@algorandfoundation/puya-ts 1.2.0-beta.4 → 1.2.0-beta.40

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

@@ -2,6 +2,7 @@ import ts from 'typescript';
 import type { ContractReference, LogicSigReference } from '../../awst/models';
 import type { AppStorageDefinition, ARC4MethodConfig } from '../../awst/nodes';
 import { SourceLocation } from '../../awst/source-location';
+import type { CompileOptions } from '../../options';
 import type { InstanceBuilder, NodeBuilder } from '../eb';
 import type { AppStorageDeclaration } from '../models/app-storage-declaration';
 import type { ContractClassModel } from '../models/contract-class-model';
@@ -11,7 +12,6 @@ import type { ContractClassPType, PType } from '../ptypes';
 import type { SymbolName } from '../symbol-name';
 import { EvaluationContext } from './evaluation-context';
 import { SwitchLoopContext } from './switch-loop-context';
-import type { CompileOptions } from '../../options';
 export type BuildAwstOptions = Pick<CompileOptions, 'filePaths' | 'outputAwst' | 'outputAwstJson' | 'validateAbiReturn'>;
 export declare abstract class AwstBuildContext {
     /**

package/awst_build/eb/arc28/arc-28-emit-function-builder.d.ts

@@ -1,11 +1,10 @@
 import type ts from 'typescript';
-import { SourceLocation } from '../../../awst/source-location';
+import type { SourceLocation } from '../../../awst/source-location';
 import type { PType } from '../../ptypes';
 import type { NodeBuilder } from '../index';
 import { FunctionBuilder } from '../index';
 export declare class Arc28EmitFunctionBuilder extends FunctionBuilder {
     readonly ptype: import("../../ptypes").LibFunctionType;
-    private encode;
     private resolvePropertyValue;
     call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
 }

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

@@ -25,7 +25,7 @@ export declare class DynamicBytesClassBuilder extends ClassBuilder {
     readonly ptype: import("../../ptypes").LibClassType;
     newCall(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
 }
-export declare abstract class ArrayExpressionBuilder<TArrayType extends DynamicArrayType | StaticArrayType> extends Arc4EncodedBaseExpressionBuilder<TArrayType> {
+declare abstract class ArrayExpressionBuilder<TArrayType extends DynamicArrayType | StaticArrayType> extends Arc4EncodedBaseExpressionBuilder<TArrayType> {
     iterate(): Expression;
     indexAccess(index: InstanceBuilder | bigint, sourceLocation: SourceLocation): NodeBuilder;
     memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
@@ -46,3 +46,4 @@ export declare class AddressExpressionBuilder extends ArrayExpressionBuilder<Sta
     constructor(expr: Expression, ptype: PType);
     memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
 }
+export {};

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

@@ -19,23 +19,6 @@ export declare class ContractProxyExpressionBuilder extends InstanceExpressionBu
     constructor(expr: Expression, ptype: PType);
     memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
 }
-export declare class ContractProxyBareCreateFunctionBuilder extends FunctionBuilder {
-    private readonly proxy;
-    constructor(proxy: ContractProxyExpressionBuilder, sourceLocation: SourceLocation);
-    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
-}
-export declare class ContractProxyCallBuilder extends NodeBuilder {
-    private readonly proxy;
-    readonly ptype: undefined;
-    constructor(proxy: ContractProxyExpressionBuilder, sourceLocation: SourceLocation);
-    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
-}
-export declare class ContractProxyCallFunctionBuilder extends FunctionBuilder {
-    private readonly proxy;
-    private readonly functionType;
-    constructor(proxy: ContractProxyExpressionBuilder, functionType: FunctionPType, sourceLocation: SourceLocation);
-    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
-}
 export declare function buildApplicationCallTxnFields({ sourceLocation, fields, arc4Config, applicationProxy, methodSelector, functionType, }: {
     applicationProxy?: InstanceBuilder;
     fields?: InstanceBuilder;

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

@@ -15,7 +15,7 @@ export declare const classBuilderForUintNAlias: (aliasClass: LibClassType, alias
         newCall(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
         call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<import("typescript").CallExpression>): NodeBuilder;
         readonly sourceLocation: SourceLocation;
-        readonly typeDescription: string;
+        get typeDescription(): string;
         taggedTemplate(head: string, spans: ReadonlyArray<readonly [InstanceBuilder, string]>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
         hasProperty(_name: string): boolean;
         memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;

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

@@ -21,6 +21,7 @@ export declare class MethodSelectorFunctionBuilder extends FunctionBuilder {
     readonly ptype: import("../../ptypes").LibFunctionType;
     call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
 }
+export declare const validateEncodingMap: Record<string, boolean>;
 export declare class SizeOfFunctionBuilder extends FunctionBuilder {
     readonly ptype: import("../../ptypes").LibFunctionType;
     call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;

package/awst_build/eb/array-like/arrays.d.ts

@@ -4,12 +4,12 @@ import type { PType, PTypeOrClass } from '../../ptypes';
 import { ArrayPType, FixedArrayPType, ReadonlyArrayPType } from '../../ptypes';
 import type { InstanceBuilder, NodeBuilder } from '../index';
 import { ClassBuilder, InstanceExpressionBuilder } from '../index';
-export type NativeArrayLike = FixedArrayPType | ReadonlyArrayPType | ArrayPType;
+type NativeArrayLike = FixedArrayPType | ReadonlyArrayPType | ArrayPType;
 export declare class NativeArrayClassBuilder extends ClassBuilder {
     readonly ptype: import("../../ptypes").GenericPType<ArrayPType>;
     newCall(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
 }
-export declare class NativeArrayLikeExpressionBuilder<T extends NativeArrayLike = NativeArrayLike> extends InstanceExpressionBuilder<T> {
+declare class NativeArrayLikeExpressionBuilder<T extends NativeArrayLike = NativeArrayLike> extends InstanceExpressionBuilder<T> {
     iterate(sourceLocation: SourceLocation): Expression;
     indexAccess(index: InstanceBuilder | bigint, sourceLocation: SourceLocation): NodeBuilder;
     protected requireMutable(method: string, sourceLocation: SourceLocation): void;
@@ -33,3 +33,4 @@ export declare class FixedArrayExpressionBuilder extends NativeArrayLikeExpressi
 export declare class ReadonlyArrayExpressionBuilder extends NativeArrayLikeExpressionBuilder<ReadonlyArrayPType> {
     constructor(expr: Expression, ptype: PType);
 }
+export {};

package/awst_build/eb/array-like/util.d.ts

@@ -3,4 +3,3 @@ import { MutableTuplePType } from '../../ptypes';
 import type { InstanceBuilder } from '../index';
 export declare function newArray(ptype: ArrayPType | ReadonlyArrayPType, valueProvider: InstanceBuilder): import("../../../awst/nodes").NewArray;
 export declare function newTuple(ptype: MutableTuplePType | ReadonlyTuplePType | ArrayLiteralPType, valueProvider: InstanceBuilder): import("../../../awst/nodes").VoidConstant | import("../../../awst/nodes").ARC4Encode | import("../../../awst/nodes").TupleExpression;
-export declare function newArrayOrTuple(ptype: ArrayPType | ReadonlyArrayPType | MutableTuplePType | ReadonlyTuplePType | ArrayLiteralPType, valueProvider: InstanceBuilder): import("../../../awst/nodes").VoidConstant | import("../../../awst/nodes").ARC4Encode | import("../../../awst/nodes").TupleExpression | import("../../../awst/nodes").NewArray;

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

@@ -1,7 +1,6 @@
 import type ts from 'typescript';
 import { type awst } from '../../awst';
 import type { Expression } from '../../awst/nodes';
-import { BytesBinaryOperator } from '../../awst/nodes';
 import type { SourceLocation } from '../../awst/source-location';
 import type { PType, PTypeOrClass } from '../ptypes';
 import { BytesPType } from '../ptypes';
@@ -25,30 +24,3 @@ export declare class BytesExpressionBuilder extends InstanceExpressionBuilder<By
     resolvableToPType(ptype: PTypeOrClass): ptype is BytesPType;
     resolveToPType(ptype: PTypeOrClass): InstanceBuilder;
 }
-export declare class ConcatFunctionBuilder extends FunctionBuilder {
-    private builder;
-    constructor(builder: BytesExpressionBuilder);
-    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
-}
-export declare function bytesToFixed(builder: InstanceBuilder, fixedType: BytesPType, sourceLocation: SourceLocation, strategy?: 'assert-length' | 'unsafe-cast'): InstanceBuilder;
-export declare class ToFixedLengthFunctionBuilder extends FunctionBuilder {
-    private builder;
-    constructor(builder: BytesExpressionBuilder);
-    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
-}
-export declare class BytesInvertBuilder extends FunctionBuilder {
-    private builder;
-    constructor(builder: BytesExpressionBuilder);
-    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
-}
-export declare class BitwiseOpFunctionBuilder extends FunctionBuilder {
-    private left;
-    private op;
-    constructor(left: BytesExpressionBuilder, op: BytesBinaryOperator);
-    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
-}
-export declare class ToStringBuilder extends FunctionBuilder {
-    private builder;
-    constructor(builder: BytesExpressionBuilder);
-    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
-}

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

@@ -25,17 +25,6 @@ export declare class ContractSuperBuilder extends ContractThisBuilder {
     call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
     memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
 }
-/**
- * Matches polytype's super.class(SomeType) expression
- */
-export declare class PolytypeExplicitClassAccessExpressionBuilder extends InstanceBuilder {
-    readonly ptype: ContractClassPType;
-    readonly isConstant = false;
-    resolve(): Expression;
-    resolveLValue(): LValue;
-    constructor(ptype: ContractClassPType, sourceLocation: SourceLocation);
-    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
-}
 export declare class ContractClassBuilder extends InstanceBuilder {
     readonly isConstant = false;
     resolve(): Expression;

package/awst_build/eb/index.d.ts

@@ -117,7 +117,6 @@ export declare abstract class ClassBuilder extends NodeBuilder {
 }
 export declare abstract class FunctionBuilder extends NodeBuilder {
     readonly ptype: PType | undefined;
-    constructor(location: SourceLocation);
     abstract call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
 }
 export declare abstract class InstanceExpressionBuilder<TPType extends PType> extends InstanceBuilder<PType> {
@@ -131,7 +130,6 @@ export declare abstract class InstanceExpressionBuilder<TPType extends PType> ex
     checkForUnclonedMutables(scenario: string): boolean;
 }
 export declare function isReferableExpression(expr: awst.Expression): boolean;
-export declare function requireLValue(expr: awst.Expression): awst.LValue;
 export declare class DecoratorDataBuilder extends NodeBuilder {
     private readonly data;
     readonly ptype: PType | undefined;

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

@@ -4,21 +4,25 @@ import type { ImmutableObjectPType, MutableObjectPType, PTypeOrClass } from '../
 import { ObjectLiteralPType } from '../../ptypes';
 import type { InstanceBuilder, NodeBuilder } from '../index';
 import { LiteralExpressionBuilder } from '../literal-expression-builder';
-export type ObjectLiteralParts = {
+export type ObjectLiteralPart = {
     type: 'properties';
-    properties: Record<string, InstanceBuilder>;
+    property: ObjectLiteralBinding;
 } | {
     type: 'spread-object';
     obj: InstanceBuilder;
     spreadLocation: SourceLocation;
 };
+export type ObjectLiteralBinding = {
+    name: string;
+    target: InstanceBuilder;
+};
 export declare class ObjectLiteralExpressionBuilder extends LiteralExpressionBuilder {
     readonly ptype: ObjectLiteralPType;
     private readonly propertyToItemMap;
-    private readonly items;
+    readonly bindings: ReadonlyArray<ObjectLiteralBinding>;
     private readonly isSingleEval;
     readonly isConstant = false;
-    static fromParts(sourceLocation: SourceLocation, parts: ObjectLiteralParts[]): ObjectLiteralExpressionBuilder;
+    static fromParts(sourceLocation: SourceLocation, parts: ObjectLiteralPart[]): ObjectLiteralExpressionBuilder;
     private constructor();
     singleEvaluation(): InstanceBuilder;
     resolve(): Expression;

package/awst_build/eb/logged-error-builder.d.ts

@@ -0,0 +1,11 @@
+import type ts from 'typescript';
+import type { SourceLocation } from '../../awst/source-location';
+import type { PType } from '../ptypes';
+import type { NodeBuilder } from './index';
+import { FunctionBuilder } from './index';
+export declare class LoggedAssertFunctionBuilder extends FunctionBuilder {
+    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
+}
+export declare class LoggedErrFunctionBuilder extends FunctionBuilder {
+    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
+}

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

@@ -2,6 +2,4 @@ import type { NewStruct, TupleExpression } from '../../../awst/nodes';
 import type { ImmutableObjectPType, ObjectLiteralPType } from '../../ptypes';
 import { MutableObjectPType } from '../../ptypes';
 import type { InstanceBuilder } from '../index';
-export declare function createStruct(ptype: MutableObjectPType, valueProvider: InstanceBuilder): NewStruct;
-export declare function createNamedTuple(ptype: ImmutableObjectPType | ObjectLiteralPType, valueProvider: InstanceBuilder): TupleExpression;
 export declare function createObject(ptype: ImmutableObjectPType | ObjectLiteralPType | MutableObjectPType, valueProvider: InstanceBuilder): TupleExpression | NewStruct;

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

@@ -28,9 +28,6 @@ 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);
-}
 /**
  * Builder for expressions which have the 'type' of an intrinsic function or group but are not the singleton instance
  * imported from @algorandfoundat/algorand-typescript. This is not supported.

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

@@ -1,5 +1,5 @@
 import type ts from 'typescript';
-import type { BoxValueExpression, Expression } from '../../../../awst/nodes';
+import type { Expression } from '../../../../awst/nodes';
 import type { SourceLocation } from '../../../../awst/source-location';
 import type { PType } from '../../../ptypes';
 import { BoxPType } from '../../../ptypes';
@@ -12,23 +12,3 @@ export declare class BoxExpressionBuilder extends BoxProxyExpressionBuilder<BoxP
     constructor(expr: Expression, ptype: PType);
     memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
 }
-export declare class BoxResizeFunctionBuilder extends FunctionBuilder {
-    private boxValue;
-    constructor(boxValue: BoxValueExpression, sourceLocation: SourceLocation);
-    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
-}
-export declare class BoxExtractFunctionBuilder extends FunctionBuilder {
-    private boxValue;
-    constructor(boxValue: BoxValueExpression, sourceLocation: SourceLocation);
-    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
-}
-export declare class BoxReplaceFunctionBuilder extends FunctionBuilder {
-    private boxValue;
-    constructor(boxValue: BoxValueExpression, sourceLocation: SourceLocation);
-    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
-}
-export declare class BoxSpliceFunctionBuilder extends FunctionBuilder {
-    private boxValue;
-    constructor(boxValue: BoxValueExpression, sourceLocation: SourceLocation);
-    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
-}

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

@@ -0,0 +1,21 @@
+import type ts from 'typescript';
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import { AppStorageDeclaration } from '../../models/app-storage-declaration';
+import type { ContractClassPType, PType } from '../../ptypes';
+import { GlobalMapType } from '../../ptypes';
+import { FunctionBuilder, InstanceExpressionBuilder, type NodeBuilder } from '../index';
+export declare class GlobalMapFunctionBuilder extends FunctionBuilder {
+    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
+}
+export declare class GlobalMapExpressionBuilder extends InstanceExpressionBuilder<GlobalMapType> {
+    constructor(expr: Expression, ptype: PType);
+    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class GlobalMapFunctionResultBuilder extends GlobalMapExpressionBuilder {
+    private readonly _keyPrefixExpr;
+    constructor(expr: Expression | undefined, ptype: PType, sourceLocation: SourceLocation);
+    resolve(): Expression;
+    buildStorageDeclaration(memberName: string, memberLocation: SourceLocation, memberDescription: string | null, contractType: ContractClassPType): AppStorageDeclaration;
+}

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

@@ -0,0 +1,21 @@
+import type ts from 'typescript';
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import { AppStorageDeclaration } from '../../models/app-storage-declaration';
+import type { ContractClassPType, PType } from '../../ptypes';
+import { LocalMapType } from '../../ptypes';
+import { FunctionBuilder, InstanceExpressionBuilder, type NodeBuilder } from '../index';
+export declare class LocalMapFunctionBuilder extends FunctionBuilder {
+    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
+}
+export declare class LocalMapExpressionBuilder extends InstanceExpressionBuilder<LocalMapType> {
+    constructor(expr: Expression, ptype: PType);
+    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class LocalMapFunctionResultBuilder extends LocalMapExpressionBuilder {
+    private readonly _keyPrefixExpr;
+    constructor(expr: Expression | undefined, ptype: PType, sourceLocation: SourceLocation);
+    resolve(): Expression;
+    buildStorageDeclaration(memberName: string, memberLocation: SourceLocation, memberDescription: string | null, contractType: ContractClassPType): AppStorageDeclaration;
+}

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

@@ -1,5 +1,4 @@
 import type ts from 'typescript';
-import { awst } from '../../awst';
 import type { Expression } from '../../awst/nodes';
 import type { SourceLocation } from '../../awst/source-location';
 import type { InstanceType, PType, PTypeOrClass } from '../ptypes';
@@ -22,8 +21,3 @@ export declare class StringExpressionBuilder extends InstanceExpressionBuilder<I
     toBytes(sourceLocation: SourceLocation): InstanceBuilder;
     toString(): Expression;
 }
-export declare class ConcatExpressionBuilder extends FunctionBuilder {
-    private expr;
-    constructor(expr: awst.Expression);
-    call(args: ReadonlyArray<NodeBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation<ts.CallExpression>): NodeBuilder;
-}

package/awst_build/eb/util/resolve-compat-builder.d.ts

@@ -1,11 +1,3 @@
 import type { PType } from '../../ptypes';
 import type { NodeBuilder } from '../index';
-import { InstanceBuilder } from '../index';
-/**
- * Given a builder, attempt to resolve it to the target type converting compatible types as possible
- *
- * @param builder
- * @param targetType
- */
-export declare function resolveCompatBuilder(builder: NodeBuilder, targetType: PType): InstanceBuilder<PType>;
 export declare function resolveCompatExpression(builder: NodeBuilder, targetType: PType): import("../../../awst/nodes").Expression;

package/awst_build/models/decorator-data.d.ts

@@ -42,6 +42,7 @@ export type LogicSigOptionsDecoratorData = {
     avmVersion?: SupportedAvmVersion;
     name?: string;
     scratchSlots?: Set<bigint>;
+    validateEncoding?: boolean;
 };
 export type ContractOptionsDecoratorData = {
     type: typeof Constants.symbolNames.contractOptionsDecoratorName;

package/awst_build/op-metadata.d.ts

@@ -1,14 +1,14 @@
 import * as ptypes from './ptypes';
 import type { Expression } from '../awst/nodes';
-export type ImmediateArgMapping = {
+type ImmediateArgMapping = {
     name: string;
     ptypes: ptypes.PType[];
 };
-export type StackArg = {
+type StackArg = {
     name: string;
     ptypes: ptypes.PType[];
 };
-export type Signature = {
+type Signature = {
     argNames: string[];
     immediateArgs: Array<ImmediateArgMapping | bigint | string>;
     stackArgs: Array<StackArg | Expression>;
@@ -25,3 +25,4 @@ export type IntrinsicOpGrouping = {
     ops: Record<string, IntrinsicOpMapping>;
 };
 export declare const OP_METADATA: Record<string, IntrinsicOpMapping | IntrinsicOpGrouping>;
+export {};

package/awst_build/ptypes/arc4-types.d.ts

@@ -1,5 +1,6 @@
 import type { SourceLocation } from '../../awst/source-location';
 import { wtypes } from '../../awst/wtypes';
+import type { PTypeField } from './base';
 import { GenericPType, PType } from './base';
 import { ContractClassPType, ImmutableObjectPType, LibClassType, LibFunctionType, MutableObjectPType, ReadonlyTuplePType } from './index';
 import type { PTypeVisitor } from './visitor';
@@ -12,7 +13,7 @@ export declare const UintN128Class: LibClassType;
 export declare const UintN256Class: LibClassType;
 export declare abstract class ARC4EncodedType extends PType {
     abstract readonly wtype: wtypes.ARC4Type;
-    abstract readonly nativeType: PType | undefined;
+    abstract readonly nativeType: PType;
     abstract readonly abiTypeSignature: string;
     protected static buildAbiTupleSignature(types: ARC4EncodedType[]): string;
 }
@@ -59,13 +60,16 @@ export declare class ARC4StructClass extends PType {
     static fromStructType(ptype: ARC4StructType): ARC4StructClass;
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
+export type ARC4StructField = PTypeField & {
+    ptype: ARC4EncodedType;
+};
 export declare class ARC4StructType extends ARC4EncodedType {
     readonly [PType.IdSymbol] = "ARC4StructType";
     readonly name: string;
     readonly module: string;
     readonly description: string | undefined;
     readonly singleton = false;
-    readonly fields: Record<string, ARC4EncodedType>;
+    readonly fields: ARC4StructField[];
     readonly sourceLocation: SourceLocation | undefined;
     readonly frozen: boolean;
     readonly abiTypeSignature: string;
@@ -74,15 +78,16 @@ export declare class ARC4StructType extends ARC4EncodedType {
         module: string;
         frozen: boolean;
         description: string | undefined;
-        fields: Record<string, ARC4EncodedType>;
+        fields: ARC4StructField[];
         sourceLocation?: SourceLocation;
     });
     get nativeType(): MutableObjectPType;
     get wtype(): wtypes.ARC4Struct;
+    getProperty(name: string): ARC4StructField | undefined;
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
 export declare const arc4StructBaseType: ARC4StructType;
-export declare const Arc4TupleGeneric: GenericPType<ARC4TupleType>;
+export declare const ARC4TupleGeneric: GenericPType<ARC4TupleType>;
 export declare class ARC4TupleType extends ARC4EncodedType {
     readonly [PType.IdSymbol] = "ARC4TupleType";
     readonly name: string;
@@ -116,7 +121,6 @@ export declare class UintNType extends ARC4EncodedType {
     });
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
-export declare const arc4Uint64: UintNType;
 export declare const UFixedNxMGeneric: GenericPType<UFixedNxMType>;
 export declare class UFixedNxMType extends ARC4EncodedType {
     readonly [PType.IdSymbol] = "UFixedNxMType";
@@ -187,8 +191,8 @@ export declare class StaticBytesType extends StaticArrayType {
         length: bigint;
     });
 }
-export declare const DynamicBytesConstructor: LibClassType;
-export declare const DynamicBytesType: DynamicArrayType;
+export declare const DynamicBytesClass: LibClassType;
+export declare const dynamicBytesType: DynamicArrayType;
 export declare const convertBytesFunction: LibFunctionType;
 export declare const encodeArc4Function: LibFunctionType;
 export declare const sizeOfFunction: LibFunctionType;

package/awst_build/ptypes/base.d.ts

@@ -60,4 +60,9 @@ export type PTypeOrClass = PType | {
     new (...args: DeliberateAny[]): PType;
     equals(other: PType): boolean;
 };
+export type PTypeField = {
+    name: string;
+    ptype: PType;
+    description: string | null;
+};
 export {};

package/awst_build/ptypes/for-export.d.ts

@@ -1,3 +1,2 @@
-export { ptypeToArc4EncodedType } from '../arc4-util';
 export * from './arc4-types';
 export * from './index';