@algorandfoundation/algokit-utils 10.0.0-alpha.8 → 10.0.0-beta.1

package/app-client.d.ts

@@ -0,0 +1,1042 @@
+import { Address, ReadableAddress } from "./packages/common/src/address.js";
+import { Expand } from "./packages/common/src/expand.js";
+import { ProgramSourceMap } from "./packages/common/src/sourcemap.js";
+import { ABIValue } from "./packages/abi/src/abi-value.js";
+import { Arc56Contract, ProgramSourceInfo } from "./packages/abi/src/arc56-contract.js";
+import { ABIType } from "./packages/abi/src/abi-type.js";
+import { ABIMethod, ABIReturn } from "./packages/abi/src/abi-method.js";
+import { OnApplicationComplete, ResourceReference } from "./packages/transact/src/transactions/app-call.js";
+import { Transaction } from "./packages/transact/src/transactions/transaction.js";
+import { AddressWithTransactionSigner, SendingAddress, TransactionSigner } from "./packages/transact/src/signer.js";
+import { PendingTransactionResponse } from "./packages/algod_client/src/models/pending-transaction-response.js";
+import { SuggestedParams } from "./packages/algod_client/src/models/suggested-params.js";
+import { AlgoAmount } from "./amount.js";
+import { IndexerClient } from "./packages/indexer_client/src/client.js";
+import { SendParams, SendTransactionFrom, SendTransactionParams, TransactionNote } from "./transaction/types.js";
+import { TransactionWithSigner } from "./transaction/transaction.js";
+import { ABIAppCallArgs, AppCompilationResult, AppLookup, AppReturn, AppState, AppStorageSchema, BoxName, CompiledTeal, OnSchemaBreak, OnUpdate, RawAppCallArgs, SendAppTransactionResult, TealTemplateParams } from "./app.js";
+import { AppManager, BoxIdentifier, BoxReference } from "./app-manager.js";
+import { AppCreateParams, AppMethodCallParams, AppUpdateParams, CommonAppCallParams } from "./transactions/app-call.js";
+import { AppMethodCall, AppMethodCallTransactionArgument } from "./transactions/method-call.js";
+import { PaymentParams } from "./transactions/payment.js";
+import { AppLookup as AppLookup$1 } from "./app-deployer.js";
+import { AlgorandClient } from "./algorand-client.js";
+import { AppSpec } from "./app-spec.js";
+
+//#region src/app-client.d.ts
+/** Configuration to resolve app by creator and name `getCreatorAppsByName` */
+type ResolveAppByCreatorAndNameBase = {
+  /** The address of the app creator account to resolve the app by */creatorAddress: ReadableAddress; /** The optional name override to resolve the app by within the creator account (default: uses the name in the ABI contract) */
+  name?: string;
+  /** The mechanism to find an existing app instance metadata for the given creator and name; either:
+   *  * An indexer instance to search the creator account apps; or
+   *  * The cached value of the existing apps for the given creator from `getCreatorAppsByName`
+   */
+  findExistingUsing: IndexerClient | AppLookup;
+};
+/** Configuration to resolve app by creator and name `getCreatorAppsByName` */
+type ResolveAppByCreatorAndName = ResolveAppByCreatorAndNameBase & {
+  /** How the app ID is resolved, either by `'id'` or `'creatorAndName'`; must be `'creatorAndName'` if you want to use `deploy` */resolveBy: 'creatorAndName';
+};
+/** Configuration to resolve app by ID */
+interface ResolveAppByIdBase {
+  /** The id of an existing app to call using this client, or 0 if the app hasn't been created yet */
+  id: number | bigint;
+  /** The optional name to use to mark the app when deploying `ApplicationClient.deploy` (default: uses the name in the ABI contract) */
+  name?: string;
+}
+interface ResolveAppById extends ResolveAppByIdBase {
+  /** How the app ID is resolved, either by `'id'` or `'creatorAndName'`; must be `'creatorAndName'` if you want to use `deploy` */
+  resolveBy: 'id';
+}
+/** The details of an AlgoKit Utils deployed app */
+type AppDetailsBase = {
+  /** Default sender to use for transactions issued by this application client */sender?: SendTransactionFrom; /** Default suggested params object to use */
+  params?: SuggestedParams;
+  /** Optionally provide any deploy-time parameters to replace in the TEAL code; if specified here will get
+   * used in calls to `deploy`, `create` and `update` unless overridden in those calls
+   */
+  deployTimeParams?: TealTemplateParams;
+};
+/** The details of an AlgoKit Utils deployed app */
+type AppDetails = AppDetailsBase & (ResolveAppById | ResolveAppByCreatorAndName);
+/** The details of an ARC-0032 app spec specified, AlgoKit Utils deployed app */
+type AppSpecAppDetailsBase = {
+  /** The ARC-0032 application spec as either:
+   *  * Parsed JSON `AppSpec`
+   *  * Raw JSON string
+   */
+  app: AppSpec | string;
+};
+/** The details of an ARC-0032 app spec specified, AlgoKit Utils deployed app by id*/
+type AppSpecAppDetailsById = AppSpecAppDetailsBase & AppDetailsBase & ResolveAppByIdBase;
+/** The details of an ARC-0032 app spec specified, AlgoKit Utils deployed app by creator and name*/
+type AppSpecAppDetailsByCreatorAndName = AppSpecAppDetailsBase & AppDetailsBase & ResolveAppByCreatorAndNameBase;
+/** The details of an ARC-0032 app spec specified, AlgoKit Utils deployed app */
+type AppSpecAppDetails = AppSpecAppDetailsBase & AppDetails;
+/** Core parameters to pass into ApplicationClient.deploy */
+interface AppClientDeployCoreParams {
+  /** The version of the contract, uses "1.0" by default */
+  version?: string;
+  /** The optional sender to send the transaction from, will use the application client's default sender by default if specified */
+  sender?: SendTransactionFrom;
+  /** Parameters to control transaction sending */
+  sendParams?: Omit<SendTransactionParams, 'skipSending' | 'skipWaiting'>;
+  /** Whether or not to allow updates in the contract using the deploy-time updatability control if present in your contract.
+   * If this is not specified then it will automatically be determined based on the AppSpec definition
+   **/
+  allowUpdate?: boolean;
+  /** Whether or not to allow deletes in the contract using the deploy-time deletability control if present in your contract.
+   * If this is not specified then it will automatically be determined based on the AppSpec definition
+   **/
+  allowDelete?: boolean;
+  /** What action to perform if a schema break is detected */
+  onSchemaBreak?: 'replace' | 'fail' | 'append' | OnSchemaBreak;
+  /** What action to perform if a TEAL update is detected */
+  onUpdate?: 'update' | 'replace' | 'append' | 'fail' | OnUpdate;
+}
+/** Call interface parameters to pass into ApplicationClient.deploy */
+interface AppClientDeployCallInterfaceParams {
+  /** Any deploy-time parameters to replace in the TEAL code */
+  deployTimeParams?: TealTemplateParams;
+  /** Any args to pass to any create transaction that is issued as part of deployment */
+  createArgs?: AppClientCallArgs;
+  /** Override the on-completion action for the create call; defaults to NoOp */
+  createOnCompleteAction?: Exclude<OnApplicationComplete, OnApplicationComplete.ClearState>;
+  /** Any args to pass to any update transaction that is issued as part of deployment */
+  updateArgs?: AppClientCallArgs;
+  /** Any args to pass to any delete transaction that is issued as part of deployment */
+  deleteArgs?: AppClientCallArgs;
+}
+/** Parameters to pass into ApplicationClient.deploy */
+interface AppClientDeployParams extends AppClientDeployCoreParams, AppClientDeployCallInterfaceParams {
+  /** Any overrides for the storage schema to request for the created app; by default the schema indicated by the app spec is used. */
+  schema?: Partial<AppStorageSchema>;
+}
+type AppClientCallRawArgs = RawAppCallArgs;
+interface AppClientCallABIArgs extends Omit<ABIAppCallArgs, 'method'> {
+  /** If calling an ABI method then either the name of the method, or the ABI signature */
+  method: string;
+}
+/** The arguments to pass to an Application Client smart contract call */
+type AppClientCallArgs = AppClientCallRawArgs | AppClientCallABIArgs;
+/** Common (core) parameters to construct a ApplicationClient contract call */
+interface AppClientCallCoreParams {
+  /** The optional sender to send the transaction from, will use the application client's default sender by default if specified */
+  sender?: SendTransactionFrom;
+  /** The transaction note for the smart contract call */
+  note?: TransactionNote;
+  /** Parameters to control transaction sending */
+  sendParams?: SendTransactionParams;
+}
+/** Parameters to construct a ApplicationClient contract call */
+type AppClientCallParams = AppClientCallArgs & AppClientCallCoreParams;
+/** Parameters to construct a ApplicationClient clear state contract call */
+type AppClientClearStateParams = AppClientCallRawArgs & AppClientCallCoreParams;
+interface AppClientCompilationParams {
+  /** Any deploy-time parameters to replace in the TEAL code */
+  deployTimeParams?: TealTemplateParams;
+  /** Whether or not the contract should have deploy-time immutability control set, undefined = ignore */
+  updatable?: boolean;
+  /** Whether or not the contract should have deploy-time permanence control set, undefined = ignore */
+  deletable?: boolean;
+}
+/** On-complete action parameter for creating a contract using ApplicationClient */
+type AppClientCreateOnComplete = {
+  /** Override the on-completion action for the create call; defaults to NoOp */onCompleteAction?: Exclude<OnApplicationComplete, OnApplicationComplete.ClearState>;
+};
+/** Parameters for creating a contract using ApplicationClient */
+type AppClientCreateParams = AppClientCallParams & AppClientCompilationParams & AppClientCreateOnComplete & {
+  /** Any overrides for the storage schema to request for the created app; by default the schema indicated by the app spec is used. */schema?: Partial<AppStorageSchema>;
+};
+/** Parameters for updating a contract using ApplicationClient */
+type AppClientUpdateParams = AppClientCallParams & AppClientCompilationParams;
+/** Parameters for funding an app account */
+interface FundAppAccountParams {
+  amount: AlgoAmount;
+  /** The optional sender to send the transaction from, will use the application client's default sender by default if specified */
+  sender?: SendTransactionFrom;
+  /** The transaction note for the smart contract call */
+  note?: TransactionNote;
+  /** Parameters to control transaction sending */
+  sendParams?: SendTransactionParams;
+}
+/** Source maps for an Algorand app */
+interface AppSourceMaps {
+  /** The source map of the approval program */
+  approvalSourceMap: SourceMapExport;
+  /** The source map of the clear program */
+  clearSourceMap: SourceMapExport;
+}
+interface SourceMapExport {
+  version: number;
+  sources: string[];
+  names: string[];
+  mappings: string;
+}
+/**
+ * The result of asking an `AppClient` to compile a program.
+ *
+ * Always contains the compiled bytecode, and may contain the result of compiling TEAL (including sourcemap) if it was available.
+ */
+interface AppClientCompilationResult extends Partial<AppCompilationResult> {
+  /** The compiled bytecode of the approval program, ready to deploy to algod */
+  approvalProgram: Uint8Array;
+  /** The compiled bytecode of the clear state program, ready to deploy to algod */
+  clearStateProgram: Uint8Array;
+}
+/** Parameters to create an app client */
+interface AppClientParams {
+  /** The ID of the app instance this client should make calls against. */
+  appId: bigint;
+  /** The ARC-56 or ARC-32 application spec as either:
+   *  * Parsed JSON ARC-56 `Contract`
+   *  * Parsed JSON ARC-32 `AppSpec`
+   *  * Raw JSON string (in either ARC-56 or ARC-32 format)
+   */
+  appSpec: Arc56Contract | AppSpec | string;
+  /** An `AlgorandClient` instance */
+  algorand: AlgorandClient;
+  /**
+   * Optional override for the app name; used for on-chain metadata and lookups.
+   * Defaults to the ARC-32/ARC-56 app spec name
+   */
+  appName?: string;
+  /** Optional address to use for the account to use as the default sender for calls. */
+  defaultSender?: ReadableAddress;
+  /** Optional signer to use as the default signer for default sender calls (if not specified then the signer will be resolved from `AlgorandClient`). */
+  defaultSigner?: TransactionSigner;
+  /** Optional source map for the approval program */
+  approvalSourceMap?: ProgramSourceMap;
+  /** Optional source map for the clear state program */
+  clearSourceMap?: ProgramSourceMap;
+}
+/** Parameters to clone an app client */
+type CloneAppClientParams = Expand<Partial<Omit<AppClientParams, 'algorand' | 'appSpec'>>>;
+/** onComplete parameter for a non-update app call */
+type CallOnComplete = {
+  /** On-complete of the call; defaults to no-op */onComplete?: Exclude<OnApplicationComplete, OnApplicationComplete.UpdateApplication>;
+};
+/** AppClient common parameters for a bare app call */
+type AppClientBareCallParams = Expand<Omit<CommonAppCallParams, 'appId' | 'sender' | 'onComplete'> & {
+  /** The address of the account sending the transaction, if undefined then the app client's defaultSender is used. */sender?: ReadableAddress;
+}>;
+/** AppClient common parameters for an ABI method call */
+type AppClientMethodCallParams = Expand<Omit<CommonAppCallParams, 'appId' | 'sender' | 'method' | 'args'> & {
+  /** The address of the account sending the transaction, if undefined then the app client's defaultSender is used. */sender?: ReadableAddress;
+  /** The method name or method signature to call if an ABI call is being emitted
+   * @example Method name
+   * `my_method`
+   * @example Method signature
+   * `my_method(unit64,string)bytes`
+   */
+  method: string;
+  /** Arguments to the ABI method, either:
+   * * An ABI value
+   * * An ARC-56 struct
+   * * A transaction with explicit signer
+   * * A transaction (where the signer will be automatically assigned)
+   * * An unawaited transaction (e.g. from algorand.createTransaction.transactionType())
+   * * Another method call (via method call params object)
+   * * undefined (this represents a placeholder for either a default argument or a transaction argument that is fulfilled by another method call argument)
+   */
+  args?: (ABIValue | AppMethodCallTransactionArgument | undefined)[];
+}>;
+/** Parameters for funding an app account */
+type FundAppParams = Expand<Omit<PaymentParams, 'receiver' | 'sender'> & SendParams & {
+  /** The optional sender to send the transaction from, will use the application client's default sender by default if specified */sender?: ReadableAddress;
+}>;
+/** Resolve an app client instance by looking up an app created by the given creator with the given name */
+type ResolveAppClientByCreatorAndName = Expand<Omit<AppClientParams, 'appId'> & {
+  /** The address of the creator account for the app */creatorAddress: ReadableAddress;
+  /** An optional cached app lookup that matches a name to on-chain details;
+   * either this is needed or indexer is required to be passed in to this `ClientManager` on construction.
+   */
+  appLookupCache?: AppLookup$1; /** Whether or not to ignore the `AppDeployer` lookup cache and force an on-chain lookup, default: use any cached value */
+  ignoreCache?: boolean;
+}>;
+/** Resolve an app client instance by looking up the current network. */
+type ResolveAppClientByNetwork = Expand<Omit<AppClientParams, 'appId'>>;
+/**
+ * ARC-56/ARC-32 application client that allows you to manage calls and
+ * state for a specific deployed instance of an app (with a known app ID).
+ * @see {@link AppFactory} for creating and deploying apps
+ */
+declare class AppClient {
+  private _appId;
+  private _appAddress;
+  private _appName;
+  private _appSpec;
+  private _algorand;
+  private _defaultSender?;
+  private _defaultSigner?;
+  private _approvalSourceMap;
+  private _clearSourceMap;
+  private _localStateMethods;
+  private _globalStateMethods;
+  private _boxStateMethods;
+  private _paramsMethods;
+  private _createTransactionsMethods;
+  private _sendMethods;
+  private _lastCompiled;
+  /**
+   * Create a new app client.
+   * @param params The parameters to create the app client
+   * @returns The `AppClient` instance
+   * @example
+   * ```typescript
+   * const appClient = new AppClient({
+   *   appId: 12345678n,
+   *   appSpec: appSpec,
+   *   algorand: AlgorandClient.mainNet(),
+   * })
+   */
+  constructor(params: AppClientParams);
+  /**
+   * Clone this app client with different params
+   *
+   * @param params The params to use for the the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value.
+   * @returns A new app client with the altered params
+   * @example
+   * ```typescript
+   * const appClient2 = appClient.clone({ defaultSender: 'NEW_SENDER_ADDRESS' })
+   * ```
+   */
+  clone(params: CloneAppClientParams): AppClient;
+  /**
+   * Returns a new `AppClient` client, resolving the app by creator address and name
+   * using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note).
+   * @param params The parameters to create the app client
+   * @returns The `AppClient` instance
+   * @example
+   * ```typescript
+   * const appClient = await AppClient.fromCreatorAndName({
+   *   creatorAddress: 'CREATOR_ADDRESS',
+   *   name: 'APP_NAME',
+   *   appSpec: appSpec,
+   *   algorand: AlgorandClient.mainNet(),
+   * })
+   */
+  static fromCreatorAndName(params: ResolveAppClientByCreatorAndName): Promise<AppClient>;
+  /**
+   * Returns an `AppClient` instance for the current network based on
+   * pre-determined network-specific app IDs specified in the ARC-56 app spec.
+   *
+   * If no IDs are in the app spec or the network isn't recognised, an error is thrown.
+   * @param params The parameters to create the app client
+   * @returns The `AppClient` instance
+   * @example
+   * ```typescript
+   * const appClient = await AppClient.fromNetwork({
+   *   appSpec: appSpec,
+   *   algorand: AlgorandClient.mainNet(),
+   * })
+   */
+  static fromNetwork(params: ResolveAppClientByNetwork): Promise<AppClient>;
+  /**
+   * Takes a string or parsed JSON object that could be ARC-32 or ARC-56 format and
+   * normalises it into a parsed ARC-56 contract object.
+   * @param spec The spec to normalise
+   * @returns The normalised ARC-56 contract object
+   * @example
+   * ```typescript
+   * const arc56AppSpec = AppClient.normaliseAppSpec(appSpec)
+   * ```
+   */
+  static normaliseAppSpec(spec: Arc56Contract | AppSpec | string): Arc56Contract;
+  /** The ID of the app instance this client is linked to. */
+  get appId(): bigint;
+  /** The app address of the app instance this client is linked to. */
+  get appAddress(): Address;
+  /** The name of the app (from the ARC-32 / ARC-56 app spec or override). */
+  get appName(): string;
+  /** The ARC-56 app spec being used */
+  get appSpec(): Arc56Contract;
+  /** A reference to the underlying `AlgorandClient` this app client is using. */
+  get algorand(): AlgorandClient;
+  /** Get parameters to create transactions for the current app.
+   *
+   * A good mental model for this is that these parameters represent a deferred transaction creation.
+   * @example Create a transaction in the future using Algorand Client
+   * ```typescript
+   * const myMethodCall = appClient.params.call({method: 'my_method', args: [123, 'hello']})
+   * // ...
+   * await algorand.send.AppMethodCall(myMethodCall)
+   * ```
+   * @example Define a nested transaction as an ABI argument
+   * ```typescript
+   * const myMethodCall = appClient.params.call({method: 'my_method', args: [123, 'hello']})
+   * await appClient.send.call({method: 'my_method2', args: [myMethodCall]})
+   * ```
+   */
+  get params(): {
+    /**
+     * Return params for a payment transaction to fund the app account
+     * @param params The parameters for the fund app accont payment transaction
+     * @returns The parameters which can be used to create a fund app account payment transaction
+     */
+    fundAppAccount: (params: FundAppParams) => {
+      sender: Address;
+      signer: AddressWithTransactionSigner | TransactionSigner | undefined;
+      receiver: Address;
+      rekeyTo?: ReadableAddress | undefined;
+      note?: (Uint8Array | string) | undefined;
+      lease?: (Uint8Array | string) | undefined;
+      staticFee?: AlgoAmount | undefined;
+      extraFee?: AlgoAmount | undefined;
+      maxFee?: AlgoAmount | undefined;
+      validityWindow?: number | bigint | undefined;
+      firstValidRound?: bigint | undefined;
+      lastValidRound?: bigint | undefined;
+      amount: AlgoAmount;
+      closeRemainderTo?: ReadableAddress | undefined;
+      maxRoundsToWaitForConfirmation?: number | undefined;
+      suppressLog?: boolean | undefined;
+      populateAppCallResources?: boolean | undefined;
+      coverAppCallInnerTransactionFees?: boolean | undefined;
+    };
+    /**
+     * Return params for an update ABI call, including deploy-time TEAL template replacements and compilation if provided
+     * @param params The parameters for the update ABI method call
+     * @returns The parameters which can be used to create an update ABI method call
+     */
+    update: (params: AppClientMethodCallParams & AppClientCompilationParams) => Promise<{
+      /** The compiled bytecode of the approval program, ready to deploy to algod */approvalProgram: Uint8Array; /** The compiled bytecode of the clear state program, ready to deploy to algod */
+      clearStateProgram: Uint8Array;
+      compiledApproval?: CompiledTeal | undefined;
+      compiledClear?: CompiledTeal | undefined;
+      signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
+      rekeyTo?: ReadableAddress | undefined;
+      note?: (Uint8Array | string) | undefined;
+      lease?: (Uint8Array | string) | undefined;
+      staticFee?: AlgoAmount | undefined;
+      extraFee?: AlgoAmount | undefined;
+      maxFee?: AlgoAmount | undefined;
+      validityWindow?: number | bigint | undefined;
+      firstValidRound?: bigint | undefined;
+      lastValidRound?: bigint | undefined;
+      onComplete?: OnApplicationComplete | undefined;
+      accountReferences?: ReadableAddress[] | undefined;
+      appReferences?: bigint[] | undefined;
+      assetReferences?: bigint[] | undefined;
+      boxReferences?: (BoxReference | BoxIdentifier)[];
+      accessReferences?: ResourceReference[] | undefined;
+      rejectVersion?: number | undefined;
+      sender?: ReadableAddress
+      /** The method name or method signature to call if an ABI call is being emitted
+       * @example Method name
+       * `my_method`
+       * @example Method signature
+       * `my_method(unit64,string)bytes`
+       */
+      | undefined;
+      method: string;
+      args?: (ABIValue | AppMethodCallTransactionArgument | undefined)[]; /** Any deploy-time parameters to replace in the TEAL code */
+      deployTimeParams?: TealTemplateParams; /** Whether or not the contract should have deploy-time immutability control set, undefined = ignore */
+      updatable?: boolean; /** Whether or not the contract should have deploy-time permanence control set, undefined = ignore */
+      deletable?: boolean;
+    } & {
+      appId: bigint;
+      sender: Address;
+      signer: AddressWithTransactionSigner | TransactionSigner | undefined;
+      method: ABIMethod;
+      onComplete: OnApplicationComplete.UpdateApplication;
+      args: (Transaction | Promise<Transaction> | ABIValue | TransactionWithSigner | AppMethodCall<{
+        signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
+        sender: SendingAddress;
+        rekeyTo?: ReadableAddress | undefined;
+        note?: (Uint8Array | string) | undefined;
+        lease?: (Uint8Array | string) | undefined;
+        staticFee?: AlgoAmount | undefined;
+        extraFee?: AlgoAmount | undefined;
+        maxFee?: AlgoAmount | undefined;
+        validityWindow?: number | bigint | undefined;
+        firstValidRound?: bigint | undefined;
+        lastValidRound?: bigint | undefined;
+        onComplete?: OnApplicationComplete.NoOp | OnApplicationComplete.OptIn | OnApplicationComplete.CloseOut | OnApplicationComplete.UpdateApplication | OnApplicationComplete.DeleteApplication | undefined;
+        args?: Uint8Array[] | undefined;
+        accountReferences?: ReadableAddress[] | undefined;
+        appReferences?: bigint[] | undefined;
+        assetReferences?: bigint[] | undefined;
+        boxReferences?: (BoxReference | BoxIdentifier)[] | undefined;
+        accessReferences?: ResourceReference[] | undefined;
+        rejectVersion?: number | undefined;
+        appId?: 0 | undefined;
+        approvalProgram: string | Uint8Array;
+        clearStateProgram: string | Uint8Array;
+        schema?: {
+          globalInts: number;
+          globalByteSlices: number;
+          localInts: number;
+          localByteSlices: number;
+        } | undefined;
+        extraProgramPages?: number | undefined;
+      }> | AppMethodCall<{
+        sender: SendingAddress;
+        signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
+        rekeyTo?: ReadableAddress | undefined;
+        note?: (Uint8Array | string) | undefined;
+        lease?: (Uint8Array | string) | undefined;
+        staticFee?: AlgoAmount | undefined;
+        extraFee?: AlgoAmount | undefined;
+        maxFee?: AlgoAmount | undefined;
+        validityWindow?: number | bigint | undefined;
+        firstValidRound?: bigint | undefined;
+        lastValidRound?: bigint | undefined;
+        appId: bigint;
+        onComplete?: OnApplicationComplete.UpdateApplication | undefined;
+        args?: Uint8Array[] | undefined;
+        accountReferences?: ReadableAddress[] | undefined;
+        appReferences?: bigint[] | undefined;
+        assetReferences?: bigint[] | undefined;
+        boxReferences?: (BoxReference | BoxIdentifier)[] | undefined;
+        accessReferences?: ResourceReference[] | undefined;
+        rejectVersion?: number | undefined;
+        approvalProgram: string | Uint8Array;
+        clearStateProgram: string | Uint8Array;
+      }> | AppMethodCall<AppMethodCallParams> | undefined)[] | undefined;
+    }>;
+    /**
+     * Return params for an opt-in ABI call
+     * @param params The parameters for the opt-in ABI method call
+     * @returns The parameters which can be used to create an opt-in ABI method call
+     */
+    optIn: (params: AppClientMethodCallParams) => Promise<{
+      signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
+      appId: bigint;
+      sender: SendingAddress;
+      rekeyTo?: ReadableAddress | undefined;
+      note?: (Uint8Array | string) | undefined;
+      lease?: (Uint8Array | string) | undefined;
+      staticFee?: AlgoAmount | undefined;
+      extraFee?: AlgoAmount | undefined;
+      maxFee?: AlgoAmount | undefined;
+      validityWindow?: number | bigint | undefined;
+      firstValidRound?: bigint | undefined;
+      lastValidRound?: bigint | undefined;
+      onComplete?: OnApplicationComplete.NoOp | OnApplicationComplete.OptIn | OnApplicationComplete.CloseOut | OnApplicationComplete.DeleteApplication | undefined;
+      accountReferences?: ReadableAddress[] | undefined;
+      appReferences?: bigint[] | undefined;
+      assetReferences?: bigint[] | undefined;
+      boxReferences?: (BoxReference | BoxIdentifier)[] | undefined;
+      accessReferences?: ResourceReference[] | undefined;
+      rejectVersion?: number | undefined;
+      method: ABIMethod;
+      args?: (ABIValue | TransactionWithSigner | Transaction | Promise<Transaction> | AppMethodCall<AppCreateParams> | AppMethodCall<AppUpdateParams> | AppMethodCall<AppMethodCallParams> | undefined)[] | undefined;
+    }>;
+    /**
+     * Return params for an delete ABI call
+     * @param params The parameters for the delete ABI method call
+     * @returns The parameters which can be used to create a delete ABI method call
+     */
+    delete: (params: AppClientMethodCallParams) => Promise<{
+      signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
+      appId: bigint;
+      sender: SendingAddress;
+      rekeyTo?: ReadableAddress | undefined;
+      note?: (Uint8Array | string) | undefined;
+      lease?: (Uint8Array | string) | undefined;
+      staticFee?: AlgoAmount | undefined;
+      extraFee?: AlgoAmount | undefined;
+      maxFee?: AlgoAmount | undefined;
+      validityWindow?: number | bigint | undefined;
+      firstValidRound?: bigint | undefined;
+      lastValidRound?: bigint | undefined;
+      onComplete?: OnApplicationComplete.DeleteApplication | undefined;
+      accountReferences?: ReadableAddress[] | undefined;
+      appReferences?: bigint[] | undefined;
+      assetReferences?: bigint[] | undefined;
+      boxReferences?: (BoxReference | BoxIdentifier)[] | undefined;
+      accessReferences?: ResourceReference[] | undefined;
+      rejectVersion?: number | undefined;
+      method: ABIMethod;
+      args?: (ABIValue | TransactionWithSigner | Transaction | Promise<Transaction> | AppMethodCall<AppCreateParams> | AppMethodCall<AppUpdateParams> | AppMethodCall<AppMethodCallParams> | undefined)[] | undefined;
+    }>;
+    /** Return params for an close out ABI call
+     * @param params The parameters for the close out ABI method call
+     * @returns The parameters which can be used to create a close out ABI method call
+     */
+    closeOut: (params: AppClientMethodCallParams) => Promise<{
+      signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
+      appId: bigint;
+      sender: SendingAddress;
+      rekeyTo?: ReadableAddress | undefined;
+      note?: (Uint8Array | string) | undefined;
+      lease?: (Uint8Array | string) | undefined;
+      staticFee?: AlgoAmount | undefined;
+      extraFee?: AlgoAmount | undefined;
+      maxFee?: AlgoAmount | undefined;
+      validityWindow?: number | bigint | undefined;
+      firstValidRound?: bigint | undefined;
+      lastValidRound?: bigint | undefined;
+      onComplete?: OnApplicationComplete.NoOp | OnApplicationComplete.OptIn | OnApplicationComplete.CloseOut | OnApplicationComplete.DeleteApplication | undefined;
+      accountReferences?: ReadableAddress[] | undefined;
+      appReferences?: bigint[] | undefined;
+      assetReferences?: bigint[] | undefined;
+      boxReferences?: (BoxReference | BoxIdentifier)[] | undefined;
+      accessReferences?: ResourceReference[] | undefined;
+      rejectVersion?: number | undefined;
+      method: ABIMethod;
+      args?: (ABIValue | TransactionWithSigner | Transaction | Promise<Transaction> | AppMethodCall<AppCreateParams> | AppMethodCall<AppUpdateParams> | AppMethodCall<AppMethodCallParams> | undefined)[] | undefined;
+    }>;
+    /** Return params for an ABI call
+     * @param params The parameters for the ABI method call
+     * @returns The parameters which can be used to create an ABI method call
+     */
+    call: (params: AppClientMethodCallParams & CallOnComplete) => Promise<{
+      signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
+      appId: bigint;
+      sender: SendingAddress;
+      rekeyTo?: ReadableAddress | undefined;
+      note?: (Uint8Array | string) | undefined;
+      lease?: (Uint8Array | string) | undefined;
+      staticFee?: AlgoAmount | undefined;
+      extraFee?: AlgoAmount | undefined;
+      maxFee?: AlgoAmount | undefined;
+      validityWindow?: number | bigint | undefined;
+      firstValidRound?: bigint | undefined;
+      lastValidRound?: bigint | undefined;
+      onComplete?: OnApplicationComplete.NoOp | OnApplicationComplete.OptIn | OnApplicationComplete.CloseOut | OnApplicationComplete.DeleteApplication | undefined;
+      accountReferences?: ReadableAddress[] | undefined;
+      appReferences?: bigint[] | undefined;
+      assetReferences?: bigint[] | undefined;
+      boxReferences?: (BoxReference | BoxIdentifier)[] | undefined;
+      accessReferences?: ResourceReference[] | undefined;
+      rejectVersion?: number | undefined;
+      method: ABIMethod;
+      args?: (ABIValue | TransactionWithSigner | Transaction | Promise<Transaction> | AppMethodCall<AppCreateParams> | AppMethodCall<AppUpdateParams> | AppMethodCall<AppMethodCallParams> | undefined)[] | undefined;
+    }>;
+  } & {
+    /** Interact with bare (raw) call parameters */bare: ReturnType<AppClient["getBareParamsMethods"]>;
+  };
+  /** Create transactions for the current app */
+  get createTransaction(): {
+    /** Return transaction for a payment transaction to fund the app account
+     * @param params The parameters for the fund app account payment transaction
+     * @returns A transaction which can be used to fund the app account
+     */
+    fundAppAccount: (params: FundAppParams) => Promise<Transaction>;
+    /**
+     * Return transactions for an update ABI call, including deploy-time TEAL template replacements and compilation if provided
+     * @param params The parameters for the update ABI method call
+     * @returns The transactions which can be used to create an update ABI method call
+     */
+    update: (params: AppClientMethodCallParams & AppClientCompilationParams) => Promise<{
+      transactions: Transaction[];
+      methodCalls: Map<number, ABIMethod>;
+      signers: Map<number, TransactionSigner>;
+    }>;
+    /**
+     * Return transactions for an opt-in ABI call
+     * @param params The parameters for the opt-in ABI method call
+     * @returns The transactions which can be used to create an opt-in ABI method call
+     */
+    optIn: (params: AppClientMethodCallParams) => Promise<{
+      transactions: Transaction[];
+      methodCalls: Map<number, ABIMethod>;
+      signers: Map<number, TransactionSigner>;
+    }>;
+    /**
+     * Return transactions for a delete ABI call
+     * @param params The parameters for the delete ABI method call
+     * @returns The transactions which can be used to create a delete ABI method call
+     */
+    delete: (params: AppClientMethodCallParams) => Promise<{
+      transactions: Transaction[];
+      methodCalls: Map<number, ABIMethod>;
+      signers: Map<number, TransactionSigner>;
+    }>;
+    /**
+     * Return transactions for a close out ABI call
+     * @param params The parameters for the close out ABI method call
+     * @returns The transactions which can be used to create a close out ABI method call
+     */
+    closeOut: (params: AppClientMethodCallParams) => Promise<{
+      transactions: Transaction[];
+      methodCalls: Map<number, ABIMethod>;
+      signers: Map<number, TransactionSigner>;
+    }>;
+    /**
+     * Return transactions for an ABI call (defaults to no-op)
+     * @param params The parameters for the ABI method call
+     * @returns The transactions which can be used to create an ABI method call
+     */
+    call: (params: AppClientMethodCallParams & CallOnComplete) => Promise<{
+      transactions: Transaction[];
+      methodCalls: Map<number, ABIMethod>;
+      signers: Map<number, TransactionSigner>;
+    }>;
+  } & {
+    /** Interact with bare (raw) call transactions */bare: ReturnType<AppClient["getBareCreateTransactionMethods"]>;
+  };
+  /** Send transactions to the current app */
+  get send(): {
+    /** Sign and send transactions for a payment transaction to fund the app account
+     * @param params The parameters for the fund app account payment transaction
+     * @returns The result of send the fund app account payment transaction
+     */
+    fundAppAccount: (params: FundAppParams & SendParams) => Promise<{
+      groupId: string | undefined;
+      txIds: string[];
+      returns?: ABIReturn[] | undefined;
+      confirmations: PendingTransactionResponse[];
+      transactions: Transaction[];
+      confirmation: PendingTransactionResponse;
+      transaction: Transaction;
+    }>;
+    /**
+     * Sign and send transactions for an update ABI call, including deploy-time TEAL template replacements and compilation if provided
+     * @param params The parameters for the update ABI method call
+     * @returns The result of sending the update ABI method call
+     */
+    update: (params: AppClientMethodCallParams & AppClientCompilationParams & SendParams) => Promise<{
+      compiledApproval?: CompiledTeal | undefined;
+      compiledClear?: CompiledTeal | undefined;
+      confirmations: PendingTransactionResponse[];
+      transactions: Transaction[];
+      groupId: string | undefined;
+      txIds: string[];
+      returns?: ABIReturn[] | undefined;
+      confirmation: PendingTransactionResponse;
+      transaction: Transaction;
+      return?: ABIValue | undefined;
+    }>;
+    /**
+     * Sign and send transactions for an opt-in ABI call
+     * @param params The parameters for the opt-in ABI method call
+     * @returns The result of sending the opt-in ABI method call
+     */
+    optIn: (params: AppClientMethodCallParams & SendParams) => Promise<Omit<{
+      groupId: string | undefined;
+      txIds: string[];
+      returns?: ABIReturn[] | undefined;
+      confirmations: PendingTransactionResponse[];
+      transactions: Transaction[];
+      confirmation: PendingTransactionResponse;
+      transaction: Transaction;
+      return?: ABIReturn | undefined;
+    }, "return"> & AppReturn<ABIValue | undefined>>;
+    /**
+     * Sign and send transactions for a delete ABI call
+     * @param params The parameters for the delete ABI method call
+     * @returns The result of sending the delete ABI method call
+     */
+    delete: (params: AppClientMethodCallParams & SendParams) => Promise<Omit<{
+      groupId: string | undefined;
+      txIds: string[];
+      returns?: ABIReturn[] | undefined;
+      confirmations: PendingTransactionResponse[];
+      transactions: Transaction[];
+      confirmation: PendingTransactionResponse;
+      transaction: Transaction;
+      return?: ABIReturn | undefined;
+    }, "return"> & AppReturn<ABIValue | undefined>>;
+    /**
+     * Sign and send transactions for a close out ABI call
+     * @param params The parameters for the close out ABI method call
+     * @returns The result of sending the close out ABI method call
+     */
+    closeOut: (params: AppClientMethodCallParams & SendParams) => Promise<Omit<{
+      groupId: string | undefined;
+      txIds: string[];
+      returns?: ABIReturn[] | undefined;
+      confirmations: PendingTransactionResponse[];
+      transactions: Transaction[];
+      confirmation: PendingTransactionResponse;
+      transaction: Transaction;
+      return?: ABIReturn | undefined;
+    }, "return"> & AppReturn<ABIValue | undefined>>;
+    /**
+     * Sign and send transactions for a call (defaults to no-op)
+     * @param params The parameters for the ABI method call
+     * @returns The result of sending the ABI method call
+     */
+    call: (params: AppClientMethodCallParams & CallOnComplete & SendParams) => Promise<Omit<{
+      groupId: string | undefined;
+      txIds: string[];
+      returns?: ABIReturn[] | undefined;
+      confirmations: PendingTransactionResponse[];
+      transactions: Transaction[];
+      confirmation: PendingTransactionResponse;
+      transaction: Transaction;
+      return?: ABIReturn | undefined;
+    }, "return"> & AppReturn<ABIValue | undefined>>;
+  } & {
+    /** Interact with bare (raw) calls */bare: ReturnType<AppClient["getBareSendMethods"]>;
+  };
+  /** Get state (local, global, box) from the current app */
+  get state(): {
+    /**
+     * Methods to access local state for the current app
+     * @param address The address of the account to get the local state for
+     */
+    local: (address: ReadableAddress) => ReturnType<AppClient["getStateMethods"]>;
+    /**
+     * Methods to access global state for the current app
+     */
+    global: {
+      /**
+       * Returns all single-key state values in a record keyed by the key name and the value a decoded ABI value.
+       */
+      getAll: () => Promise<Record<string, any>>;
+      /**
+       * Returns a single state value for the current app with the value a decoded ABI value.
+       * @param name The name of the state value to retrieve the value for
+       * @param appState Optional cached value of the current state
+       * @returns
+       */
+      getValue: (name: string, appState?: AppState) => Promise<ABIValue | undefined>;
+      /**
+       * Returns a single value from the given map for the current app with the value a decoded ABI value.
+       * @param mapName The name of the map to read from
+       * @param key The key within the map (without any map prefix) as either a Buffer with the bytes or a value
+       *  that will be converted to bytes by encoding it using the specified ABI key type
+       *  in the ARC-56 spec
+       * @param appState Optional cached value of the current state
+       */
+      getMapValue: (mapName: string, key: Uint8Array | any, appState?: AppState) => Promise<ABIValue | undefined>;
+      /**
+       * Returns all map values for the given map.
+       * @param mapName The name of the map to read from
+       * @returns A map of all key-value pairs in the map as a `Record<string, ABIValue>`
+       */
+      getMap: (mapName: string) => Promise<Map<ABIValue, ABIValue>>;
+    };
+    /**
+     * Methods to access box storage for the current app
+     */
+    box: {
+      /**
+       * Returns all single-key state values in a record keyed by the key name and the value a decoded ABI value.
+       */
+      getAll: () => Promise<Record<string, any>>;
+      /**
+       * Returns a single state value for the current app with the value a decoded ABI value.
+       * @param name The name of the state value to retrieve the value for
+       * @returns
+       */
+      getValue: (name: string) => Promise<ABIValue>;
+      /**
+       *
+       * @param mapName The name of the map to read from
+       * @param key The key within the map (without any map prefix) as either a Buffer with the bytes or a value
+       *  that will be converted to bytes by encoding it using the specified ABI key type
+       *  in the ARC-56 spec
+       */
+      getMapValue: (mapName: string, key: Uint8Array | any) => Promise<ABIValue>;
+      /**
+       * Returns all map values for the given map from box storage.
+       * @param mapName The name of the map to read from
+       */
+      getMap: (mapName: string) => Promise<Map<ABIValue, ABIValue>>;
+    };
+  };
+  /**
+   * Funds Algo into the app account for this app.
+   *
+   * An alias for `appClient.send.fundAppAccount(params)`.
+   * @param params The parameters for the funding transaction
+   * @returns The result of the funding
+   * @example
+   * ```typescript
+   * await appClient.fundAppAccount({ amount: algo(1) })
+   * ```
+   */
+  fundAppAccount(params: FundAppParams): Promise<{
+    groupId: string | undefined;
+    txIds: string[];
+    returns?: ABIReturn[] | undefined;
+    confirmations: PendingTransactionResponse[];
+    transactions: Transaction[];
+    confirmation: PendingTransactionResponse;
+    transaction: Transaction;
+  }>;
+  /**
+   * Returns raw global state for the current app.
+   * @returns The global state
+   * @example
+   * ```typescript
+   * const globalState = await appClient.getGlobalState()
+   * ```
+   */
+  getGlobalState(): Promise<AppState>;
+  /**
+   * Returns raw local state for the given account address.
+   * @param address The address of the account to get the local state for
+   * @returns The local state
+   * @example
+   * ```typescript
+   * const localState = await appClient.getLocalState('ACCOUNT_ADDRESS')
+   * ```
+   */
+  getLocalState(address: ReadableAddress): Promise<AppState>;
+  /**
+   * Returns the names of all current boxes for the current app.
+   * @returns The names of the boxes
+   * @example
+   * ```typescript
+   * const boxNames = await appClient.getBoxNames()
+   * ```
+   */
+  getBoxNames(): Promise<BoxName[]>;
+  /**
+   * Returns the value of the given box for the current app.
+   * @param name The identifier of the box to return
+   * @returns The current box value as a byte array
+   * @example
+   * ```typescript
+   * const boxValue = await appClient.getBoxValue('boxName')
+   * ```
+   */
+  getBoxValue(name: BoxIdentifier): Promise<Uint8Array>;
+  /**
+   * Returns the value of the given box for the current app.
+   * @param name The identifier of the box to return
+   * @param type
+   * @returns The current box value as a byte array
+   * @example
+   * ```typescript
+   * const boxValue = await appClient.getBoxValueFromABIType('boxName', new ABIUintType(32))
+   * ```
+   */
+  getBoxValueFromABIType(name: BoxIdentifier, type: ABIType): Promise<ABIValue>;
+  /**
+   * Returns the values of all current boxes for the current app.
+   * Note: This will issue multiple HTTP requests (one per box) and it's not an atomic operation so values may be out of sync.
+   * @param filter Optional filter to filter which boxes' values are returned
+   * @returns The (name, value) pair of the boxes with values as raw byte arrays
+   * @example
+   * ```typescript
+   * const boxValues = await appClient.getBoxValues()
+   * ```
+   */
+  getBoxValues(filter?: (name: BoxName) => boolean): Promise<{
+    name: BoxName;
+    value: Uint8Array;
+  }[]>;
+  /**
+   * Returns the values of all current boxes for the current app decoded using an ABI Type.
+   * Note: This will issue multiple HTTP requests (one per box) and it's not an atomic operation so values may be out of sync.
+   * @param type The ABI type to decode the values with
+   * @param filter Optional filter to filter which boxes' values are returned
+   * @returns The (name, value) pair of the boxes with values as the ABI Value
+   * @example
+   * ```typescript
+   * const boxValues = await appClient.getBoxValuesFromABIType(new ABIUintType(32))
+   * ```
+   */
+  getBoxValuesFromABIType(type: ABIType, filter?: (name: BoxName) => boolean): Promise<{
+    name: BoxName;
+    value: ABIValue;
+  }[]>;
+  /**
+   * Takes an error that may include a logic error from a call to the current app and re-exposes the
+   * error to include source code information via the source map and ARC-56 spec.
+   * @param e The error to parse
+   * @param isClearStateProgram Whether or not the code was running the clear state program (defaults to approval program)
+   * @returns The new error, or if there was no logic error or source map then the wrapped error with source details
+   */
+  exposeLogicError(e: Error, isClearStateProgram?: boolean): Promise<Error>;
+  /**
+   * Export the current source maps for the app.
+   * @returns The source maps
+   */
+  exportSourceMaps(): AppSourceMaps;
+  /**
+   * Import source maps for the app.
+   * @param sourceMaps The source maps to import
+   */
+  importSourceMaps(sourceMaps: AppSourceMaps): void;
+  /**
+   * Returns the ABI Method spec for the given method string for the app represented by this application client instance
+   * @param methodNameOrSignature The method name or method signature to call if an ABI call is being emitted.
+   * e.g. `my_method` or `my_method(unit64,string)bytes`
+   * @returns A tuple with: [ARC-56 `Method`, algosdk `ABIMethod`]
+   */
+  getABIMethod(methodNameOrSignature: string): ABIMethod;
+  /**
+   * Checks for decode errors on the SendAppTransactionResult and maps the return value to the specified type
+   * on the ARC-56 method, replacing the `return` property with the decoded type.
+   *
+   * If the return type is an ARC-56 struct then the struct will be returned.
+   *
+   * @param result The SendAppTransactionResult to be mapped
+   * @returns The smart contract response with an updated return value
+   */
+  processMethodCallReturn<TReturn extends ABIValue | undefined, TResult extends SendAppTransactionResult = SendAppTransactionResult>(result: Promise<TResult> | TResult): Promise<Omit<TResult, 'return'> & AppReturn<TReturn>>;
+  /**
+   * Compiles the approval and clear state programs (if TEAL templates provided),
+   * performing any provided deploy-time parameter replacement and stores
+   * the source maps.
+   *
+   * If no TEAL templates provided it will use any byte code provided in the app spec.
+   *
+   * Will store any generated source maps for later use in debugging.
+   * @param compilation Any compilation parameters to use
+   * @returns The compiled code and any compilation results (including source maps)
+   */
+  compile(compilation?: AppClientCompilationParams): Promise<AppClientCompilationResult>;
+  /**
+   * Takes an error that may include a logic error from a call to the current app and re-exposes the
+   * error to include source code information via the source map and ARC-56 spec.
+   * @param e The error to parse
+   * @param appSpec The app spec for the app
+   * @param details Additional information to inform the error
+   * @returns The new error, or if there was no logic error or source map then the wrapped error with source details
+   */
+  static exposeLogicError(e: Error, appSpec: Arc56Contract, details: {
+    /** Whether or not the code was running the clear state program (defaults to approval program) */isClearStateProgram?: boolean; /** Approval program source map */
+    approvalSourceMap?: ProgramSourceMap; /** Clear state program source map */
+    clearSourceMap?: ProgramSourceMap; /** program bytes */
+    program?: Uint8Array; /** ARC56 approval source info */
+    approvalSourceInfo?: ProgramSourceInfo; /** ARC56 clear source info */
+    clearSourceInfo?: ProgramSourceInfo;
+  }): Error;
+  /**
+   * Compiles the approval and clear state programs (if TEAL templates provided),
+   * performing any provided deploy-time parameter replacement and returns
+   * the compiled code and any compilation results (including source maps).
+   *
+   * If no TEAL templates provided it will use any byte code provided in the app spec.
+   *
+   * Will store any generated source maps for later use in debugging.
+   * @param appSpec The app spec for the app
+   * @param appManager The app manager to use for compilation
+   * @param compilation Any compilation parameters to use
+   * @returns The compiled code and any compilation results (including source maps)
+   */
+  static compile(appSpec: Arc56Contract, appManager: AppManager, compilation?: AppClientCompilationParams): Promise<AppClientCompilationResult>;
+  /**
+   * Returns ABI method arguments ready for a method call params object with default values populated
+   * and structs replaced with tuples.
+   *
+   * It does this by replacing any `undefined` values with the equivalent default value from the given ARC-56 app spec.
+   * @param methodNameOrSignature The method name or method signature to call if an ABI call is being emitted.
+   * e.g. `my_method` or `my_method(unit64,string)bytes`
+   * @param args The arguments to the method with `undefined` for any that should be populated with a default value
+   */
+  private getABIArgsWithDefaultValues;
+  private getDefaultValueFromStorage;
+  private getBareParamsMethods;
+  private getBareCreateTransactionMethods;
+  private getBareSendMethods;
+  private getMethodCallParamsMethods;
+  private getMethodCallSendMethods;
+  private getMethodCallCreateTransactionMethods;
+  /** Returns the sender for a call, using the provided sender or using the `defaultSender`
+   * if none provided and throws an error if neither provided */
+  private getSender;
+  /** Returns the signer for a call, using the provided signer or the `defaultSigner`
+   * if no signer was provided and the sender resolves to the default sender, the call will use default signer
+   * or `undefined` otherwise (so the signer is resolved from `AlgorandClient`) */
+  private getSigner;
+  private getBareParams;
+  private getABIParams;
+  /** Make the given call and catch any errors, augmenting with debugging information before re-throwing. */
+  private handleCallErrors;
+  private getBoxMethods;
+  private getStateMethods;
+}
+//#endregion
+export { AppClient, AppClientBareCallParams, AppClientCallABIArgs, AppClientCallArgs, AppClientCallCoreParams, AppClientCallParams, AppClientCallRawArgs, AppClientClearStateParams, AppClientCompilationParams, AppClientCompilationResult, AppClientCreateOnComplete, AppClientCreateParams, AppClientDeployCallInterfaceParams, AppClientDeployCoreParams, AppClientDeployParams, AppClientMethodCallParams, AppClientParams, AppClientUpdateParams, AppDetails, AppDetailsBase, AppSourceMaps, AppSpecAppDetails, AppSpecAppDetailsBase, AppSpecAppDetailsByCreatorAndName, AppSpecAppDetailsById, CallOnComplete, CloneAppClientParams, FundAppAccountParams, FundAppParams, ResolveAppByCreatorAndName, ResolveAppByCreatorAndNameBase, ResolveAppById, ResolveAppByIdBase, ResolveAppClientByCreatorAndName, ResolveAppClientByNetwork, SourceMapExport };
+//# sourceMappingURL=app-client.d.ts.map