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

package/awst_build/ptypes/index.d.ts

@@ -2,7 +2,7 @@ import { TransactionKind } from '../../awst/models';
 import { SourceLocation } from '../../awst/source-location';
 import { wtypes } from '../../awst/wtypes';
 import { SymbolName } from '../symbol-name';
-import type { ABICompatiblePType, PTypeOrClass } from './base';
+import type { ABICompatiblePType, PTypeField, PTypeOrClass } from './base';
 import { GenericPType, PType } from './base';
 import type { PTypeVisitor } from './visitor';
 export * from './base';
@@ -135,31 +135,60 @@ declare abstract class StorageProxyPType extends PType {
         keyWType: wtypes.WType;
     });
 }
+declare abstract class StateProxyPType extends StorageProxyPType {
+    readonly module: string;
+    readonly kind: string;
+    protected constructor(props: {
+        content: PType;
+        kind: string;
+    });
+    get name(): string;
+    get fullName(): string;
+}
 export declare const GlobalStateGeneric: GenericPType<GlobalStateType>;
-export declare class GlobalStateType extends StorageProxyPType {
+export declare class GlobalStateType extends StateProxyPType {
     readonly [PType.IdSymbol] = "GlobalStateType";
-    static readonly baseName = "GlobalState";
-    static readonly baseFullName: string;
+    constructor(props: {
+        content: PType;
+    });
+    accept<T>(visitor: PTypeVisitor<T>): T;
+}
+declare abstract class StateMapProxyPType extends StorageProxyPType {
     readonly module: string;
+    readonly kind: string;
+    readonly keyType: PType;
+    protected constructor(props: {
+        content: PType;
+        keyType: PType;
+        kind: string;
+    });
     get name(): string;
     get fullName(): string;
+}
+export declare const GlobalMapGeneric: GenericPType<GlobalMapType>;
+export declare class GlobalMapType extends StateMapProxyPType {
+    readonly [PType.IdSymbol] = "GlobalMapType";
     constructor(props: {
         content: PType;
+        keyType: PType;
     });
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
 export declare const LocalStateGeneric: GenericPType<LocalStateType>;
-export declare class LocalStateType extends StorageProxyPType {
+export declare class LocalStateType extends StateProxyPType {
     readonly [PType.IdSymbol] = "LocalStateType";
-    static readonly baseName = "LocalState";
-    static readonly baseFullName: string;
-    readonly module: string;
-    get name(): string;
-    get fullName(): string;
     constructor(props: {
         content: PType;
     });
-    static parameterise(typeArgs: PType[]): LocalStateType;
+    accept<T>(visitor: PTypeVisitor<T>): T;
+}
+export declare const LocalMapGeneric: GenericPType<LocalMapType>;
+export declare class LocalMapType extends StateMapProxyPType {
+    readonly [PType.IdSymbol] = "LocalMapType";
+    constructor(props: {
+        content: PType;
+        keyType: PType;
+    });
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
 export declare const BoxGeneric: GenericPType<BoxPType>;
@@ -186,7 +215,7 @@ export declare class BoxMapPType extends StorageProxyPType {
     });
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
-export type AppStorageType = GlobalStateType | LocalStateType | BoxPType | BoxMapPType;
+export type AppStorageType = GlobalStateType | LocalStateType | BoxPType | BoxMapPType | GlobalMapType | LocalMapType;
 /**
  * An open generic type parameter
  */
@@ -223,7 +252,7 @@ export declare class AnyPType extends PType {
     readonly [PType.IdSymbol] = "AnyPType";
     get wtype(): never;
     readonly name = "any";
-    readonly module = "lib.d.ts";
+    readonly module: "lib.d.ts";
     readonly singleton = false;
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
@@ -249,8 +278,7 @@ export declare class ABICompatibleInstanceType extends InstanceType implements A
         abiTypeSignature: string;
     });
 }
-export declare class LibFunctionType extends PType {
-    readonly [PType.IdSymbol] = "LibFunctionType";
+declare abstract class LibPType extends PType {
     readonly wtype: undefined;
     readonly name: string;
     readonly module: string;
@@ -259,74 +287,46 @@ export declare class LibFunctionType extends PType {
         name: string;
         module: string;
     });
+}
+export declare class LibFunctionType extends LibPType {
+    readonly [PType.IdSymbol] = "LibFunctionType";
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
-export declare class LibClassType extends PType {
+export declare class LibClassType extends LibPType {
     readonly [PType.IdSymbol] = "LibClassType";
-    readonly wtype: undefined;
-    readonly name: string;
-    readonly module: string;
-    readonly singleton = true;
-    constructor({ name, module }: {
-        name: string;
-        module: string;
-    });
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
-export declare class LibObjType extends PType {
+export declare class LibObjType extends LibPType {
     readonly [PType.IdSymbol] = "LibObjType";
-    readonly wtype: undefined;
-    readonly name: string;
-    readonly module: string;
-    readonly singleton = true;
-    constructor({ name, module }: {
-        name: string;
-        module: string;
-    });
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
-export declare class IntrinsicFunctionGroupType extends PType {
-    readonly [PType.IdSymbol] = "IntrinsicFunctionGroupType";
+declare abstract class IntrinsicOpPType extends PType {
     readonly wtype: undefined;
     readonly name: string;
     readonly module: string;
-    readonly singleton = true;
+    abstract readonly singleton: boolean;
     constructor({ name }: {
         name: string;
     });
+}
+export declare class IntrinsicFunctionGroupType extends IntrinsicOpPType {
+    readonly [PType.IdSymbol] = "IntrinsicFunctionGroupType";
+    readonly singleton = true;
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
-export declare class IntrinsicFunctionGroupTypeType extends PType {
+export declare class IntrinsicFunctionGroupTypeType extends IntrinsicOpPType {
     readonly [PType.IdSymbol] = "IntrinsicFunctionGroupTypeType";
-    readonly wtype: undefined;
-    readonly name: string;
-    readonly module: string;
     readonly singleton = false;
-    constructor({ name }: {
-        name: string;
-    });
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
-export declare class IntrinsicFunctionType extends PType {
+export declare class IntrinsicFunctionType extends IntrinsicOpPType {
     readonly [PType.IdSymbol] = "IntrinsicFunctionType";
-    readonly wtype: undefined;
-    readonly name: string;
-    readonly module: string;
     readonly singleton = true;
-    constructor({ name }: {
-        name: string;
-    });
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
-export declare class IntrinsicFunctionTypeType extends PType {
+export declare class IntrinsicFunctionTypeType extends IntrinsicOpPType {
     readonly [PType.IdSymbol] = "IntrinsicFunctionTypeType";
-    readonly wtype: undefined;
-    readonly name: string;
-    readonly module: string;
     readonly singleton = false;
-    constructor({ name }: {
-        name: string;
-    });
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
 export declare const bzeroFunction: IntrinsicFunctionType;
@@ -334,7 +334,6 @@ export declare class NamespacePType extends PType {
     readonly [PType.IdSymbol] = "NamespacePType";
     readonly wtype: undefined;
     readonly name: string;
-    readonly factory: undefined;
     readonly module: string;
     readonly singleton = true;
     constructor({ name, module }: {
@@ -382,26 +381,28 @@ export declare class ArrayLiteralPType extends PType {
     getReadonlyTupleType(): ReadonlyTuplePType;
     getMutableTupleType(): MutableTuplePType;
 }
-export declare class MutableTuplePType extends PType {
-    readonly [PType.IdSymbol] = "MutableTuplePType";
+declare abstract class TupleBasePType extends PType {
+    readonly items: PType[];
+    readonly singleton = false;
     readonly module: string;
+    private readonly namePrefix;
+    protected constructor(props: {
+        items: PType[];
+        immutable?: boolean;
+    });
     get name(): string;
     get fullName(): string;
-    readonly items: PType[];
-    readonly singleton = false;
+}
+export declare class MutableTuplePType extends TupleBasePType {
+    readonly [PType.IdSymbol] = "MutableTuplePType";
     constructor(props: {
         items: PType[];
     });
     get wtype(): wtypes.ARC4Tuple;
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
-export declare class ReadonlyTuplePType extends PType {
+export declare class ReadonlyTuplePType extends TupleBasePType {
     readonly [PType.IdSymbol] = "ReadonlyTuplePType";
-    readonly module: string;
-    get name(): string;
-    get fullName(): string;
-    readonly items: PType[];
-    readonly singleton = false;
     constructor(props: {
         items: PType[];
     });
@@ -409,33 +410,33 @@ export declare class ReadonlyTuplePType extends PType {
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
 export declare const ArrayGeneric: GenericPType<ArrayPType>;
-export declare class ArrayPType extends PType {
-    readonly [PType.IdSymbol] = "ArrayPType";
+declare abstract class DynamicArrayBasePType extends PType {
     readonly elementType: PType;
-    readonly immutable = false;
+    readonly immutable: boolean;
     readonly singleton = false;
     readonly name: string;
     readonly module: string;
+    private readonly kind;
+    protected constructor(props: {
+        elementType: PType;
+        immutable: boolean;
+    });
     get fullName(): string;
+    get wtype(): wtypes.ARC4DynamicArray;
+}
+export declare class ArrayPType extends DynamicArrayBasePType {
+    readonly [PType.IdSymbol] = "ArrayPType";
     constructor(props: {
         elementType: PType;
     });
-    get wtype(): wtypes.ARC4DynamicArray;
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
 export declare const ReadonlyArrayGeneric: GenericPType<ReadonlyArrayPType>;
-export declare class ReadonlyArrayPType extends PType {
+export declare class ReadonlyArrayPType extends DynamicArrayBasePType {
     readonly [PType.IdSymbol] = "ReadonlyArrayPType";
-    readonly elementType: PType;
-    readonly singleton = false;
-    readonly immutable = true;
-    readonly name: string;
-    readonly module: string;
-    get fullName(): string;
     constructor(props: {
         elementType: PType;
     });
-    get wtype(): wtypes.ARC4DynamicArray;
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
 export declare const FixedArrayGeneric: GenericPType<FixedArrayPType>;
@@ -461,24 +462,25 @@ declare abstract class ObjectPType extends PType {
     readonly module: string;
     readonly alias: SymbolName | null;
     readonly description: string | undefined;
-    readonly properties: Record<string, PType>;
+    readonly properties: PTypeField[];
     readonly singleton = false;
     readonly immutable: boolean;
     constructor(props: {
         alias?: SymbolName | null;
-        properties: Record<string, PType>;
+        properties: PTypeField[];
         description?: string;
         namePrefix: string;
         immutable: boolean;
     });
-    orderedProperties(): [string, PType][];
     toString(): string;
+    getProperty(name: string): PTypeField | undefined;
     hasSameStructure(other: ObjectPType): boolean;
+    protected toWTuple(fallbackName: string): wtypes.WTuple;
 }
 export declare class ObjectLiteralPType extends ObjectPType {
     readonly [PType.IdSymbol] = "ObjectLiteralPType";
     constructor(props: {
-        properties: Record<string, PType>;
+        properties: PTypeField[];
     });
     accept<T>(visitor: PTypeVisitor<T>): T;
     getImmutable(): ImmutableObjectPType;
@@ -489,7 +491,7 @@ export declare class ImmutableObjectPType extends ObjectPType {
     readonly [PType.IdSymbol] = "ImmutableObjectPType";
     constructor(props: {
         alias?: SymbolName | null;
-        properties: Record<string, PType>;
+        properties: PTypeField[];
         description?: string;
     });
     get wtype(): wtypes.WTuple;
@@ -499,7 +501,7 @@ export declare class MutableObjectPType extends ObjectPType {
     readonly [PType.IdSymbol] = "MutableObjectPType";
     constructor(props: {
         alias?: SymbolName | null;
-        properties: Record<string, PType>;
+        properties: PTypeField[];
         description?: string;
     });
     get wtype(): wtypes.ARC4Struct;
@@ -573,12 +575,14 @@ export declare const BytesFunction: LibFunctionType;
 export declare const logFunction: LibFunctionType;
 export declare const assertFunction: LibFunctionType;
 export declare const errFunction: LibFunctionType;
+export declare const loggedAssertFunction: LibFunctionType;
+export declare const loggedErrFunction: LibFunctionType;
 export declare const assetPType: ABICompatibleInstanceType;
 export declare const AssetFunction: LibFunctionType;
 export declare const accountPType: ABICompatibleInstanceType;
 export declare const AccountFunction: LibFunctionType;
 export declare const applicationPType: ABICompatibleInstanceType;
-export declare const ApplicationFunctionType: LibFunctionType;
+export declare const ApplicationFunction: LibFunctionType;
 export declare const ClearStateProgram: FunctionPType;
 export declare const ApprovalProgram: FunctionPType;
 export declare const baseContractType: BaseContractClassType;
@@ -622,7 +626,7 @@ export declare const AssetTransferTxnFunction: TransactionFunctionType;
 export declare const assetFreezeGtxnType: GroupTransactionPType;
 export declare const AssetFreezeTxnFunction: TransactionFunctionType;
 export declare const applicationCallGtxnType: GroupTransactionPType;
-export declare const ApplicationTxnFunction: TransactionFunctionType;
+export declare const ApplicationCallTxnFunction: TransactionFunctionType;
 export declare const anyGtxnType: GroupTransactionPType;
 export declare const TransactionFunction: TransactionFunctionType;
 export declare const assertMatchFunction: LibFunctionType;
@@ -686,12 +690,12 @@ export declare class GeneratorType extends UnsupportedType {
         nextType: PType;
     });
 }
-export declare const paymentItxnFn: TransactionFunctionType;
-export declare const keyRegistrationItxnFn: TransactionFunctionType;
-export declare const assetConfigItxnFn: TransactionFunctionType;
-export declare const assetTransferItxnFn: TransactionFunctionType;
-export declare const assetFreezeItxnFn: TransactionFunctionType;
-export declare const applicationCallItxnFn: TransactionFunctionType;
+export declare const paymentItxnFunction: TransactionFunctionType;
+export declare const keyRegistrationItxnFunction: TransactionFunctionType;
+export declare const assetConfigItxnFunction: TransactionFunctionType;
+export declare const assetTransferItxnFunction: TransactionFunctionType;
+export declare const assetFreezeItxnFunction: TransactionFunctionType;
+export declare const applicationCallItxnFunction: TransactionFunctionType;
 export declare class InnerTransactionPType extends PType {
     readonly [PType.IdSymbol] = "InnerTransactionPType";
     get wtype(): wtypes.WInnerTransaction;
@@ -729,13 +733,13 @@ export declare const assetTransferItxnType: InnerTransactionPType;
 export declare const assetFreezeItxnParamsType: ItxnParamsPType;
 export declare const assetFreezeItxnType: InnerTransactionPType;
 export declare const applicationCallItxnParamsType: ItxnParamsPType;
-export declare const applicationItxnType: InnerTransactionPType;
+export declare const applicationCallItxnType: InnerTransactionPType;
 export declare const anyItxnParamsType: ItxnParamsPType;
 export declare const anyItxnType: InnerTransactionPType;
 export declare const inputOnlyObjects: ObjectWithOptionalFieldsType[];
 export declare const submitGroupItxnFunction: LibFunctionType;
 export declare const TemplateVarFunction: LibFunctionType;
-export declare const compileFunctionType: LibFunctionType;
+export declare const compileFunction: LibFunctionType;
 export declare const compiledContractType: ImmutableObjectPType;
 export declare const compiledLogicSigType: ImmutableObjectPType;
 export declare const arc28EmitFunction: LibFunctionType;
@@ -762,15 +766,14 @@ export declare class ReferenceArrayType extends PType {
     readonly singleton = false;
     readonly sourceLocation: SourceLocation | undefined;
     readonly elementType: PType;
-    constructor({ elementType, sourceLocation, name, }: {
+    constructor({ elementType, sourceLocation, name }: {
         elementType: PType;
         sourceLocation?: SourceLocation;
         name?: string;
-        immutable?: boolean;
     });
     get wtype(): wtypes.ReferenceArray;
     accept<T>(visitor: PTypeVisitor<T>): T;
 }
 export declare const itxnComposePType: LibObjType;
-export declare const cloneFunctionPType: LibFunctionType;
-export declare const validateEncodingFunctionPType: LibFunctionType;
+export declare const cloneFunction: LibFunctionType;
+export declare const validateEncodingFunction: LibFunctionType;

package/awst_build/ptypes/util.d.ts

@@ -1,3 +1,3 @@
-import type { PType } from './base';
+import type { PType, PTypeField } from './base';
 export declare const ptypeIn: (target: PType, ...ptypes: [PType, ...PType[]]) => boolean;
-export declare function generateObjectHash(objectProperties: Record<string, PType>): string;
+export declare function generateObjectHash(objectProperties: PTypeField[]): string;

package/awst_build/ptypes/visitor.d.ts

@@ -1,5 +1,5 @@
 import type { ARC4InstanceType, ARC4StructClass, ARC4StructType, ARC4TupleType, ContractProxyType, DynamicArrayType, StaticArrayType, UFixedNxMType, UintNType } from './arc4-types';
-import type { AnyPType, ArrayLiteralPType, ArrayPType, BoxMapPType, BoxPType, BytesPType, ContractClassPType, FixedArrayPType, FunctionPType, GenericPType, GlobalStateType, GroupTransactionPType, ImmutableObjectPType, InnerTransactionPType, InstanceType, InternalType, IntrinsicEnumType, IntrinsicFunctionGroupType, IntrinsicFunctionGroupTypeType, IntrinsicFunctionType, IntrinsicFunctionTypeType, IterableIteratorType, ItxnParamsPType, LibClassType, LibFunctionType, LibObjType, LocalStateType, LogicSigPType, MutableObjectPType, MutableTuplePType, NamespacePType, ObjectLiteralPType, ReadonlyArrayPType, ReadonlyTuplePType, ReferenceArrayType, SuperPrototypeSelector, TransientType, TypeParameterType, Uint64EnumMemberType, Uint64EnumType, UnsupportedType } from './index';
+import type { AnyPType, ArrayLiteralPType, ArrayPType, BoxMapPType, BoxPType, BytesPType, ContractClassPType, FixedArrayPType, FunctionPType, GenericPType, GlobalMapType, GlobalStateType, GroupTransactionPType, ImmutableObjectPType, InnerTransactionPType, InstanceType, InternalType, IntrinsicEnumType, IntrinsicFunctionGroupType, IntrinsicFunctionGroupTypeType, IntrinsicFunctionType, IntrinsicFunctionTypeType, IterableIteratorType, ItxnParamsPType, LibClassType, LibFunctionType, LibObjType, LocalMapType, LocalStateType, LogicSigPType, MutableObjectPType, MutableTuplePType, NamespacePType, ObjectLiteralPType, ReadonlyArrayPType, ReadonlyTuplePType, ReferenceArrayType, SuperPrototypeSelector, TransientType, TypeParameterType, Uint64EnumMemberType, Uint64EnumType, UnsupportedType } from './index';
 export interface PTypeVisitor<T> {
     visitGeneric(ptype: GenericPType): T;
     visitMutableObjectPType(ptype: MutableObjectPType): T;
@@ -43,7 +43,9 @@ export interface PTypeVisitor<T> {
     visitInstanceType(ptype: InstanceType): T;
     visitContractClassPType(ptype: ContractClassPType): T;
     visitGlobalStateType(ptype: GlobalStateType): T;
+    visitGlobalMapType(ptype: GlobalMapType): T;
     visitLocalStateType(ptype: LocalStateType): T;
+    visitLocalMapType(ptype: LocalMapType): T;
     visitBoxPType(ptype: BoxPType): T;
     visitBoxMapPType(ptype: BoxMapPType): T;
     visitTypeParameterType(ptype: TypeParameterType): T;

package/awst_build/ptypes/visitors/default-visitor.d.ts

@@ -1,4 +1,4 @@
-import type { AnyPType, ArrayLiteralPType, ArrayPType, BoxMapPType, BoxPType, BytesPType, ContractClassPType, FixedArrayPType, FunctionPType, GlobalStateType, GroupTransactionPType, ImmutableObjectPType, InnerTransactionPType, InstanceType, InternalType, IntrinsicFunctionGroupType, IntrinsicFunctionGroupTypeType, IntrinsicFunctionType, IntrinsicFunctionTypeType, IterableIteratorType, ItxnParamsPType, LibClassType, LibFunctionType, LibObjType, LocalStateType, LogicSigPType, MutableObjectPType, MutableTuplePType, NamespacePType, ObjectLiteralPType, ReadonlyArrayPType, ReadonlyTuplePType, ReferenceArrayType, SuperPrototypeSelector, TransientType, TypeParameterType, Uint64EnumMemberType, Uint64EnumType, UnsupportedType } from '..';
+import type { AnyPType, ArrayLiteralPType, ArrayPType, BoxMapPType, BoxPType, BytesPType, ContractClassPType, FixedArrayPType, FunctionPType, GlobalMapType, GlobalStateType, GroupTransactionPType, ImmutableObjectPType, InnerTransactionPType, InstanceType, InternalType, IntrinsicFunctionGroupType, IntrinsicFunctionGroupTypeType, IntrinsicFunctionType, IntrinsicFunctionTypeType, IterableIteratorType, ItxnParamsPType, LibClassType, LibFunctionType, LibObjType, LocalMapType, LocalStateType, LogicSigPType, MutableObjectPType, MutableTuplePType, NamespacePType, ObjectLiteralPType, ReadonlyArrayPType, ReadonlyTuplePType, ReferenceArrayType, SuperPrototypeSelector, TransientType, TypeParameterType, Uint64EnumMemberType, Uint64EnumType, UnsupportedType } from '..';
 import type { ARC4InstanceType, ARC4StructClass, ARC4StructType, ARC4TupleType, ContractProxyType, DynamicArrayType, StaticArrayType, UFixedNxMType, UintNType } from '../arc4-types';
 import type { GenericPType, PType } from '../base';
 import type { IntrinsicEnumType } from '../intrinsic-enum-type';
@@ -49,7 +49,9 @@ export declare abstract class DefaultVisitor<T> implements PTypeVisitor<T> {
     visitInstanceType(ptype: InstanceType): T;
     visitContractClassPType(ptype: ContractClassPType): T;
     visitGlobalStateType(ptype: GlobalStateType): T;
+    visitGlobalMapType(ptype: GlobalMapType): T;
     visitLocalStateType(ptype: LocalStateType): T;
+    visitLocalMapType(ptype: LocalMapType): T;
     visitBoxPType(ptype: BoxPType): T;
     visitBoxMapPType(ptype: BoxMapPType): T;
     visitTypeParameterType(ptype: TypeParameterType): T;

package/awst_build/ptypes/visitors/index-type-visitor.d.ts

@@ -1,36 +1,5 @@
 import type { SourceLocation } from '../../../awst/source-location';
-import type { ARC4StructType, DynamicArrayType, StaticArrayType } from '../arc4-types';
 import type { PType } from '../base';
-import type { ArrayLiteralPType, ArrayPType, FixedArrayPType, ImmutableObjectPType, MutableObjectPType, MutableTuplePType, ObjectLiteralPType, ReadonlyArrayPType, ReadonlyTuplePType, ReferenceArrayType } from '../index';
-import { DefaultVisitor } from './default-visitor';
-export declare function hasProperty(ptype: PType, property: string, sourceLocation: SourceLocation): boolean;
 export declare function hasPropertyOfType(ptype: PType, property: string, propType: PType, sourceLocation: SourceLocation): boolean;
 export declare function getPropertyType(ptype: PType, property: string, sourceLocation: SourceLocation): PType;
 export declare function getIndexType(ptype: PType, index: bigint | string, sourceLocation: SourceLocation): PType | undefined;
-export declare class IndexTypeVisitor extends DefaultVisitor<PType | undefined> {
-    private readonly index;
-    private readonly sourceLocation;
-    constructor(index: string | bigint, sourceLocation: SourceLocation);
-    /**
-     * Return the type that would result from accessing the specified index of a value of this type.
-     *
-     * @param ptype
-     * @param index
-     * @param sourceLocation
-     */
-    static accept(ptype: PType, index: string | bigint, sourceLocation: SourceLocation): PType | undefined;
-    defaultReturn(ptype: PType): PType | undefined;
-    visitARC4StructType(ptype: ARC4StructType): PType | undefined;
-    visitImmutableObjectPType(ptype: ImmutableObjectPType): PType | undefined;
-    visitMutableObjectPType(ptype: MutableObjectPType): PType | undefined;
-    visitObjectLiteralPType(ptype: ObjectLiteralPType): PType | undefined;
-    visitReferenceArrayType(ptype: ReferenceArrayType): PType | undefined;
-    visitDynamicArrayType(ptype: DynamicArrayType): PType | undefined;
-    visitStaticArrayType(ptype: StaticArrayType): PType | undefined;
-    visitFixedArrayPType(ptype: FixedArrayPType): PType | undefined;
-    visitReadonlyArrayPType(ptype: ReadonlyArrayPType): PType | undefined;
-    visitArrayPType(ptype: ArrayPType): PType | undefined;
-    visitReadonlyTuplePType(ptype: ReadonlyTuplePType): PType | undefined;
-    visitMutableTuplePType(ptype: MutableTuplePType): PType | undefined;
-    visitArrayLiteralPType(ptype: ArrayLiteralPType): PType | undefined;
-}

package/awst_build/type-resolver.d.ts

@@ -32,7 +32,7 @@ export declare class TypeResolver {
     private reflectStructType;
     private reflectContractType;
     private resolveClusteredPrototype;
-    getTypeName(type: ts.Type, sourceLocation: SourceLocation): SymbolName | undefined;
+    getTypeName(type: ts.Type): SymbolName | undefined;
     private getLocationOfSymbol;
     private tryGetLocalSymbolName;
     private getSymbolFullName;

package/bin/puyats-clientgen.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../clientgen';

package/bin/puyats-clientgen.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+import { arc32ToArc56 } from '@algorandfoundation/algokit-utils/app-spec';
+import { ArgumentParser } from 'argparse';
+import { readFile } from 'fs/promises';
+import { w as writeARC4Client } from '../arc4-clientgen-BMCeFyNd.js';
+import { a as appVersion } from '../semver-DpFo0aCr.js';
+import { c as checkNodeVersion } from '../check-node-version-BP_a9Mv8.js';
+import { a as addEnumArg, C as ConsoleLogSink } from '../util-JPoBh0Op.js';
+import { L as LogLevel, l as logger, A as AbsolutePath, P as PuyaError, a as LoggingContext } from '../contract-class-model-pgJctz5F.js';
+import '@algorandfoundation/algokit-utils/abi';
+import 'fs';
+import 'node:url';
+import 'pathe';
+import 'chalk';
+import 'typescript';
+import 'node:fs';
+import 'node:util';
+import 'node:crypto';
+import 'polytype';
+import 'node:async_hooks';
+
+async function parseCliArguments() {
+    checkNodeVersion();
+    const parser = new ArgumentParser({
+        prog: 'puya-ts-clientgen',
+    });
+    addEnumArg(parser, {
+        name: '--log-level',
+        default: LogLevel.Info,
+        enumType: LogLevel,
+        help: 'The minimum log level to output',
+    });
+    parser.add_argument('--version', {
+        action: 'store_const',
+        help: 'Show application version',
+        const: 'version',
+        dest: 'command',
+    });
+    parser.add_argument('specs', {
+        metavar: 'SPECS',
+        nargs: '+',
+        help: 'The path, or paths to the .arc32.json or .arc56.json files',
+    });
+    parser.add_argument('--out-dir', {
+        action: 'store',
+        help: 'Where to output clientgen artifacts',
+        default: 'out',
+    });
+    parser.set_defaults({
+        command: 'clientgen',
+    });
+    const result = parser.parse_args();
+    switch (result.command) {
+        case 'clientgen':
+            await outputStubs(result.specs, result.out_dir, result.log_level);
+            break;
+        case 'version':
+            /* eslint-disable-next-line no-console */
+            console.log(appVersion());
+            break;
+        default:
+            parser.print_help();
+            break;
+    }
+}
+async function outputStubs(paths, outDir, logLevel) {
+    const logCtx = LoggingContext.create();
+    return logCtx.run(async () => {
+        logger.configure([new ConsoleLogSink(logLevel, AbsolutePath.resolve({ path: '' }))]);
+        for (const appSpecPath of paths) {
+            try {
+                const appSpecJSON = JSON.parse(await readFile(appSpecPath, { encoding: 'utf-8' }));
+                let appSpec;
+                if (appSpecPath.endsWith('.arc56.json')) {
+                    appSpec = appSpecJSON;
+                }
+                else {
+                    appSpec = arc32ToArc56(appSpecJSON);
+                }
+                const sourceFile = AbsolutePath.resolve({ path: appSpecPath });
+                const outFile = AbsolutePath.resolve({ path: outDir, workingDirectory: sourceFile.resolve('..') }).join(`${appSpec.name}.client.ts`);
+                await writeARC4Client(appSpec, outFile);
+            }
+            catch (e) {
+                if (e instanceof PuyaError) {
+                    logger.error(e);
+                }
+                else if (e instanceof Error) {
+                    logger.error(e);
+                    throw e;
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+        logCtx.exitIfErrors();
+    });
+}
+void parseCliArguments();
+//# sourceMappingURL=puyats-clientgen.mjs.map

package/bin/puyats-clientgen.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"puyats-clientgen.mjs","sources":["../../src/clientgen.ts"],"sourcesContent":["import type { Arc56Contract } from '@algorandfoundation/algokit-utils/abi'\nimport { arc32ToArc56 } from '@algorandfoundation/algokit-utils/app-spec'\nimport { ArgumentParser } from 'argparse'\nimport { readFile } from 'fs/promises'\nimport { writeARC4Client } from './arc4-clientgen'\nimport { appVersion } from './cli/app-version'\nimport { checkNodeVersion } from './cli/check-node-version'\nimport { addEnumArg } from './cli/util'\nimport { PuyaError } from './errors'\nimport { logger, LoggingContext, LogLevel } from './logger'\nimport { ConsoleLogSink } from './logger/sinks/console-log-sink'\nimport { AbsolutePath } from './util/absolute-path'\n\ninterface ClientgenCommandArgs {\n  command: 'clientgen'\n  specs: string[]\n  out_dir: string\n  log_level: LogLevel\n}\n\ninterface VersionCommand {\n  command: 'version'\n}\n\ntype PuyaTsClientgenCommand = ClientgenCommandArgs | VersionCommand\n\nasync function parseCliArguments() {\n  checkNodeVersion()\n  const parser = new ArgumentParser({\n    prog: 'puya-ts-clientgen',\n  })\n\n  addEnumArg(parser, {\n    name: '--log-level',\n    default: LogLevel.Info,\n    enumType: LogLevel,\n    help: 'The minimum log level to output',\n  })\n  parser.add_argument('--version', {\n    action: 'store_const',\n    help: 'Show application version',\n    const: 'version',\n    dest: 'command',\n  })\n  parser.add_argument('specs', {\n    metavar: 'SPECS',\n    nargs: '+',\n    help: 'The path, or paths to the .arc32.json or .arc56.json files',\n  })\n  parser.add_argument('--out-dir', {\n    action: 'store',\n    help: 'Where to output clientgen artifacts',\n    default: 'out',\n  })\n  parser.set_defaults({\n    command: 'clientgen',\n  })\n  const result: PuyaTsClientgenCommand = parser.parse_args()\n  switch (result.command) {\n    case 'clientgen':\n      await outputStubs(result.specs, result.out_dir, result.log_level)\n      break\n    case 'version':\n      /* eslint-disable-next-line no-console */\n      console.log(appVersion())\n      break\n    default:\n      parser.print_help()\n      break\n  }\n}\n\nasync function outputStubs(paths: string[], outDir: string, logLevel: LogLevel) {\n  const logCtx = LoggingContext.create()\n  return logCtx.run(async () => {\n    logger.configure([new ConsoleLogSink(logLevel, AbsolutePath.resolve({ path: '' }))])\n    for (const appSpecPath of paths) {\n      try {\n        const appSpecJSON = JSON.parse(await readFile(appSpecPath, { encoding: 'utf-8' }))\n        let appSpec: Arc56Contract\n        if (appSpecPath.endsWith('.arc56.json')) {\n          appSpec = appSpecJSON\n        } else {\n          appSpec = arc32ToArc56(appSpecJSON)\n        }\n        const sourceFile = AbsolutePath.resolve({ path: appSpecPath })\n        const outFile = AbsolutePath.resolve({ path: outDir, workingDirectory: sourceFile.resolve('..') }).join(`${appSpec.name}.client.ts`)\n        await writeARC4Client(appSpec, outFile)\n      } catch (e) {\n        if (e instanceof PuyaError) {\n          logger.error(e)\n        } else if (e instanceof Error) {\n          logger.error(e)\n          throw e\n        } else {\n          throw e\n        }\n      }\n    }\n    logCtx.exitIfErrors()\n  })\n}\n\nvoid parseCliArguments()\n"],"names":[],"mappings":"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"}