@algorandfoundation/puya-ts 1.0.0-alpha.10

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

@@ -0,0 +1,37 @@
+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 { InstanceExpressionBuilder } from '../index';
+export type FieldMapping = Record<string, [string, PType]>;
+export declare abstract class ReferenceTypeExpressionBuilder extends InstanceExpressionBuilder<PType> {
+    protected options: {
+        ptype: PType;
+        backingType: PType;
+        backingMember: string;
+        fieldMapping: FieldMapping;
+        fieldOpCode: string;
+        fieldBoolComment: string;
+    };
+    constructor(expr: Expression, options: {
+        ptype: PType;
+        backingType: PType;
+        backingMember: string;
+        fieldMapping: FieldMapping;
+        fieldOpCode: string;
+        fieldBoolComment: string;
+    });
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare abstract class Uint64BackedReferenceTypeExpressionBuilder extends ReferenceTypeExpressionBuilder {
+    constructor(expr: Expression, options: {
+        ptype: PType;
+        backingMember: string;
+        fieldMapping: FieldMapping;
+        fieldOpCode: string;
+        fieldBoolComment: string;
+    });
+    toBytes(sourceLocation: SourceLocation): Expression;
+    boolEval(sourceLocation: SourceLocation, negate?: boolean): Expression;
+    compare(other: InstanceBuilder, op: BuilderComparisonOp, sourceLocation: SourceLocation): InstanceBuilder;
+}

package/awst_build/eb/storage/box.d.ts

@@ -0,0 +1,50 @@
+import type { BoxValueExpression, Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import { AppStorageDeclaration } from '../../contract-data';
+import type { ContractClassPType, PType } from '../../ptypes';
+import { BoxMapPType, BoxPType, BoxRefPType } from '../../ptypes';
+import type { InstanceBuilder, NodeBuilder } from '../index';
+import { FunctionBuilder, InstanceExpressionBuilder } from '../index';
+export declare class BoxFunctionBuilder extends FunctionBuilder {
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class BoxRefFunctionBuilder extends FunctionBuilder {
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class BoxMapFunctionBuilder extends FunctionBuilder {
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare abstract class BoxProxyExpressionBuilder<TProxyType extends BoxMapPType | BoxRefPType | BoxPType> extends InstanceExpressionBuilder<TProxyType> {
+    buildStorageDeclaration(memberName: string, memberLocation: SourceLocation, contractType: ContractClassPType): AppStorageDeclaration;
+}
+export declare class BoxMapExpressionBuilder extends BoxProxyExpressionBuilder<BoxMapPType> {
+    constructor(expr: Expression, ptype: PType);
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class BoxRefExpressionBuilder extends BoxProxyExpressionBuilder<BoxRefPType> {
+    constructor(expr: Expression, ptype: PType);
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare abstract class BoxRefBaseFunctionBuilder extends FunctionBuilder {
+    protected readonly boxValue: BoxValueExpression;
+    constructor(boxValue: BoxValueExpression);
+}
+export declare class BoxRefCreateFunctionBuilder extends BoxRefBaseFunctionBuilder {
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class BoxRefExtractFunctionBuilder extends BoxRefBaseFunctionBuilder {
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class BoxRefReplaceFunctionBuilder extends BoxRefBaseFunctionBuilder {
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class BoxRefPutFunctionBuilder extends BoxRefBaseFunctionBuilder {
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class BoxRefSpliceFunctionBuilder extends BoxRefBaseFunctionBuilder {
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class BoxExpressionBuilder extends BoxProxyExpressionBuilder<BoxPType> {
+    constructor(expr: Expression, ptype: PType);
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}

package/awst_build/eb/storage/global-state.d.ts

@@ -0,0 +1,29 @@
+import type { Expression, LValue } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import { AppStorageDeclaration } from '../../contract-data';
+import type { ContractClassPType, PType } from '../../ptypes';
+import { GlobalStateType } from '../../ptypes';
+import type { NodeBuilder } from '../index';
+import { FunctionBuilder, InstanceBuilder, InstanceExpressionBuilder } from '../index';
+export declare class GlobalStateFunctionBuilder extends FunctionBuilder {
+    constructor(sourceLocation: SourceLocation);
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
+}
+export declare class GlobalStateExpressionBuilder extends InstanceExpressionBuilder<GlobalStateType> {
+    constructor(expr: Expression, ptype: PType);
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+    private buildField;
+}
+export declare class GlobalStateFunctionResultBuilder extends InstanceBuilder<GlobalStateType> {
+    resolve(): Expression;
+    resolveLValue(): LValue;
+    private _ptype;
+    private _expr;
+    readonly initialValue: Expression | undefined;
+    constructor(expr: Expression | undefined, ptype: PType, config: {
+        initialValue?: Expression;
+        sourceLocation: SourceLocation;
+    });
+    get ptype(): GlobalStateType;
+    buildStorageDeclaration(memberName: string, memberLocation: SourceLocation, contractType: ContractClassPType): AppStorageDeclaration;
+}

package/awst_build/eb/storage/local-state.d.ts

@@ -0,0 +1,32 @@
+import type { AppStateExpression, Expression, LValue } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import { AppStorageDeclaration } from '../../contract-data';
+import type { ContractClassPType, PType } from '../../ptypes';
+import { LocalStateType } from '../../ptypes';
+import { FunctionBuilder, InstanceBuilder, InstanceExpressionBuilder, NodeBuilder } from '../index';
+export declare class LocalStateFunctionBuilder extends FunctionBuilder {
+    constructor(sourceLocation: SourceLocation);
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
+}
+export declare class LocalStateExpressionBuilder extends InstanceExpressionBuilder<LocalStateType> {
+    constructor(expr: Expression, ptype: PType);
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+    private buildField;
+}
+export declare class LocalStateForAccountExpressionBuilder extends NodeBuilder {
+    private key;
+    private contentType;
+    ptype: undefined;
+    constructor(key: AppStateExpression, contentType: PType);
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class LocalStateFunctionResultBuilder extends InstanceBuilder<LocalStateType> {
+    resolve(): Expression;
+    resolveLValue(): LValue;
+    private _expr;
+    constructor(expr: Expression | undefined, ptype: PType, config: {
+        sourceLocation: SourceLocation;
+    });
+    readonly ptype: LocalStateType;
+    buildStorageDeclaration(memberName: string, memberLocation: SourceLocation, contractType: ContractClassPType): AppStorageDeclaration;
+}

package/awst_build/eb/storage/util.d.ts

@@ -0,0 +1,5 @@
+import type { Expression } from '../../../awst/nodes';
+import type { WType } from '../../../awst/wtypes';
+import type { InstanceBuilder } from '../index';
+export declare function extractKey(key: InstanceBuilder, keyWType: WType): Expression;
+export declare function extractKey(key: InstanceBuilder | undefined, keyWType: WType): Expression | undefined;

package/awst_build/eb/storage/value-proxy.d.ts

@@ -0,0 +1,22 @@
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import type { PType } from '../../ptypes';
+import type { BuilderBinaryOp, BuilderComparisonOp, BuilderUnaryOp, InstanceBuilder, NodeBuilder } from '../index';
+import { InstanceExpressionBuilder } from '../index';
+export declare abstract class ValueProxy<TPType extends PType> extends InstanceExpressionBuilder<TPType> {
+    private get proxied();
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+    augmentedAssignment(other: InstanceBuilder, op: BuilderBinaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    iterate(sourceLocation: SourceLocation): Expression;
+    indexAccess(index: InstanceBuilder, sourceLocation: SourceLocation): NodeBuilder;
+    boolEval(sourceLocation: SourceLocation, negate?: boolean): Expression;
+    binaryOp(other: InstanceBuilder, op: BuilderBinaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    prefixUnaryOp(op: BuilderUnaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    postfixUnaryOp(op: BuilderUnaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+    compare(other: InstanceBuilder, op: BuilderComparisonOp, sourceLocation: SourceLocation): InstanceBuilder;
+    taggedTemplate(head: string, spans: ReadonlyArray<readonly [InstanceBuilder, string]>, sourceLocation: SourceLocation): InstanceBuilder;
+    singleEvaluation(): InstanceBuilder;
+    hasProperty(_name: string): boolean;
+    toBytes(sourceLocation: SourceLocation): Expression;
+}

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

@@ -0,0 +1,27 @@
+import { awst } from '../../awst';
+import type { Expression } from '../../awst/nodes';
+import type { SourceLocation } from '../../awst/source-location';
+import type { InstanceType, PType, PTypeOrClass } from '../ptypes';
+import type { InstanceBuilder, NodeBuilder } from './index';
+import { BuilderBinaryOp, BuilderComparisonOp, FunctionBuilder, InstanceExpressionBuilder } from './index';
+export declare class StringFunctionBuilder extends FunctionBuilder {
+    taggedTemplate(head: string, spans: ReadonlyArray<readonly [InstanceBuilder, string]>, sourceLocation: SourceLocation): InstanceBuilder;
+    call(args: Array<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
+}
+export declare class StringExpressionBuilder extends InstanceExpressionBuilder<InstanceType> {
+    constructor(expr: Expression);
+    resolvableToPType(ptype: PTypeOrClass): boolean;
+    resolveToPType(ptype: PTypeOrClass): InstanceBuilder;
+    boolEval(sourceLocation: SourceLocation, negate?: boolean): Expression;
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+    compare(other: InstanceBuilder, op: BuilderComparisonOp, sourceLocation: SourceLocation): InstanceBuilder;
+    binaryOp(other: InstanceBuilder, op: BuilderBinaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    augmentedAssignment(other: InstanceBuilder, op: BuilderBinaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    toBytes(sourceLocation: SourceLocation): awst.Expression;
+    toString(): Expression;
+}
+export declare class ConcatExpressionBuilder extends FunctionBuilder {
+    private expr;
+    constructor(expr: awst.Expression);
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): StringExpressionBuilder;
+}

package/awst_build/eb/transactions/group-transactions.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 { GroupTransactionPType, TransactionFunctionType } from '../../ptypes';
+import type { InstanceBuilder, NodeBuilder } from '../index';
+import { FunctionBuilder, InstanceExpressionBuilder } from '../index';
+export declare class GroupTransactionExpressionBuilder extends InstanceExpressionBuilder<GroupTransactionPType> {
+    constructor(expr: Expression, ptype: PType);
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class GroupTransactionFunctionBuilder extends FunctionBuilder {
+    readonly ptype: TransactionFunctionType;
+    constructor(sourceLocation: SourceLocation, ptype: PType);
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}

package/awst_build/eb/transactions/inner-transaction-params.d.ts

@@ -0,0 +1,19 @@
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import type { PType } from '../../ptypes';
+import { ItxnParamsPType, TransactionFunctionType } from '../../ptypes';
+import type { InstanceBuilder, NodeBuilder } from '../index';
+import { FunctionBuilder, InstanceExpressionBuilder } from '../index';
+export declare class ItxnParamsFactoryFunctionBuilder extends FunctionBuilder {
+    readonly ptype: TransactionFunctionType;
+    constructor(sourceLocation: SourceLocation, ptype: PType);
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class SubmitItxnGroupFunctionBuilder extends FunctionBuilder {
+    ptype: import("../../ptypes").LibFunctionType;
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class ItxnParamsExpressionBuilder extends InstanceExpressionBuilder<ItxnParamsPType> {
+    constructor(expr: Expression, ptype: PType);
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}

package/awst_build/eb/transactions/inner-transactions.d.ts

@@ -0,0 +1,10 @@
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import type { PType } from '../../ptypes';
+import { InnerTransactionPType } from '../../ptypes';
+import type { NodeBuilder } from '../index';
+import { InstanceExpressionBuilder } from '../index';
+export declare class InnerTransactionExpressionBuilder extends InstanceExpressionBuilder<InnerTransactionPType> {
+    constructor(expr: Expression, ptype: PType);
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}