@algorandfoundation/puya-ts 1.0.0-alpha.4

package/awst/nodes.d.ts

@@ -0,0 +1,841 @@
+import type { Props } from '../typescript-helpers';
+import type { ARC4ABIMethodConfig, ARC4BareMethodConfig, ContractReference, LogicSigReference } from './models';
+import type { SourceLocation } from './source-location';
+import type { TxnField } from './txn-fields';
+import type * as wtypes from './wtypes';
+export declare class SubroutineID {
+    constructor(props: Props<SubroutineID>);
+    target: string;
+}
+export declare abstract class Node {
+    constructor(props: Props<Node>);
+    sourceLocation: SourceLocation;
+}
+export declare abstract class Statement extends Node {
+    constructor(props: Props<Statement>);
+    abstract accept<T>(visitor: StatementVisitor<T>): T;
+}
+export declare abstract class Expression extends Node {
+    constructor(props: Props<Expression>);
+    wtype: wtypes.WType;
+    abstract accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class ExpressionStatement extends Statement {
+    constructor(props: Props<ExpressionStatement>);
+    expr: Expression;
+    sourceLocation: SourceLocation;
+    accept<T>(visitor: StatementVisitor<T>): T;
+}
+export declare class Block extends Statement {
+    constructor(props: Props<Block>);
+    body: Array<Statement>;
+    label: string | null;
+    comment: string | null;
+    accept<T>(visitor: StatementVisitor<T>): T;
+}
+export declare class Goto extends Statement {
+    constructor(props: Props<Goto>);
+    target: string;
+    accept<T>(visitor: StatementVisitor<T>): T;
+}
+export declare class IfElse extends Statement {
+    constructor(props: Props<IfElse>);
+    condition: Expression;
+    ifBranch: Block;
+    elseBranch: Block | null;
+    accept<T>(visitor: StatementVisitor<T>): T;
+}
+export declare class Switch extends Statement {
+    constructor(props: Props<Switch>);
+    value: Expression;
+    cases: Map<Expression, Block>;
+    defaultCase: Block | null;
+    accept<T>(visitor: StatementVisitor<T>): T;
+}
+export declare class WhileLoop extends Statement {
+    constructor(props: Props<WhileLoop>);
+    condition: Expression;
+    loopBody: Block;
+    accept<T>(visitor: StatementVisitor<T>): T;
+}
+export declare class LoopExit extends Statement {
+    constructor(props: Props<LoopExit>);
+    accept<T>(visitor: StatementVisitor<T>): T;
+}
+export declare class LoopContinue extends Statement {
+    constructor(props: Props<LoopContinue>);
+    accept<T>(visitor: StatementVisitor<T>): T;
+}
+export declare class ReturnStatement extends Statement {
+    constructor(props: Props<ReturnStatement>);
+    value: Expression | null;
+    accept<T>(visitor: StatementVisitor<T>): T;
+}
+export declare class IntegerConstant extends Expression {
+    constructor(props: Props<IntegerConstant>);
+    value: bigint;
+    tealAlias: string | null;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class DecimalConstant extends Expression {
+    constructor(props: Props<DecimalConstant>);
+    wtype: wtypes.ARC4UFixedNxM;
+    value: number;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class BoolConstant extends Expression {
+    constructor(props: Props<BoolConstant>);
+    value: boolean;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare enum BytesEncoding {
+    unknown = "unknown",
+    base16 = "base16",
+    base32 = "base32",
+    base64 = "base64",
+    utf8 = "utf8"
+}
+export declare class BytesConstant extends Expression {
+    constructor(props: Props<BytesConstant>);
+    value: Uint8Array;
+    encoding: BytesEncoding;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class StringConstant extends Expression {
+    constructor(props: Props<StringConstant>);
+    value: string;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class VoidConstant extends Expression {
+    constructor(props: Props<VoidConstant>);
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class TemplateVar extends Expression {
+    constructor(props: Props<TemplateVar>);
+    name: string;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class MethodConstant extends Expression {
+    constructor(props: Props<MethodConstant>);
+    value: string;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class AddressConstant extends Expression {
+    constructor(props: Props<AddressConstant>);
+    value: string;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class ARC4Encode extends Expression {
+    constructor(props: Props<ARC4Encode>);
+    value: Expression;
+    wtype: wtypes.ARC4Type;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class Copy extends Expression {
+    constructor(props: Props<Copy>);
+    value: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class ArrayConcat extends Expression {
+    constructor(props: Props<ArrayConcat>);
+    left: Expression;
+    right: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class ArrayPop extends Expression {
+    constructor(props: Props<ArrayPop>);
+    base: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class ArrayExtend extends Expression {
+    constructor(props: Props<ArrayExtend>);
+    base: Expression;
+    other: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class ARC4Decode extends Expression {
+    constructor(props: Props<ARC4Decode>);
+    value: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class IntrinsicCall extends Expression {
+    constructor(props: Props<IntrinsicCall>);
+    opCode: string;
+    immediates: Array<string | bigint>;
+    stackArgs: Array<Expression>;
+    comment: string | null;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class CreateInnerTransaction extends Expression {
+    constructor(props: Props<CreateInnerTransaction>);
+    wtype: wtypes.WInnerTransactionFields;
+    fields: Map<TxnField, Expression>;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class UpdateInnerTransaction extends Expression {
+    constructor(props: Props<UpdateInnerTransaction>);
+    itxn: Expression;
+    fields: Map<TxnField, Expression>;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class GroupTransactionReference extends Expression {
+    constructor(props: Props<GroupTransactionReference>);
+    index: Expression;
+    wtype: wtypes.WGroupTransaction;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class CheckedMaybe extends Expression {
+    constructor(props: Props<CheckedMaybe>);
+    expr: Expression;
+    comment: string;
+    sourceLocation: SourceLocation;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class TupleExpression extends Expression {
+    constructor(props: Props<TupleExpression>);
+    items: Array<Expression>;
+    wtype: wtypes.WTuple;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class TupleItemExpression extends Expression {
+    constructor(props: Props<TupleItemExpression>);
+    base: Expression;
+    index: bigint;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class VarExpression extends Expression {
+    constructor(props: Props<VarExpression>);
+    name: string;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class InnerTransactionField extends Expression {
+    constructor(props: Props<InnerTransactionField>);
+    itxn: Expression;
+    field: TxnField;
+    arrayIndex: Expression | null;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class SubmitInnerTransaction extends Expression {
+    constructor(props: Props<SubmitInnerTransaction>);
+    itxns: Array<Expression>;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class FieldExpression extends Expression {
+    constructor(props: Props<FieldExpression>);
+    base: Expression;
+    name: string;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class IndexExpression extends Expression {
+    constructor(props: Props<IndexExpression>);
+    base: Expression;
+    index: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class SliceExpression extends Expression {
+    constructor(props: Props<SliceExpression>);
+    base: Expression;
+    beginIndex: Expression | null;
+    endIndex: Expression | null;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class IntersectionSliceExpression extends Expression {
+    constructor(props: Props<IntersectionSliceExpression>);
+    base: Expression;
+    beginIndex: Expression | bigint | null;
+    endIndex: Expression | bigint | null;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class AppStateExpression extends Expression {
+    constructor(props: Props<AppStateExpression>);
+    key: Expression;
+    existsAssertionMessage: string | null;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class AppAccountStateExpression extends Expression {
+    constructor(props: Props<AppAccountStateExpression>);
+    key: Expression;
+    existsAssertionMessage: string | null;
+    account: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class BoxValueExpression extends Expression {
+    constructor(props: Props<BoxValueExpression>);
+    key: Expression;
+    existsAssertionMessage: string | null;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class SingleEvaluation extends Expression {
+    constructor(props: Props<SingleEvaluation>);
+    source: Expression;
+    id: bigint;
+    sourceLocation: SourceLocation;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class ReinterpretCast extends Expression {
+    constructor(props: Props<ReinterpretCast>);
+    expr: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class NewArray extends Expression {
+    constructor(props: Props<NewArray>);
+    wtype: wtypes.WArray | wtypes.ARC4Array;
+    values: Array<Expression>;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class ConditionalExpression extends Expression {
+    constructor(props: Props<ConditionalExpression>);
+    condition: Expression;
+    trueExpr: Expression;
+    falseExpr: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class AssignmentStatement extends Statement {
+    constructor(props: Props<AssignmentStatement>);
+    target: VarExpression | FieldExpression | IndexExpression | TupleExpression | AppStateExpression | AppAccountStateExpression | BoxValueExpression;
+    value: Expression;
+    accept<T>(visitor: StatementVisitor<T>): T;
+}
+export declare class AssignmentExpression extends Expression {
+    constructor(props: Props<AssignmentExpression>);
+    target: VarExpression | FieldExpression | IndexExpression | TupleExpression | AppStateExpression | AppAccountStateExpression | BoxValueExpression;
+    value: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare enum EqualityComparison {
+    eq = "==",
+    ne = "!="
+}
+export declare enum NumericComparison {
+    eq = "==",
+    ne = "!=",
+    lt = "<",
+    lte = "<=",
+    gt = ">",
+    gte = ">="
+}
+export declare class NumericComparisonExpression extends Expression {
+    constructor(props: Props<NumericComparisonExpression>);
+    lhs: Expression;
+    operator: NumericComparison;
+    rhs: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class BytesComparisonExpression extends Expression {
+    constructor(props: Props<BytesComparisonExpression>);
+    lhs: Expression;
+    operator: EqualityComparison;
+    rhs: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class InstanceMethodTarget {
+    constructor(props: Props<InstanceMethodTarget>);
+    memberName: string;
+}
+export declare class InstanceSuperMethodTarget {
+    constructor(props: Props<InstanceSuperMethodTarget>);
+    memberName: string;
+}
+export declare class ContractMethodTarget {
+    constructor(props: Props<ContractMethodTarget>);
+    cref: ContractReference;
+    memberName: string;
+}
+export declare class CallArg {
+    constructor(props: Props<CallArg>);
+    name: string | null;
+    value: Expression;
+}
+export declare class SubroutineCallExpression extends Expression {
+    constructor(props: Props<SubroutineCallExpression>);
+    target: SubroutineID | InstanceMethodTarget | InstanceSuperMethodTarget | ContractMethodTarget;
+    args: Array<CallArg>;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class PuyaLibData {
+    constructor(props: Props<PuyaLibData>);
+    id: string;
+    params: Map<string, wtypes.WType>;
+    wtype: wtypes.WType;
+}
+export declare enum PuyaLibFunction {
+    ensureBudget = "ensure_budget",
+    isSubstring = "is_substring"
+}
+export declare class PuyaLibCall extends Expression {
+    constructor(props: Props<PuyaLibCall>);
+    func: PuyaLibFunction;
+    args: Array<CallArg>;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare enum UInt64BinaryOperator {
+    add = "+",
+    sub = "-",
+    mult = "*",
+    floorDiv = "//",
+    mod = "%",
+    pow = "**",
+    lshift = "<<",
+    rshift = ">>",
+    bitOr = "|",
+    bitXor = "^",
+    bitAnd = "&"
+}
+export declare enum BigUIntBinaryOperator {
+    add = "+",
+    sub = "-",
+    mult = "*",
+    floorDiv = "//",
+    mod = "%",
+    bitOr = "|",
+    bitXor = "^",
+    bitAnd = "&"
+}
+export declare enum BytesBinaryOperator {
+    add = "+",
+    bitOr = "|",
+    bitXor = "^",
+    bitAnd = "&"
+}
+export declare enum BytesUnaryOperator {
+    bitInvert = "~"
+}
+export declare enum UInt64UnaryOperator {
+    bitInvert = "~"
+}
+export declare enum UInt64PostfixUnaryOperator {
+    increment = "++",
+    decrement = "--"
+}
+export declare class UInt64UnaryOperation extends Expression {
+    constructor(props: Props<UInt64UnaryOperation>);
+    op: UInt64UnaryOperator;
+    expr: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class UInt64PostfixUnaryOperation extends Expression {
+    constructor(props: Props<UInt64PostfixUnaryOperation>);
+    op: UInt64PostfixUnaryOperator;
+    target: VarExpression | FieldExpression | IndexExpression | TupleExpression | AppStateExpression | AppAccountStateExpression | BoxValueExpression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare enum BigUIntPostfixUnaryOperator {
+    increment = "++",
+    decrement = "--"
+}
+export declare class BigUIntPostfixUnaryOperation extends Expression {
+    constructor(props: Props<BigUIntPostfixUnaryOperation>);
+    op: BigUIntPostfixUnaryOperator;
+    target: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class BytesUnaryOperation extends Expression {
+    constructor(props: Props<BytesUnaryOperation>);
+    op: BytesUnaryOperator;
+    expr: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class UInt64BinaryOperation extends Expression {
+    constructor(props: Props<UInt64BinaryOperation>);
+    left: Expression;
+    op: UInt64BinaryOperator;
+    right: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class BigUIntBinaryOperation extends Expression {
+    constructor(props: Props<BigUIntBinaryOperation>);
+    left: Expression;
+    op: BigUIntBinaryOperator;
+    right: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class BytesBinaryOperation extends Expression {
+    constructor(props: Props<BytesBinaryOperation>);
+    left: Expression;
+    op: BytesBinaryOperator;
+    right: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare enum BinaryBooleanOperator {
+    and = "and",
+    or = "or"
+}
+export declare class BooleanBinaryOperation extends Expression {
+    constructor(props: Props<BooleanBinaryOperation>);
+    left: Expression;
+    op: BinaryBooleanOperator;
+    right: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class Not extends Expression {
+    constructor(props: Props<Not>);
+    expr: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class UInt64AugmentedAssignment extends Statement {
+    constructor(props: Props<UInt64AugmentedAssignment>);
+    target: VarExpression | FieldExpression | IndexExpression | TupleExpression | AppStateExpression | AppAccountStateExpression | BoxValueExpression;
+    op: UInt64BinaryOperator;
+    value: Expression;
+    accept<T>(visitor: StatementVisitor<T>): T;
+}
+export declare class BigUIntAugmentedAssignment extends Statement {
+    constructor(props: Props<BigUIntAugmentedAssignment>);
+    target: VarExpression | FieldExpression | IndexExpression | TupleExpression | AppStateExpression | AppAccountStateExpression | BoxValueExpression;
+    op: BigUIntBinaryOperator;
+    value: Expression;
+    accept<T>(visitor: StatementVisitor<T>): T;
+}
+export declare class BytesAugmentedAssignment extends Statement {
+    constructor(props: Props<BytesAugmentedAssignment>);
+    target: VarExpression | FieldExpression | IndexExpression | TupleExpression | AppStateExpression | AppAccountStateExpression | BoxValueExpression;
+    op: BytesBinaryOperator;
+    value: Expression;
+    accept<T>(visitor: StatementVisitor<T>): T;
+}
+export declare class Range extends Expression {
+    constructor(props: Props<Range>);
+    start: Expression;
+    stop: Expression;
+    step: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class Enumeration extends Expression {
+    constructor(props: Props<Enumeration>);
+    expr: Expression;
+    wtype: wtypes.WEnumeration;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class Reversed extends Expression {
+    constructor(props: Props<Reversed>);
+    expr: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class ForInLoop extends Statement {
+    constructor(props: Props<ForInLoop>);
+    sequence: Expression;
+    items: VarExpression | FieldExpression | IndexExpression | TupleExpression | AppStateExpression | AppAccountStateExpression | BoxValueExpression;
+    loopBody: Block;
+    accept<T>(visitor: StatementVisitor<T>): T;
+}
+export declare class StateGet extends Expression {
+    constructor(props: Props<StateGet>);
+    field: AppStateExpression | AppAccountStateExpression | BoxValueExpression;
+    default: Expression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class StateGetEx extends Expression {
+    constructor(props: Props<StateGetEx>);
+    field: AppStateExpression | AppAccountStateExpression | BoxValueExpression;
+    wtype: wtypes.WTuple;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class StateExists extends Expression {
+    constructor(props: Props<StateExists>);
+    field: AppStateExpression | AppAccountStateExpression | BoxValueExpression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class StateDelete extends Expression {
+    constructor(props: Props<StateDelete>);
+    field: AppStateExpression | AppAccountStateExpression | BoxValueExpression;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class NewStruct extends Expression {
+    constructor(props: Props<NewStruct>);
+    wtype: wtypes.WStructType | wtypes.ARC4Struct;
+    values: Map<string, Expression>;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare abstract class RootNode extends Node {
+    constructor(props: Props<RootNode>);
+    abstract accept<T>(visitor: RootNodeVisitor<T>): T;
+}
+export declare class SubroutineArgument {
+    constructor(props: Props<SubroutineArgument>);
+    name: string;
+    wtype: wtypes.WType;
+    sourceLocation: SourceLocation | null;
+}
+export declare class MethodDocumentation {
+    constructor(props: Props<MethodDocumentation>);
+    description: string | null;
+    args: Map<string, string>;
+    returns: string | null;
+}
+export declare abstract class _Function extends Node {
+    constructor(props: Props<_Function>);
+    args: Array<SubroutineArgument>;
+    returnType: wtypes.WType;
+    body: Block;
+    documentation: MethodDocumentation;
+}
+declare const Subroutine_base: import("polytype").Polytype.ClusteredConstructor<[typeof _Function, typeof RootNode]>;
+export declare class Subroutine extends Subroutine_base {
+    constructor(props: Props<Subroutine>);
+    id: string;
+    name: string;
+    accept<T>(visitor: RootNodeVisitor<T>): T;
+}
+export declare abstract class ContractMemberNode extends Node {
+    constructor(props: Props<ContractMemberNode>);
+    abstract accept<T>(visitor: ContractMemberNodeVisitor<T>): T;
+}
+declare const ContractMethod_base: import("polytype").Polytype.ClusteredConstructor<[typeof _Function, typeof ContractMemberNode]>;
+export declare class ContractMethod extends ContractMethod_base {
+    constructor(props: Props<ContractMethod>);
+    cref: ContractReference;
+    memberName: string;
+    arc4MethodConfig: ARC4BareMethodConfig | ARC4ABIMethodConfig | null;
+    synthetic: boolean;
+    inheritable: boolean;
+    accept<T>(visitor: ContractMemberNodeVisitor<T>): T;
+}
+export declare enum AppStorageKind {
+    appGlobal = 1,
+    accountLocal = 2,
+    box = 3
+}
+export declare class AppStorageDefinition extends ContractMemberNode {
+    constructor(props: Props<AppStorageDefinition>);
+    memberName: string;
+    kind: AppStorageKind;
+    storageWtype: wtypes.WType;
+    keyWtype: wtypes.WType | null;
+    key: BytesConstant;
+    description: string | null;
+    accept<T>(visitor: ContractMemberNodeVisitor<T>): T;
+}
+export declare class LogicSignature extends RootNode {
+    constructor(props: Props<LogicSignature>);
+    id: LogicSigReference;
+    shortName: string;
+    program: Subroutine;
+    docstring: string | null;
+    accept<T>(visitor: RootNodeVisitor<T>): T;
+}
+export declare class CompiledContract extends Expression {
+    constructor(props: Props<CompiledContract>);
+    contract: ContractReference;
+    allocationOverrides: Map<TxnField, Expression>;
+    prefix: string | null;
+    templateVariables: Map<string, Expression>;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class CompiledLogicSig extends Expression {
+    constructor(props: Props<CompiledLogicSig>);
+    logicSig: LogicSigReference;
+    prefix: string | null;
+    templateVariables: Map<string, Expression>;
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class StateTotals {
+    constructor(props: Props<StateTotals>);
+    globalUints: bigint | null;
+    localUints: bigint | null;
+    globalBytes: bigint | null;
+    localBytes: bigint | null;
+}
+export declare class ARC4Router extends Expression {
+    constructor(props: Props<ARC4Router>);
+    accept<T>(visitor: ExpressionVisitor<T>): T;
+}
+export declare class ContractFragment extends RootNode {
+    constructor(props: Props<ContractFragment>);
+    id: ContractReference;
+    name: string;
+    bases: Array<ContractReference>;
+    init: ContractMethod | null;
+    approvalProgram: ContractMethod | null;
+    clearProgram: ContractMethod | null;
+    subroutines: Array<ContractMethod>;
+    appState: Map<string, AppStorageDefinition>;
+    reservedScratchSpace: Set<bigint>;
+    stateTotals: StateTotals | null;
+    docstring: string | null;
+    accept<T>(visitor: RootNodeVisitor<T>): T;
+}
+export type LValue = VarExpression | FieldExpression | IndexExpression | TupleExpression | AppStateExpression | AppAccountStateExpression;
+export type Constant = IntegerConstant | BoolConstant | BytesConstant | StringConstant;
+export type AWST = ContractFragment | LogicSignature | Subroutine;
+export declare const concreteNodes: {
+    readonly subroutineID: typeof SubroutineID;
+    readonly expressionStatement: typeof ExpressionStatement;
+    readonly block: typeof Block;
+    readonly goto: typeof Goto;
+    readonly ifElse: typeof IfElse;
+    readonly switch: typeof Switch;
+    readonly whileLoop: typeof WhileLoop;
+    readonly loopExit: typeof LoopExit;
+    readonly loopContinue: typeof LoopContinue;
+    readonly returnStatement: typeof ReturnStatement;
+    readonly integerConstant: typeof IntegerConstant;
+    readonly decimalConstant: typeof DecimalConstant;
+    readonly boolConstant: typeof BoolConstant;
+    readonly bytesConstant: typeof BytesConstant;
+    readonly stringConstant: typeof StringConstant;
+    readonly voidConstant: typeof VoidConstant;
+    readonly templateVar: typeof TemplateVar;
+    readonly methodConstant: typeof MethodConstant;
+    readonly addressConstant: typeof AddressConstant;
+    readonly aRC4Encode: typeof ARC4Encode;
+    readonly copy: typeof Copy;
+    readonly arrayConcat: typeof ArrayConcat;
+    readonly arrayPop: typeof ArrayPop;
+    readonly arrayExtend: typeof ArrayExtend;
+    readonly aRC4Decode: typeof ARC4Decode;
+    readonly intrinsicCall: typeof IntrinsicCall;
+    readonly createInnerTransaction: typeof CreateInnerTransaction;
+    readonly updateInnerTransaction: typeof UpdateInnerTransaction;
+    readonly groupTransactionReference: typeof GroupTransactionReference;
+    readonly checkedMaybe: typeof CheckedMaybe;
+    readonly tupleExpression: typeof TupleExpression;
+    readonly tupleItemExpression: typeof TupleItemExpression;
+    readonly varExpression: typeof VarExpression;
+    readonly innerTransactionField: typeof InnerTransactionField;
+    readonly submitInnerTransaction: typeof SubmitInnerTransaction;
+    readonly fieldExpression: typeof FieldExpression;
+    readonly indexExpression: typeof IndexExpression;
+    readonly sliceExpression: typeof SliceExpression;
+    readonly intersectionSliceExpression: typeof IntersectionSliceExpression;
+    readonly appStateExpression: typeof AppStateExpression;
+    readonly appAccountStateExpression: typeof AppAccountStateExpression;
+    readonly boxValueExpression: typeof BoxValueExpression;
+    readonly singleEvaluation: typeof SingleEvaluation;
+    readonly reinterpretCast: typeof ReinterpretCast;
+    readonly newArray: typeof NewArray;
+    readonly conditionalExpression: typeof ConditionalExpression;
+    readonly assignmentStatement: typeof AssignmentStatement;
+    readonly assignmentExpression: typeof AssignmentExpression;
+    readonly numericComparisonExpression: typeof NumericComparisonExpression;
+    readonly bytesComparisonExpression: typeof BytesComparisonExpression;
+    readonly instanceMethodTarget: typeof InstanceMethodTarget;
+    readonly instanceSuperMethodTarget: typeof InstanceSuperMethodTarget;
+    readonly contractMethodTarget: typeof ContractMethodTarget;
+    readonly callArg: typeof CallArg;
+    readonly subroutineCallExpression: typeof SubroutineCallExpression;
+    readonly puyaLibData: typeof PuyaLibData;
+    readonly puyaLibCall: typeof PuyaLibCall;
+    readonly uInt64UnaryOperation: typeof UInt64UnaryOperation;
+    readonly uInt64PostfixUnaryOperation: typeof UInt64PostfixUnaryOperation;
+    readonly bigUIntPostfixUnaryOperation: typeof BigUIntPostfixUnaryOperation;
+    readonly bytesUnaryOperation: typeof BytesUnaryOperation;
+    readonly uInt64BinaryOperation: typeof UInt64BinaryOperation;
+    readonly bigUIntBinaryOperation: typeof BigUIntBinaryOperation;
+    readonly bytesBinaryOperation: typeof BytesBinaryOperation;
+    readonly booleanBinaryOperation: typeof BooleanBinaryOperation;
+    readonly not: typeof Not;
+    readonly uInt64AugmentedAssignment: typeof UInt64AugmentedAssignment;
+    readonly bigUIntAugmentedAssignment: typeof BigUIntAugmentedAssignment;
+    readonly bytesAugmentedAssignment: typeof BytesAugmentedAssignment;
+    readonly range: typeof Range;
+    readonly enumeration: typeof Enumeration;
+    readonly reversed: typeof Reversed;
+    readonly forInLoop: typeof ForInLoop;
+    readonly stateGet: typeof StateGet;
+    readonly stateGetEx: typeof StateGetEx;
+    readonly stateExists: typeof StateExists;
+    readonly stateDelete: typeof StateDelete;
+    readonly newStruct: typeof NewStruct;
+    readonly subroutineArgument: typeof SubroutineArgument;
+    readonly methodDocumentation: typeof MethodDocumentation;
+    readonly subroutine: typeof Subroutine;
+    readonly contractMethod: typeof ContractMethod;
+    readonly appStorageDefinition: typeof AppStorageDefinition;
+    readonly logicSignature: typeof LogicSignature;
+    readonly compiledContract: typeof CompiledContract;
+    readonly compiledLogicSig: typeof CompiledLogicSig;
+    readonly stateTotals: typeof StateTotals;
+    readonly aRC4Router: typeof ARC4Router;
+    readonly contractFragment: typeof ContractFragment;
+    readonly uInt64Constant: typeof IntegerConstant;
+    readonly bigUIntConstant: typeof IntegerConstant;
+};
+export interface ExpressionVisitor<T> {
+    visitIntegerConstant(expression: IntegerConstant): T;
+    visitDecimalConstant(expression: DecimalConstant): T;
+    visitBoolConstant(expression: BoolConstant): T;
+    visitBytesConstant(expression: BytesConstant): T;
+    visitStringConstant(expression: StringConstant): T;
+    visitVoidConstant(expression: VoidConstant): T;
+    visitTemplateVar(expression: TemplateVar): T;
+    visitMethodConstant(expression: MethodConstant): T;
+    visitAddressConstant(expression: AddressConstant): T;
+    visitARC4Encode(expression: ARC4Encode): T;
+    visitCopy(expression: Copy): T;
+    visitArrayConcat(expression: ArrayConcat): T;
+    visitArrayPop(expression: ArrayPop): T;
+    visitArrayExtend(expression: ArrayExtend): T;
+    visitARC4Decode(expression: ARC4Decode): T;
+    visitIntrinsicCall(expression: IntrinsicCall): T;
+    visitCreateInnerTransaction(expression: CreateInnerTransaction): T;
+    visitUpdateInnerTransaction(expression: UpdateInnerTransaction): T;
+    visitGroupTransactionReference(expression: GroupTransactionReference): T;
+    visitCheckedMaybe(expression: CheckedMaybe): T;
+    visitTupleExpression(expression: TupleExpression): T;
+    visitTupleItemExpression(expression: TupleItemExpression): T;
+    visitVarExpression(expression: VarExpression): T;
+    visitInnerTransactionField(expression: InnerTransactionField): T;
+    visitSubmitInnerTransaction(expression: SubmitInnerTransaction): T;
+    visitFieldExpression(expression: FieldExpression): T;
+    visitIndexExpression(expression: IndexExpression): T;
+    visitSliceExpression(expression: SliceExpression): T;
+    visitIntersectionSliceExpression(expression: IntersectionSliceExpression): T;
+    visitAppStateExpression(expression: AppStateExpression): T;
+    visitAppAccountStateExpression(expression: AppAccountStateExpression): T;
+    visitBoxValueExpression(expression: BoxValueExpression): T;
+    visitSingleEvaluation(expression: SingleEvaluation): T;
+    visitReinterpretCast(expression: ReinterpretCast): T;
+    visitNewArray(expression: NewArray): T;
+    visitConditionalExpression(expression: ConditionalExpression): T;
+    visitAssignmentExpression(expression: AssignmentExpression): T;
+    visitNumericComparisonExpression(expression: NumericComparisonExpression): T;
+    visitBytesComparisonExpression(expression: BytesComparisonExpression): T;
+    visitSubroutineCallExpression(expression: SubroutineCallExpression): T;
+    visitPuyaLibCall(expression: PuyaLibCall): T;
+    visitUInt64UnaryOperation(expression: UInt64UnaryOperation): T;
+    visitUInt64PostfixUnaryOperation(expression: UInt64PostfixUnaryOperation): T;
+    visitBigUIntPostfixUnaryOperation(expression: BigUIntPostfixUnaryOperation): T;
+    visitBytesUnaryOperation(expression: BytesUnaryOperation): T;
+    visitUInt64BinaryOperation(expression: UInt64BinaryOperation): T;
+    visitBigUIntBinaryOperation(expression: BigUIntBinaryOperation): T;
+    visitBytesBinaryOperation(expression: BytesBinaryOperation): T;
+    visitBooleanBinaryOperation(expression: BooleanBinaryOperation): T;
+    visitNot(expression: Not): T;
+    visitRange(expression: Range): T;
+    visitEnumeration(expression: Enumeration): T;
+    visitReversed(expression: Reversed): T;
+    visitStateGet(expression: StateGet): T;
+    visitStateGetEx(expression: StateGetEx): T;
+    visitStateExists(expression: StateExists): T;
+    visitStateDelete(expression: StateDelete): T;
+    visitNewStruct(expression: NewStruct): T;
+    visitCompiledContract(expression: CompiledContract): T;
+    visitCompiledLogicSig(expression: CompiledLogicSig): T;
+    visitARC4Router(expression: ARC4Router): T;
+}
+export interface StatementVisitor<T> {
+    visitExpressionStatement(statement: ExpressionStatement): T;
+    visitBlock(statement: Block): T;
+    visitGoto(statement: Goto): T;
+    visitIfElse(statement: IfElse): T;
+    visitSwitch(statement: Switch): T;
+    visitWhileLoop(statement: WhileLoop): T;
+    visitLoopExit(statement: LoopExit): T;
+    visitLoopContinue(statement: LoopContinue): T;
+    visitReturnStatement(statement: ReturnStatement): T;
+    visitAssignmentStatement(statement: AssignmentStatement): T;
+    visitUInt64AugmentedAssignment(statement: UInt64AugmentedAssignment): T;
+    visitBigUIntAugmentedAssignment(statement: BigUIntAugmentedAssignment): T;
+    visitBytesAugmentedAssignment(statement: BytesAugmentedAssignment): T;
+    visitForInLoop(statement: ForInLoop): T;
+}
+export interface ContractMemberNodeVisitor<T> {
+    visitContractMethod(contractMemberNode: ContractMethod): T;
+    visitAppStorageDefinition(contractMemberNode: AppStorageDefinition): T;
+}
+export interface RootNodeVisitor<T> {
+    visitSubroutine(rootNode: Subroutine): T;
+    visitLogicSignature(rootNode: LogicSignature): T;
+    visitContractFragment(rootNode: ContractFragment): T;
+}
+export {};