@algorandfoundation/algorand-typescript-testing 1.0.0-beta.11 → 1.0.0-beta.12

package/abi-metadata.d.ts

@@ -1,5 +1,5 @@
-import { BaseContract, Contract } from '@algorandfoundation/algorand-typescript';
-import { AbiMethodConfig, BareMethodConfig, CreateOptions, OnCompleteActionStr } from '@algorandfoundation/algorand-typescript/arc4';
+import type { BaseContract, Contract } from '@algorandfoundation/algorand-typescript';
+import type { AbiMethodConfig, BareMethodConfig, CreateOptions, OnCompleteActionStr } from '@algorandfoundation/algorand-typescript/arc4';
 export interface AbiMetadata {
     methodName: string;
     methodSignature: string | undefined;

package/collections/custom-key-map.d.ts

@@ -1,5 +1,6 @@
-import { Account, internal } from '@algorandfoundation/algorand-typescript';
-import { DeliberateAny } from '../typescript-helpers';
+import type { Account } from '@algorandfoundation/algorand-typescript';
+import { internal } from '@algorandfoundation/algorand-typescript';
+import type { DeliberateAny } from '../typescript-helpers';
 export declare abstract class CustomKeyMap<TKey, TValue> implements Map<TKey, TValue> {
     #private;
     constructor(keySerializer: (key: TKey) => number | bigint | string);

package/context-helpers/context-util.d.ts

@@ -1,3 +1,3 @@
-import { uint64 } from '@algorandfoundation/algorand-typescript';
-import { AbiMetadata } from '../abi-metadata';
+import type { uint64 } from '@algorandfoundation/algorand-typescript';
+import type { AbiMetadata } from '../abi-metadata';
 export declare const checkRoutingConditions: (appId: uint64, metadata: AbiMetadata) => void;

package/context-helpers/internal-context.d.ts

@@ -1,10 +1,9 @@
-import { Account, BaseContract, internal } from '@algorandfoundation/algorand-typescript';
-import { AccountData } from '../impl/account';
-import { ApplicationData } from '../impl/application';
-import { AssetData } from '../impl/asset';
-import { VoterData } from '../impl/voter-params';
-import { TransactionGroup } from '../subcontexts/transaction-context';
-import { TestExecutionContext } from '../test-execution-context';
+import type { Account } from '@algorandfoundation/algorand-typescript';
+import { BaseContract, internal } from '@algorandfoundation/algorand-typescript';
+import type { AccountData, ApplicationData, AssetData } from '../impl/reference';
+import type { VoterData } from '../impl/voter-params';
+import type { TransactionGroup } from '../subcontexts/transaction-context';
+import type { TestExecutionContext } from '../test-execution-context';
 /**
  * For accessing implementation specific functions, with a convenient single entry
  * point for other modules to import Also allows for a single place to check and

package/decode-logs.d.ts

@@ -1,4 +1,4 @@
-import { bytes } from '@algorandfoundation/algorand-typescript';
+import type { bytes } from '@algorandfoundation/algorand-typescript';
 export type LogDecoding = 'i' | 's' | 'b';
 export type DecodedLog<T extends LogDecoding> = T extends 'i' ? bigint : T extends 's' ? string : Uint8Array;
 export type DecodedLogs<T extends [...LogDecoding[]]> = {

package/encoders.d.ts

@@ -1,5 +1,6 @@
-import { bytes, internal } from '@algorandfoundation/algorand-typescript';
-import { DeliberateAny } from './typescript-helpers';
+import type { bytes } from '@algorandfoundation/algorand-typescript';
+import { internal } from '@algorandfoundation/algorand-typescript';
+import type { DeliberateAny } from './typescript-helpers';
 export type TypeInfo = {
     name: string;
     genericArgs?: TypeInfo[] | Record<string, TypeInfo>;

package/impl/acct-params.d.ts

@@ -1,4 +1,5 @@
-import { Account, Application, internal, uint64 } from '@algorandfoundation/algorand-typescript';
+import type { internal, uint64 } from '@algorandfoundation/algorand-typescript';
+import type { Account, Application } from '@algorandfoundation/algorand-typescript';
 export declare const getAccount: (acct: Account | internal.primitives.StubUint64Compat) => Account;
 export declare const balance: (a: Account | internal.primitives.StubUint64Compat) => uint64;
 export declare const minBalance: (a: Account | internal.primitives.StubUint64Compat) => uint64;

package/impl/app-global.d.ts

@@ -1,2 +1,2 @@
-import { internal } from '@algorandfoundation/algorand-typescript';
+import type { internal } from '@algorandfoundation/algorand-typescript';
 export declare const AppGlobal: internal.opTypes.AppGlobalType;

package/impl/app-local.d.ts

@@ -1,2 +1,2 @@
-import { internal } from '@algorandfoundation/algorand-typescript';
+import type { internal } from '@algorandfoundation/algorand-typescript';
 export declare const AppLocal: internal.opTypes.AppLocalType;

package/impl/app-params.d.ts

@@ -1,3 +1,3 @@
-import { Application, internal } from '@algorandfoundation/algorand-typescript';
-export declare const getApp: (app: Application | internal.primitives.StubUint64Compat) => Application | undefined;
+import type { internal, Application as ApplicationType } from '@algorandfoundation/algorand-typescript';
+export declare const getApp: (app: ApplicationType | internal.primitives.StubUint64Compat) => ApplicationType | undefined;
 export declare const AppParams: internal.opTypes.AppParamsType;

package/impl/asset-holding.d.ts

@@ -1,2 +1,2 @@
-import { internal } from '@algorandfoundation/algorand-typescript';
+import type { internal } from '@algorandfoundation/algorand-typescript';
 export declare const AssetHolding: internal.opTypes.AssetHoldingType;

package/impl/asset-params.d.ts

@@ -1,3 +1,4 @@
-import { Asset, internal } from '@algorandfoundation/algorand-typescript';
-export declare const getAsset: (asset: Asset | internal.primitives.StubUint64Compat) => Asset | undefined;
+import type { internal } from '@algorandfoundation/algorand-typescript';
+import { type Asset as AssetType } from '@algorandfoundation/algorand-typescript';
+export declare const getAsset: (asset: AssetType | internal.primitives.StubUint64Compat) => AssetType | undefined;
 export declare const AssetParams: internal.opTypes.AssetParamsType;

package/impl/base.d.ts

@@ -1,4 +1,5 @@
-import { bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript';
+import type { bytes, uint64 } from '@algorandfoundation/algorand-typescript';
+import { internal } from '@algorandfoundation/algorand-typescript';
 import type { TypeInfo } from '../encoders';
 export declare abstract class BytesBackedCls {
     #private;

package/impl/block.d.ts

@@ -1,12 +1,12 @@
-import { Account, bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript';
+import type { bytes, internal, uint64, Account as AccountType } from '@algorandfoundation/algorand-typescript';
 export declare class BlockData {
     seed: bytes;
     timestamp: uint64;
-    proposer: Account;
+    proposer: AccountType;
     feesCollected: uint64;
     bonus: uint64;
     branch: bytes;
-    feeSink: Account;
+    feeSink: AccountType;
     protocol: bytes;
     txnCounter: uint64;
     proposerPayout: uint64;

package/impl/compiled.d.ts

@@ -1,3 +1,3 @@
-import { BaseContract, CompileContractOptions, CompiledContract, CompiledLogicSig, CompileLogicSigOptions, LogicSig } from '@algorandfoundation/algorand-typescript';
-import { ConstructorFor } from '../typescript-helpers';
+import type { BaseContract, CompileContractOptions, CompiledContract, CompiledLogicSig, CompileLogicSigOptions, LogicSig } from '@algorandfoundation/algorand-typescript';
+import type { ConstructorFor } from '../typescript-helpers';
 export declare function compileImpl(artefact: ConstructorFor<BaseContract> | ConstructorFor<LogicSig>, options?: CompileContractOptions | CompileLogicSigOptions): CompiledLogicSig | CompiledContract;

package/impl/crypto.d.ts

@@ -1,4 +1,5 @@
-import { bytes, Ecdsa, internal, MimcConfigurations, VrfVerify } from '@algorandfoundation/algorand-typescript';
+import type { bytes, MimcConfigurations, VrfVerify } from '@algorandfoundation/algorand-typescript';
+import { Ecdsa, internal } from '@algorandfoundation/algorand-typescript';
 export declare const sha256: (a: internal.primitives.StubBytesCompat) => bytes;
 export declare const sha3_256: (a: internal.primitives.StubBytesCompat) => bytes;
 export declare const keccak256: (a: internal.primitives.StubBytesCompat) => bytes;

package/impl/encoded-types.d.ts

@@ -1,7 +1,9 @@
-import { Account, BigUintCompat, bytes, internal, StringCompat, uint64, Uint64Compat } from '@algorandfoundation/algorand-typescript';
-import { Address, ARC4Encoded, BitSize, Bool, Byte, DynamicArray, DynamicBytes, StaticArray, StaticBytes, Str, Tuple, UFixedNxM, UintN } from '@algorandfoundation/algorand-typescript/arc4';
-import { fromBytes, TypeInfo } from '../encoders';
-import { DeliberateAny } from '../typescript-helpers';
+import type { BigUintCompat, bytes, StringCompat, uint64, Uint64Compat, Account as AccountType } from '@algorandfoundation/algorand-typescript';
+import { internal } from '@algorandfoundation/algorand-typescript';
+import type { BitSize } from '@algorandfoundation/algorand-typescript/arc4';
+import { Address, ARC4Encoded, Bool, Byte, DynamicArray, DynamicBytes, StaticArray, StaticBytes, Str, Tuple, UFixedNxM, UintN } from '@algorandfoundation/algorand-typescript/arc4';
+import type { fromBytes, TypeInfo } from '../encoders';
+import type { DeliberateAny } from '../typescript-helpers';
 type CompatForArc4Int<N extends BitSize> = N extends 8 | 16 | 32 | 64 ? Uint64Compat : BigUintCompat;
 export declare class UintNImpl<N extends BitSize> extends UintN<N> {
     private value;
@@ -84,11 +86,11 @@ export declare class StaticArrayImpl<TItem extends ARC4Encoded, TLength extends
 export declare class AddressImpl extends Address {
     typeInfo: TypeInfo;
     private value;
-    constructor(typeInfo: TypeInfo | string, value?: Account | string | bytes);
+    constructor(typeInfo: TypeInfo | string, value?: AccountType | string | bytes);
     get bytes(): bytes;
     equals(other: this): boolean;
     get length(): uint64;
-    get native(): Account;
+    get native(): AccountType;
     get items(): ByteImpl[];
     setItem(_index: number, _value: ByteImpl): void;
     static fromBytesImpl(value: internal.primitives.StubBytesCompat | Uint8Array, typeInfo: string | TypeInfo, prefix?: 'none' | 'log'): AddressImpl;

package/impl/ensure-budget.d.ts

@@ -1,2 +1,3 @@
-import { OpUpFeeSource, uint64 } from '@algorandfoundation/algorand-typescript';
+import type { uint64 } from '@algorandfoundation/algorand-typescript';
+import { OpUpFeeSource } from '@algorandfoundation/algorand-typescript';
 export declare function ensureBudgetImpl(_budget: uint64, _feeSource?: OpUpFeeSource): void;

package/impl/global.d.ts

@@ -1,9 +1,10 @@
-import { Account, bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript';
+import type { bytes, uint64, Account as AccountType } from '@algorandfoundation/algorand-typescript';
+import { internal } from '@algorandfoundation/algorand-typescript';
 export declare class GlobalData {
     minTxnFee: uint64;
     minBalance: uint64;
     maxTxnLife: uint64;
-    zeroAddress: Account;
+    zeroAddress: AccountType;
     logicSigVersion?: uint64;
     round?: uint64;
     latestTimestamp?: uint64;

package/impl/gtxn.d.ts

@@ -1,2 +1,2 @@
-import { internal } from '@algorandfoundation/algorand-typescript';
+import type { internal } from '@algorandfoundation/algorand-typescript';
 export declare const GTxn: internal.opTypes.GTxnType;

package/impl/inner-transactions.d.ts

@@ -1,5 +1,6 @@
-import { itxn, TransactionType } from '@algorandfoundation/algorand-typescript';
-import { InnerTxn, InnerTxnFields } from './itxn';
+import type { itxn } from '@algorandfoundation/algorand-typescript';
+import { TransactionType } from '@algorandfoundation/algorand-typescript';
+import type { InnerTxn, InnerTxnFields } from './itxn';
 import { ApplicationTransaction, AssetConfigTransaction, AssetFreezeTransaction, AssetTransferTransaction, KeyRegistrationTransaction, PaymentTransaction } from './transactions';
 export declare class PaymentInnerTxn extends PaymentTransaction implements itxn.PaymentInnerTxn {
     readonly isItxn?: true;

package/impl/itxn.d.ts

@@ -1,4 +1,4 @@
-import { internal, itxn, TransactionType } from '@algorandfoundation/algorand-typescript';
+import type { internal, itxn, TransactionType } from '@algorandfoundation/algorand-typescript';
 export type InnerTxn = itxn.PaymentInnerTxn | itxn.KeyRegistrationInnerTxn | itxn.AssetConfigInnerTxn | itxn.AssetTransferInnerTxn | itxn.AssetFreezeInnerTxn | itxn.ApplicationInnerTxn;
 export type InnerTxnFields = (itxn.PaymentFields | itxn.KeyRegistrationFields | itxn.AssetConfigFields | itxn.AssetTransferFields | itxn.AssetFreezeFields | itxn.ApplicationCallFields) & {
     type?: TransactionType;

package/impl/log.d.ts

@@ -0,0 +1,3 @@
+import type { BytesBacked, StringCompat } from '@algorandfoundation/algorand-typescript';
+import { internal } from '@algorandfoundation/algorand-typescript';
+export declare function log(...args: Array<internal.primitives.StubUint64Compat | internal.primitives.StubBytesCompat | internal.primitives.StubBigUintCompat | StringCompat | BytesBacked>): void;

package/impl/logicSigArg.d.ts

@@ -1,2 +1,2 @@
-import { bytes, internal } from '@algorandfoundation/algorand-typescript';
+import type { bytes, internal } from '@algorandfoundation/algorand-typescript';
 export declare const arg: (a: internal.primitives.StubUint64Compat) => bytes;

package/impl/match.d.ts

@@ -1,3 +1,3 @@
-import { assertMatch, match } from '@algorandfoundation/algorand-typescript';
+import type { assertMatch, match } from '@algorandfoundation/algorand-typescript';
 export declare const matchImpl: typeof match;
 export declare const assertMatchImpl: typeof assertMatch;

package/impl/online-stake.d.ts

@@ -1,2 +1,2 @@
-import { internal } from '@algorandfoundation/algorand-typescript';
+import type { internal } from '@algorandfoundation/algorand-typescript';
 export declare const onlineStake: internal.opTypes.OnlineStakeType;

package/impl/pure.d.ts

@@ -1,4 +1,5 @@
-import { Base64, biguint, bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript';
+import type { biguint, bytes, uint64 } from '@algorandfoundation/algorand-typescript';
+import { Base64, internal } from '@algorandfoundation/algorand-typescript';
 export declare const addw: (a: internal.primitives.StubUint64Compat, b: internal.primitives.StubUint64Compat) => readonly [uint64, uint64];
 export declare const base64Decode: (e: Base64, a: internal.primitives.StubBytesCompat) => bytes;
 export declare const bitLength: (a: internal.primitives.StubUint64Compat | internal.primitives.StubBytesCompat) => uint64;

package/impl/reference.d.ts

@@ -0,0 +1,90 @@
+import type { bytes, LocalState, uint64, Account as AccountType, Application as ApplicationType, Asset as AssetType } from '@algorandfoundation/algorand-typescript';
+import { internal } from '@algorandfoundation/algorand-typescript';
+import { BytesMap, Uint64Map } from '../collections/custom-key-map';
+import type { Mutable } from '../typescript-helpers';
+import { BytesBackedCls, Uint64BackedCls } from './base';
+import type { GlobalStateCls } from './state';
+export declare class AssetHolding {
+    balance: uint64;
+    frozen: boolean;
+    constructor(balance: internal.primitives.StubUint64Compat, frozen: boolean);
+}
+export declare class AccountData {
+    optedAssets: Uint64Map<AssetHolding>;
+    optedApplications: Uint64Map<ApplicationType>;
+    incentiveEligible: boolean;
+    lastProposed?: uint64;
+    lastHeartbeat?: uint64;
+    account: Mutable<Omit<AccountType, 'bytes' | 'isOptedIn'>>;
+    constructor();
+}
+export declare function Account(address?: bytes): AccountType;
+export declare class AccountCls extends BytesBackedCls implements AccountType {
+    constructor(address?: bytes);
+    private get data();
+    get balance(): uint64;
+    get minBalance(): uint64;
+    get authAddress(): AccountType;
+    get totalNumUint(): uint64;
+    get totalNumByteSlice(): uint64;
+    get totalExtraAppPages(): uint64;
+    get totalAppsCreated(): uint64;
+    get totalAppsOptedIn(): uint64;
+    get totalAssetsCreated(): uint64;
+    get totalAssets(): uint64;
+    get totalBoxes(): uint64;
+    get totalBoxBytes(): uint64;
+    isOptedIn(assetOrApp: AssetType | ApplicationType): boolean;
+}
+export declare class ApplicationData {
+    application: Mutable<Omit<ApplicationType, 'id' | 'address'>> & {
+        appLogs: bytes[];
+        globalStates: BytesMap<GlobalStateCls<unknown>>;
+        localStates: BytesMap<LocalState<unknown>>;
+        boxes: BytesMap<Uint8Array>;
+    };
+    isCreating: boolean;
+    get appLogs(): bytes[];
+    constructor();
+}
+export declare function Application(id?: uint64): ApplicationType;
+export declare class ApplicationCls extends Uint64BackedCls implements ApplicationType {
+    get id(): uint64;
+    constructor(id?: uint64);
+    private get data();
+    get approvalProgram(): bytes;
+    get clearStateProgram(): bytes;
+    get globalNumUint(): uint64;
+    get globalNumBytes(): uint64;
+    get localNumUint(): uint64;
+    get localNumBytes(): uint64;
+    get extraProgramPages(): uint64;
+    get creator(): AccountType;
+    get address(): AccountType;
+}
+export type AssetData = Mutable<Omit<AssetType, 'id' | 'balance' | 'frozen'>>;
+export declare function Asset(id?: uint64): AssetType;
+export declare class AssetCls extends Uint64BackedCls implements AssetType {
+    get id(): uint64;
+    constructor(id?: internal.primitives.StubUint64Compat);
+    private get data();
+    get total(): uint64;
+    get decimals(): uint64;
+    get defaultFrozen(): boolean;
+    get unitName(): bytes;
+    get name(): bytes;
+    get url(): bytes;
+    get metadataHash(): bytes;
+    get manager(): AccountType;
+    get reserve(): AccountType;
+    get freeze(): AccountType;
+    get clawback(): AccountType;
+    get creator(): AccountType;
+    balance(account: AccountType): uint64;
+    frozen(account: AccountType): boolean;
+    private getAssetHolding;
+}
+export declare const checksumFromPublicKey: (pk: Uint8Array) => Uint8Array;
+export declare const getApplicationAddress: (appId: internal.primitives.StubUint64Compat) => AccountType;
+export declare const encodeAddress: (address: Uint8Array) => string;
+export declare const decodePublicKey: (address: string) => Uint8Array;

package/impl/state.d.ts

@@ -1,4 +1,5 @@
-import { Account, BoxMap as BoxMapType, BoxRef as BoxRefType, Box as BoxType, bytes, GlobalStateOptions, GlobalState as GlobalStateType, internal, LocalState as LocalStateType, uint64 } from '@algorandfoundation/algorand-typescript';
+import type { BoxMap as BoxMapType, BoxRef as BoxRefType, Box as BoxType, bytes, GlobalStateOptions, GlobalState as GlobalStateType, LocalState as LocalStateType, uint64, Account } from '@algorandfoundation/algorand-typescript';
+import { internal } from '@algorandfoundation/algorand-typescript';
 export declare class GlobalStateCls<ValueType> {
     #private;
     private readonly _type;

package/impl/transactions.d.ts

@@ -1,7 +1,8 @@
-import { Account, Application, arc4, Asset, bytes, gtxn, internal, TransactionType, uint64 } from '@algorandfoundation/algorand-typescript';
-import { Mutable, ObjectKeys } from '../typescript-helpers';
+import type { arc4, bytes, gtxn, uint64, Account as AccountType, Application as ApplicationType, Asset as AssetType } from '@algorandfoundation/algorand-typescript';
+import { internal, TransactionType } from '@algorandfoundation/algorand-typescript';
+import type { Mutable, ObjectKeys } from '../typescript-helpers';
 declare const baseDefaultFields: () => {
-    sender: Account;
+    sender: AccountType;
     fee: uint64;
     firstValid: uint64;
     firstValidTime: uint64;
@@ -10,12 +11,12 @@ declare const baseDefaultFields: () => {
     lease: bytes;
     groupIndex: uint64;
     txnId: bytes;
-    rekeyTo: Account;
+    rekeyTo: AccountType;
 };
 export type TxnFields<TTxn> = Partial<Mutable<Pick<TTxn, ObjectKeys<TTxn>>>>;
 declare abstract class TransactionBase {
     protected constructor(fields: Partial<ReturnType<typeof baseDefaultFields>>);
-    readonly sender: Account;
+    readonly sender: AccountType;
     readonly fee: uint64;
     readonly firstValid: uint64;
     readonly firstValidTime: uint64;
@@ -24,16 +25,16 @@ declare abstract class TransactionBase {
     readonly lease: bytes;
     readonly groupIndex: uint64;
     readonly txnId: bytes;
-    readonly rekeyTo: Account;
+    readonly rekeyTo: AccountType;
     readonly scratchSpace: Array<bytes | uint64>;
     setScratchSlot(index: internal.primitives.StubUint64Compat, value: internal.primitives.StubBytesCompat | internal.primitives.StubUint64Compat): void;
     getScratchSlot(index: internal.primitives.StubUint64Compat): bytes | uint64;
 }
 export declare class PaymentTransaction extends TransactionBase implements gtxn.PaymentTxn {
     protected constructor(fields: TxnFields<gtxn.PaymentTxn>);
-    readonly receiver: Account;
+    readonly receiver: AccountType;
     readonly amount: uint64;
-    readonly closeRemainderTo: Account;
+    readonly closeRemainderTo: AccountType;
     readonly type: TransactionType.Payment;
     readonly typeBytes: bytes;
 }
@@ -51,7 +52,7 @@ export declare class KeyRegistrationTransaction extends TransactionBase implemen
 }
 export declare class AssetConfigTransaction extends TransactionBase implements gtxn.AssetConfigTxn {
     protected constructor(fields: TxnFields<gtxn.AssetConfigTxn>);
-    readonly configAsset: Asset;
+    readonly configAsset: AssetType;
     readonly total: uint64;
     readonly decimals: uint64;
     readonly defaultFrozen: boolean;
@@ -59,37 +60,37 @@ export declare class AssetConfigTransaction extends TransactionBase implements g
     readonly assetName: bytes;
     readonly url: bytes;
     readonly metadataHash: bytes;
-    readonly manager: Account;
-    readonly reserve: Account;
-    readonly freeze: Account;
-    readonly clawback: Account;
-    readonly createdAsset: Asset;
+    readonly manager: AccountType;
+    readonly reserve: AccountType;
+    readonly freeze: AccountType;
+    readonly clawback: AccountType;
+    readonly createdAsset: AssetType;
     readonly type: TransactionType.AssetConfig;
     readonly typeBytes: bytes;
 }
 export declare class AssetTransferTransaction extends TransactionBase implements gtxn.AssetTransferTxn {
     protected constructor(fields: TxnFields<gtxn.AssetTransferTxn>);
-    readonly xferAsset: Asset;
+    readonly xferAsset: AssetType;
     readonly assetAmount: uint64;
-    readonly assetSender: Account;
-    readonly assetReceiver: Account;
-    readonly assetCloseTo: Account;
+    readonly assetSender: AccountType;
+    readonly assetReceiver: AccountType;
+    readonly assetCloseTo: AccountType;
     readonly type: TransactionType.AssetTransfer;
     readonly typeBytes: bytes;
 }
 export declare class AssetFreezeTransaction extends TransactionBase implements gtxn.AssetFreezeTxn {
     protected constructor(fields: TxnFields<gtxn.AssetFreezeTxn>);
-    readonly freezeAsset: Asset;
-    readonly freezeAccount: Account;
+    readonly freezeAsset: AssetType;
+    readonly freezeAccount: AccountType;
     readonly frozen: boolean;
     readonly type: TransactionType.AssetFreeze;
     readonly typeBytes: bytes;
 }
 export type ApplicationTransactionFields = TxnFields<gtxn.ApplicationTxn> & Partial<{
     appArgs: Array<unknown>;
-    accounts: Array<Account>;
-    assets: Array<Asset>;
-    apps: Array<Application>;
+    accounts: Array<AccountType>;
+    assets: Array<AssetType>;
+    apps: Array<ApplicationType>;
     approvalProgramPages: Array<bytes>;
     clearStateProgramPages: Array<bytes>;
     appLogs: Array<bytes>;
@@ -98,14 +99,14 @@ export type ApplicationTransactionFields = TxnFields<gtxn.ApplicationTxn> & Part
 export declare class ApplicationTransaction extends TransactionBase implements gtxn.ApplicationTxn {
     #private;
     protected constructor(fields: ApplicationTransactionFields);
-    readonly appId: Application;
+    readonly appId: ApplicationType;
     readonly onCompletion: arc4.OnCompleteActionStr;
     readonly globalNumUint: uint64;
     readonly globalNumBytes: uint64;
     readonly localNumUint: uint64;
     readonly localNumBytes: uint64;
     readonly extraProgramPages: uint64;
-    readonly createdApp: Application;
+    readonly createdApp: ApplicationType;
     get approvalProgram(): bytes;
     get clearStateProgram(): bytes;
     get numAppArgs(): uint64;
@@ -116,13 +117,13 @@ export declare class ApplicationTransaction extends TransactionBase implements g
     get numClearStateProgramPages(): uint64;
     get numLogs(): uint64;
     get lastLog(): bytes;
-    get apat(): Account[];
-    get apas(): Asset[];
-    get apfa(): Application[];
+    get apat(): AccountType[];
+    get apas(): AssetType[];
+    get apfa(): ApplicationType[];
     appArgs(index: internal.primitives.StubUint64Compat): bytes;
-    accounts(index: internal.primitives.StubUint64Compat): Account;
-    assets(index: internal.primitives.StubUint64Compat): Asset;
-    apps(index: internal.primitives.StubUint64Compat): Application;
+    accounts(index: internal.primitives.StubUint64Compat): AccountType;
+    assets(index: internal.primitives.StubUint64Compat): AssetType;
+    apps(index: internal.primitives.StubUint64Compat): ApplicationType;
     approvalProgramPages(index: internal.primitives.StubUint64Compat): bytes;
     clearStateProgramPages(index: internal.primitives.StubUint64Compat): bytes;
     logs(index: internal.primitives.StubUint64Compat): bytes;

package/impl/txn.d.ts

@@ -1,3 +1,4 @@
-import { internal, uint64 } from '@algorandfoundation/algorand-typescript';
+import type { uint64 } from '@algorandfoundation/algorand-typescript';
+import { internal } from '@algorandfoundation/algorand-typescript';
 export declare const gaid: (a: internal.primitives.StubUint64Compat) => uint64;
 export declare const Txn: internal.opTypes.TxnType;

package/impl/urange.d.ts

@@ -1,2 +1,2 @@
-import { internal } from '@algorandfoundation/algorand-typescript';
+import type { internal } from '@algorandfoundation/algorand-typescript';
 export declare function urangeImpl(a: internal.primitives.StubUint64Compat, b?: internal.primitives.StubUint64Compat, c?: internal.primitives.StubUint64Compat): Generator<import("@algorandfoundation/algorand-typescript").uint64, number, unknown>;

package/impl/voter-params.d.ts

@@ -1,4 +1,4 @@
-import { internal, uint64 } from '@algorandfoundation/algorand-typescript';
+import type { internal, uint64 } from '@algorandfoundation/algorand-typescript';
 export declare class VoterData {
     balance: uint64;
     incentiveEligible: boolean;