@algorandfoundation/puya-ts 1.0.0-alpha.9 → 1.0.0

package/awst/index.d.ts

@@ -1,4 +1,3 @@
 export * as awst from './nodes';
-export * as wtypes from './wtypes';
 export * from './util';
 export type ConstantValue = bigint | Uint8Array | boolean | string;

package/awst/intrinsic-factory.d.ts

@@ -1,5 +1,5 @@
-import * as awst from './nodes';
 import type { Expression } from './nodes';
+import * as awst from './nodes';
 import type { SourceLocation } from './source-location';
 export declare const intrinsicFactory: {
     bytesConcat({ left, right, sourceLocation, }: {

package/awst/models.d.ts

@@ -1,4 +1,4 @@
-import type { ContractClassPType } from '../awst_build/ptypes';
+import type { ContractClassPType, LogicSigPType } from '../awst_build/ptypes';
 import type { Props } from '../typescript-helpers';
 import type { SourceLocation } from './source-location';
 export declare enum OnCompletionAction {
@@ -21,7 +21,7 @@ export declare class ARC4BareMethodConfig extends ModelBase {
     readonly sourceLocation: SourceLocation | undefined;
     readonly allowedCompletionTypes: OnCompletionAction[];
     readonly create: ARC4CreateOption;
-    readonly isBare: true;
+    readonly isBare = true;
     constructor(props: Omit<Props<ARC4BareMethodConfig>, 'isBare'>);
 }
 export type DefaultArgumentSource = {
@@ -40,7 +40,7 @@ export type DefaultArgumentSource = {
 export declare class ARC4ABIMethodConfig extends ModelBase {
     readonly sourceLocation: SourceLocation | undefined;
     readonly name: string;
-    readonly isBare: false;
+    readonly isBare = false;
     readonly create: ARC4CreateOption;
     readonly readonly: boolean;
     readonly allowedCompletionTypes: OnCompletionAction[];
@@ -72,8 +72,8 @@ export declare class LogicSigReference extends ModelBase {
     readonly moduleName: string;
     get id(): string;
     toString(): string;
+    static fromPType(logicSigPType: LogicSigPType): LogicSigReference;
 }
-export type CompilationSet = ReadonlyArray<ContractReference | LogicSigReference>;
 export declare enum TransactionKind {
     pay = 1,
     keyreg = 2,

package/awst/node-factory.d.ts

@@ -1,8 +1,8 @@
 import type { Props } from '../typescript-helpers';
 import type { Expression, Statement } from './nodes';
-import { AssignmentExpression, AssignmentStatement, BigUIntBinaryOperation, Block, BoolConstant, BooleanBinaryOperation, BytesComparisonExpression, BytesConstant, BytesEncoding, CheckedMaybe, concreteNodes, Copy, ExpressionStatement, IntegerConstant, IntrinsicCall, MethodDocumentation, Not, NumericComparisonExpression, SingleEvaluation, StringConstant, TupleExpression, TupleItemExpression, UInt64BinaryOperation, VoidConstant } from './nodes';
+import { AssignmentExpression, AssignmentStatement, BigUIntBinaryOperation, Block, BoolConstant, BooleanBinaryOperation, BytesComparisonExpression, BytesConstant, BytesEncoding, CheckedMaybe, concreteNodes, Copy, ExpressionStatement, IntegerConstant, IntrinsicCall, MethodDocumentation, Not, NumericComparisonExpression, ReinterpretCast, SingleEvaluation, StringConstant, TupleExpression, TupleItemExpression, UInt64BinaryOperation, VoidConstant } from './nodes';
 import type { SourceLocation } from './source-location';
-import type { WType } from './wtypes';
+import { wtypes } from './wtypes';
 type ConcreteNodes = typeof concreteNodes;
 declare const explicitNodeFactory: {
     voidConstant(props: {
@@ -12,18 +12,19 @@ declare const explicitNodeFactory: {
         value: Uint8Array;
         encoding?: BytesEncoding;
         sourceLocation: SourceLocation;
-        wtype?: WType;
+        wtype?: wtypes.WType;
     }): BytesConstant;
     stringConstant(props: {
         value: string;
         sourceLocation: SourceLocation;
+        wtype?: wtypes.WType;
     }): StringConstant;
-    uInt64Constant(props: {
+    uInt64Constant({ value, tealAlias, sourceLocation, }: {
         value: bigint;
         tealAlias?: string;
         sourceLocation: SourceLocation;
     }): IntegerConstant;
-    bigUIntConstant(props: {
+    bigUIntConstant({ value, sourceLocation }: {
         value: bigint;
         sourceLocation: SourceLocation;
     }): IntegerConstant;
@@ -44,7 +45,7 @@ declare const explicitNodeFactory: {
     }): SingleEvaluation;
     expressionStatement({ expr }: {
         expr: Expression;
-    }): ExpressionStatement;
+    }): ExpressionStatement | AssignmentStatement;
     block({ sourceLocation, comment, label }: {
         sourceLocation: SourceLocation;
         comment?: string;
@@ -61,7 +62,9 @@ declare const explicitNodeFactory: {
         value: Expression;
         sourceLocation: SourceLocation;
     }): AssignmentStatement;
-    tupleExpression(props: Omit<Props<TupleExpression>, "wtype">): TupleExpression;
+    tupleExpression(props: Omit<Props<TupleExpression>, "wtype"> & {
+        wtype?: wtypes.WTuple;
+    }): TupleExpression;
     methodDocumentation(props?: {
         description?: string | null;
         args?: Map<string, string>;
@@ -79,6 +82,11 @@ declare const explicitNodeFactory: {
         comment: string;
     }): CheckedMaybe;
     tupleItemExpression(props: Omit<Props<TupleItemExpression>, "wtype">): TupleItemExpression;
+    reinterpretCast({ expr, wtype, sourceLocation }: {
+        expr: Expression;
+        wtype: wtypes.WType;
+        sourceLocation: SourceLocation;
+    }): BytesConstant | ReinterpretCast;
 };
 type ExplicitNodeFactory = typeof explicitNodeFactory;
 type DefaultNodeFactory<TKey extends keyof ConcreteNodes> = (...args: ConstructorParameters<ConcreteNodes[TKey]>) => InstanceType<ConcreteNodes[TKey]>;

package/awst/nodes.d.ts

@@ -2,7 +2,7 @@ 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';
+import type { wtypes } from './wtypes';
 export declare class SubroutineID {
     constructor(props: Props<SubroutineID>);
     target: string;
@@ -80,7 +80,7 @@ export declare class IntegerConstant extends Expression {
 export declare class DecimalConstant extends Expression {
     constructor(props: Props<DecimalConstant>);
     wtype: wtypes.ARC4UFixedNxM;
-    value: number;
+    value: string;
     accept<T>(visitor: ExpressionVisitor<T>): T;
 }
 export declare class BoolConstant extends Expression {
@@ -586,8 +586,6 @@ export declare class ContractMethod extends ContractMethod_base {
     cref: ContractReference;
     memberName: string;
     arc4MethodConfig: ARC4BareMethodConfig | ARC4ABIMethodConfig | null;
-    synthetic: boolean;
-    inheritable: boolean;
     accept<T>(visitor: ContractMemberNodeVisitor<T>): T;
 }
 export declare enum AppStorageKind {
@@ -611,6 +609,7 @@ export declare class LogicSignature extends RootNode {
     shortName: string;
     program: Subroutine;
     docstring: string | null;
+    avmVersion: bigint | null;
     accept<T>(visitor: RootNodeVisitor<T>): T;
 }
 export declare class CompiledContract extends Expression {
@@ -639,24 +638,24 @@ 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>);
+export declare class Contract extends RootNode {
+    constructor(props: Props<Contract>);
     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>;
+    description: string | null;
+    methodResolutionOrder: Array<ContractReference>;
+    approvalProgram: ContractMethod;
+    clearProgram: ContractMethod;
+    methods: Array<ContractMethod>;
+    appState: Array<AppStorageDefinition>;
     stateTotals: StateTotals | null;
-    docstring: string | null;
+    reservedScratchSpace: Set<bigint>;
+    avmVersion: bigint | 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 type AWST = Contract | LogicSignature | Subroutine;
 export declare const concreteNodes: {
     readonly subroutineID: typeof SubroutineID;
     readonly expressionStatement: typeof ExpressionStatement;
@@ -746,7 +745,7 @@ export declare const concreteNodes: {
     readonly compiledLogicSig: typeof CompiledLogicSig;
     readonly stateTotals: typeof StateTotals;
     readonly aRC4Router: typeof ARC4Router;
-    readonly contractFragment: typeof ContractFragment;
+    readonly contract: typeof Contract;
     readonly uInt64Constant: typeof IntegerConstant;
     readonly bigUIntConstant: typeof IntegerConstant;
 };
@@ -836,6 +835,6 @@ export interface ContractMemberNodeVisitor<T> {
 export interface RootNodeVisitor<T> {
     visitSubroutine(rootNode: Subroutine): T;
     visitLogicSignature(rootNode: LogicSignature): T;
-    visitContractFragment(rootNode: ContractFragment): T;
+    visitContract(rootNode: Contract): T;
 }
 export {};

package/awst/source-location.d.ts

@@ -1,21 +1,25 @@
-import type ts from 'typescript';
+import ts from 'typescript';
 export declare class SourceLocation {
-    file: string;
+    file: string | null;
     line: number;
     endLine: number;
     column: number;
     endColumn: number;
+    scope: 'file' | 'range';
     constructor(props: {
-        file: string;
+        file?: string | null;
         line: number;
         endLine: number;
         column: number;
         endColumn: number;
+        scope: SourceLocation['scope'];
     });
-    static fromNode(sourceFile: ts.SourceFile, node: ts.Node, programDirectory: string): SourceLocation;
+    private static getStartAndEnd;
+    static fromNode(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;
+    static None: SourceLocation;
 }

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

@@ -82,6 +82,7 @@ export declare class ToCodeVisitor implements RootNodeVisitor<string[]>, Contrac
     visitSubroutine(moduleStatement: nodes.Subroutine): string[];
     visitContractMethod(statement: nodes.ContractMethod): string[];
     visitLogicSignature(moduleStatement: nodes.LogicSignature): string[];
-    visitContractFragment(c: nodes.ContractFragment): string[];
+    private currentContract;
+    visitContract(c: nodes.Contract): string[];
     visitSpecialMethod(statement: nodes.ContractMethod, name: string): string[];
 }

package/awst/txn-fields.d.ts

@@ -1,4 +1,4 @@
-import { wtypes } from './index';
+import { wtypes } from './wtypes';
 export declare class TxnFieldData {
     readonly immediate: string;
     readonly wtype: wtypes.WType;

package/awst/wtypes.d.ts

@@ -5,132 +5,173 @@ export declare enum AVMType {
     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 {
-    fields: Record<string, WType>;
-    constructor({ fields, name }: {
+export declare namespace wtypes {
+    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;
+    }
+    const voidWType: WType;
+    const boolWType: WType;
+    const uint64WType: WType;
+    const uint64RangeWType: WType;
+    const bytesWType: WType;
+    const stateKeyWType: WType;
+    const boxKeyWType: WType;
+    const stringWType: WType;
+    const biguintWType: WType;
+    const assetWType: WType;
+    const accountWType: WType;
+    const applicationWType: WType;
+    class ARC4Type extends WType {
+        readonly nativeType: WType | null;
+        readonly arc4Name: string;
+        constructor({ nativeType, arc4Name, ...rest }: {
+            nativeType: WType | null;
+            arc4Name: string;
+            name: string;
+            immutable?: boolean;
+            scalarType?: AVMType | null;
+            ephemeral?: boolean;
+        });
+    }
+    class WStructType extends WType {
         fields: Record<string, WType>;
-        name: string;
-    });
-}
-export declare class WTuple extends WType {
-    types: WType[];
-    constructor(props: {
+        readonly frozen = true;
+        constructor({ fields, name }: {
+            fields: Record<string, WType>;
+            name: string;
+        });
+    }
+    class WTuple extends WType {
         types: WType[];
-        immutable?: boolean;
-    });
-    toString(): string;
-}
-export declare class WArray extends WType {
-    readonly elementType: 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;
-    });
+        names: string[] | undefined;
+        constructor(props: {
+            names?: string[];
+            types: WType[];
+            immutable?: boolean;
+            name?: string;
+        });
+        equals(other: WType): boolean;
+        toString(): string;
+    }
+    class WArray extends WType {
+        readonly elementType: WType;
+        constructor(props: {
+            itemType: WType;
+            immutable: boolean;
+        });
+    }
+    class WEnumeration extends WType {
+        readonly sequenceType: WType;
+        constructor(props: {
+            sequenceType: WType;
+        });
+    }
+    class WGroupTransaction extends WType {
+        transactionType: TransactionKind | null;
+        constructor({ transactionType }: {
+            transactionType?: TransactionKind;
+        });
+    }
+    class WInnerTransaction extends WType {
+        transactionType: TransactionKind | null;
+        constructor({ transactionType }: {
+            transactionType?: TransactionKind;
+        });
+    }
+    class WInnerTransactionFields extends WType {
+        transactionType: TransactionKind | null;
+        constructor({ transactionType }: {
+            transactionType?: TransactionKind;
+        });
+    }
+    class ARC4UIntN extends ARC4Type {
+        readonly n: bigint;
+        constructor({ n, arc4Name }: {
+            n: bigint;
+            arc4Name?: string;
+        });
+    }
+    class ARC4UFixedNxM extends ARC4Type {
+        readonly n: bigint;
+        readonly m: bigint;
+        constructor({ n, m }: {
+            n: bigint;
+            m: bigint;
+        });
+    }
+    class ARC4Struct extends ARC4Type {
+        fields: Record<string, ARC4Type>;
+        sourceLocation: SourceLocation | null;
+        frozen: boolean;
+        constructor({ fields, sourceLocation, name, frozen, }: {
+            frozen: boolean;
+            name: string;
+            fields: Record<string, ARC4Type>;
+            sourceLocation?: SourceLocation;
+        });
+    }
+    class ARC4Tuple extends ARC4Type {
+        readonly types: ARC4Type[];
+        readonly sourceLocation: SourceLocation | null;
+        constructor({ types, sourceLocation }: {
+            types: ARC4Type[];
+            sourceLocation?: SourceLocation;
+        });
+    }
+    abstract class ARC4Array extends ARC4Type {
+        readonly elementType: ARC4Type;
+        protected constructor(props: {
+            arc4Name: string;
+            otherEncodeableTypes: WType[];
+            name: string;
+            elementType: ARC4Type;
+            nativeType?: WType;
+            immutable?: boolean;
+        });
+    }
+    class ARC4DynamicArray extends ARC4Array {
+        readonly sourceLocation: SourceLocation | null;
+        constructor({ elementType, sourceLocation, arc4Name, nativeType, immutable, }: {
+            elementType: ARC4Type;
+            sourceLocation?: SourceLocation;
+            arc4Name?: string;
+            nativeType?: WType;
+            immutable?: boolean;
+        });
+    }
+    class ARC4StaticArray extends ARC4Array {
+        readonly sourceLocation: SourceLocation | null;
+        readonly arraySize: bigint;
+        constructor({ elementType, sourceLocation, arraySize, arc4Name, nativeType, immutable, }: {
+            arraySize: bigint;
+            elementType: ARC4Type;
+            sourceLocation?: SourceLocation;
+            arc4Name?: string;
+            nativeType?: WType;
+            immutable?: boolean;
+        });
+    }
+    const arc4ByteAliasWType: ARC4UIntN;
+    const arc4AddressAliasWType: ARC4StaticArray;
+    const arc4BooleanWType: ARC4Type;
+    const arc4StringAliasWType: ARC4DynamicArray;
 }

package/awst_build/arc4-util.d.ts

@@ -0,0 +1,9 @@
+import type { ARC32StructDef } from '../awst/models';
+import type { SourceLocation } from '../awst/source-location';
+import type { FunctionPType, PType } from './ptypes';
+import { ARC4EncodedType, ARC4StructType } from './ptypes/arc4-types';
+export declare function ptypeToArc4PType(ptype: PType, sourceLocation: SourceLocation): PType;
+export declare function isArc4EncodableType(ptype: PType): boolean;
+export declare function ptypeToArc4EncodedType(ptype: PType, sourceLocation: SourceLocation): ARC4EncodedType;
+export declare function getFunctionTypes(ptype: FunctionPType, sourceLocation: SourceLocation): Record<string, PType>;
+export declare function getArc4StructDef(ptype: ARC4StructType): ARC32StructDef;

package/awst_build/{base-visitor.d.ts → ast-visitors/base-visitor.d.ts}

@@ -1,12 +1,12 @@
 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 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;
@@ -84,4 +84,10 @@ export declare abstract class BaseVisitor implements Visitor<Expressions, NodeBu
      */
     private buildAssignmentExpressionType;
     buildLValue(target: InstanceBuilder, assignmentType: PType, sourceLocation: SourceLocation): LValue;
+    protected parseMemberModifiers(node: {
+        modifiers?: readonly ts.ModifierLike[];
+    }): {
+        isStatic: boolean;
+        isPublic: boolean;
+    };
 }

package/awst_build/{constructor-visitor.d.ts → ast-visitors/constructor-visitor.d.ts}

@@ -1,7 +1,7 @@
 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 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[];

package/awst_build/{contract-method-visitor.d.ts → ast-visitors/contract-method-visitor.d.ts}

@@ -1,20 +1,19 @@
-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 ts from 'typescript';
+import * as awst from '../../awst/nodes';
+import type { AwstBuildContext } from '../context/awst-build-context';
+import type { NodeBuilder } from '../eb';
+import { ContractClassPType } from '../ptypes';
 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);
+    private readonly _contractType;
+    constructor(ctx: AwstBuildContext, node: ts.MethodDeclaration, contractType: ContractClassPType);
     get result(): awst.ContractMethod;
-    static buildContractMethod(parentCtx: AwstBuildContext, node: ts.MethodDeclaration, contractMethodInfo: ContractMethodInfo): awst.ContractMethod;
+    static buildContractMethod(parentCtx: AwstBuildContext, node: ts.MethodDeclaration, contractType: ContractClassPType): awst.ContractMethod;
+    private buildArc4Config;
+    private buildDefaultArgument;
 }