@algorandfoundation/algokit-utils 8.2.0-beta.1 → 8.2.0-beta.3

package/types/composer.d.ts

@@ -469,6 +469,7 @@ export declare class TransactionComposer {
     /**
      * Create a `TransactionComposer`.
      * @param params The configuration for this composer
+     * @returns The `TransactionComposer` instance
      */
     constructor(params: TransactionComposerParams);
     /**
@@ -476,54 +477,258 @@ export declare class TransactionComposer {
      * @param transaction The pre-built transaction
      * @param signer Optional signer override for the transaction
      * @returns The composer so you can chain method calls
+     * @example
+     * ```typescript
+     * composer.addTransaction(txn)
+     * ```
      */
     addTransaction(transaction: Transaction, signer?: TransactionSigner): TransactionComposer;
     /**
      * Add a payment transaction to the transaction group.
      * @param params The payment transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example
+     * ```typescript
+     * composer.addPayment({
+     *   sender: 'SENDERADDRESS',
+     *   receiver: 'RECEIVERADDRESS',
+     *   amount: (4).algo(),
+     * })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * composer.addPayment({
+     *   amount: (4).algo(),
+     *   receiver: 'RECEIVERADDRESS',
+     *   sender: 'SENDERADDRESS',
+     *   closeRemainderTo: 'CLOSEREMAINDERTOADDRESS',
+     *   lease: 'lease',
+     *   note: 'note',
+     *   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
+     *   rekeyTo: 'REKEYTOADDRESS',
+     *   // You wouldn't normally set this field
+     *   firstValidRound: 1000n,
+     *   validityWindow: 10,
+     *   extraFee: (1000).microAlgo(),
+     *   staticFee: (1000).microAlgo(),
+     *   // Max fee doesn't make sense with extraFee AND staticFee
+     *   //  already specified, but here for completeness
+     *   maxFee: (3000).microAlgo(),
+     * })
      */
     addPayment(params: PaymentParams): TransactionComposer;
     /**
      * Add an asset create transaction to the transaction group.
      * @param params The asset create transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example
+     * ```typescript
+     * composer.addAssetCreate({ sender: "CREATORADDRESS", total: 100n})
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * composer.addAssetCreate({
+     *   sender: 'CREATORADDRESS',
+     *   total: 100n,
+     *   decimals: 2,
+     *   assetName: 'asset',
+     *   unitName: 'unit',
+     *   url: 'url',
+     *   metadataHash: 'metadataHash',
+     *   defaultFrozen: false,
+     *   manager: 'MANAGERADDRESS',
+     *   reserve: 'RESERVEADDRESS',
+     *   freeze: 'FREEZEADDRESS',
+     *   clawback: 'CLAWBACKADDRESS',
+     *   lease: 'lease',
+     *   note: 'note',
+     *   // You wouldn't normally set this field
+     *   firstValidRound: 1000n,
+     *   validityWindow: 10,
+     *   extraFee: (1000).microAlgo(),
+     *   staticFee: (1000).microAlgo(),
+     *   // Max fee doesn't make sense with extraFee AND staticFee
+     *   //  already specified, but here for completeness
+     *   maxFee: (3000).microAlgo(),
+     * })
      */
     addAssetCreate(params: AssetCreateParams): TransactionComposer;
     /**
      * Add an asset config transaction to the transaction group.
      * @param params The asset config transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example
+     * ```typescript
+     * composer.addAssetConfig({ sender: "MANAGERADDRESS", assetId: 123456n, manager: "MANAGERADDRESS" })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * composer.addAssetConfig({
+     *   sender: 'MANAGERADDRESS',
+     *   assetId: 123456n,
+     *   manager: 'MANAGERADDRESS',
+     *   reserve: 'RESERVEADDRESS',
+     *   freeze: 'FREEZEADDRESS',
+     *   clawback: 'CLAWBACKADDRESS',
+     *   lease: 'lease',
+     *   note: 'note',
+     *   // You wouldn't normally set this field
+     *   firstValidRound: 1000n,
+     *   validityWindow: 10,
+     *   extraFee: (1000).microAlgo(),
+     *   staticFee: (1000).microAlgo(),
+     *   // Max fee doesn't make sense with extraFee AND staticFee
+     *   //  already specified, but here for completeness
+     *   maxFee: (3000).microAlgo(),
+     * })
      */
     addAssetConfig(params: AssetConfigParams): TransactionComposer;
     /**
      * Add an asset freeze transaction to the transaction group.
      * @param params The asset freeze transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example
+     * ```typescript
+     * composer.addAssetFreeze({ sender: "MANAGERADDRESS", assetId: 123456n, account: "ACCOUNTADDRESS", frozen: true })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * composer.addAssetFreeze({
+     *   sender: 'MANAGERADDRESS',
+     *   assetId: 123456n,
+     *   account: 'ACCOUNTADDRESS',
+     *   frozen: true,
+     *   lease: 'lease',
+     *   note: 'note',
+     *   // You wouldn't normally set this field
+     *   firstValidRound: 1000n,
+     *   validityWindow: 10,
+     *   extraFee: (1000).microAlgo(),
+     *   staticFee: (1000).microAlgo(),
+     *   // Max fee doesn't make sense with extraFee AND staticFee
+     *   //  already specified, but here for completeness
+     *   maxFee: (3000).microAlgo(),
+     * })
+     * ```
      */
     addAssetFreeze(params: AssetFreezeParams): TransactionComposer;
     /**
      * Add an asset destroy transaction to the transaction group.
      * @param params The asset destroy transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example
+     * ```typescript
+     * composer.addAssetDestroy({ sender: "MANAGERADDRESS", assetId: 123456n })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * composer.addAssetDestroy({
+     *   sender: 'MANAGERADDRESS',
+     *   assetId: 123456n,
+     *   lease: 'lease',
+     *   note: 'note',
+     *   // You wouldn't normally set this field
+     *   firstValidRound: 1000n,
+     *   validityWindow: 10,
+     *   extraFee: (1000).microAlgo(),
+     *   staticFee: (1000).microAlgo(),
+     *   // Max fee doesn't make sense with extraFee AND staticFee
+     *   //  already specified, but here for completeness
+     *   maxFee: (3000).microAlgo(),
+     * })
+     * ```
      */
     addAssetDestroy(params: AssetDestroyParams): TransactionComposer;
     /**
      * Add an asset transfer transaction to the transaction group.
      * @param params The asset transfer transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example
+     * ```typescript
+     * composer.addAssetTransfer({ sender: "HOLDERADDRESS", assetId: 123456n, amount: 1n, receiver: "RECEIVERADDRESS" })
+     * ```
+     * @example Advanced example (with clawback)
+     * ```typescript
+     * composer.addAssetTransfer({
+     *   sender: 'CLAWBACKADDRESS',
+     *   assetId: 123456n,
+     *   amount: 1n,
+     *   receiver: 'RECEIVERADDRESS',
+     *   clawbackTarget: 'HOLDERADDRESS',
+     *   // This field needs to be used with caution
+     *   closeAssetTo: 'ADDRESSTOCLOSETO'
+     *   lease: 'lease',
+     *   note: 'note',
+     *   // You wouldn't normally set this field
+     *   firstValidRound: 1000n,
+     *   validityWindow: 10,
+     *   extraFee: (1000).microAlgo(),
+     *   staticFee: (1000).microAlgo(),
+     *   // Max fee doesn't make sense with extraFee AND staticFee
+     *   //  already specified, but here for completeness
+     *   maxFee: (3000).microAlgo(),
+     * })
+     * ```
      */
     addAssetTransfer(params: AssetTransferParams): TransactionComposer;
     /**
      * Add an asset opt-in transaction to the transaction group.
      * @param params The asset opt-in transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example
+     * ```typescript
+     * composer.addAssetOptIn({ sender: "SENDERADDRESS", assetId: 123456n })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * composer.addAssetOptIn({
+     *   sender: 'SENDERADDRESS',
+     *   assetId: 123456n,
+     *   lease: 'lease',
+     *   note: 'note',
+     *   // You wouldn't normally set this field
+     *   firstValidRound: 1000n,
+     *   validityWindow: 10,
+     *   extraFee: (1000).microAlgo(),
+     *   staticFee: (1000).microAlgo(),
+     *   // Max fee doesn't make sense with extraFee AND staticFee
+     *   //  already specified, but here for completeness
+     *   maxFee: (3000).microAlgo(),
+     * })
+     * ```
      */
     addAssetOptIn(params: AssetOptInParams): TransactionComposer;
     /**
      * Add an asset opt-out transaction to the transaction group.
      * @param params The asset opt-out transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example (without creator, will be retrieved from algod)
+     * ```typescript
+     * composer.addAssetOptOut({ sender: "SENDERADDRESS", assetId: 123456n, ensureZeroBalance: true })
+     * ```
+     * @example Basic example (with creator)
+     * ```typescript
+     * composer.addAssetOptOut({ sender: "SENDERADDRESS", creator: "CREATORADDRESS", assetId: 123456n, ensureZeroBalance: true })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * composer.addAssetOptOut({
+     *   sender: 'SENDERADDRESS',
+     *   assetId: 123456n,
+     *   creator: 'CREATORADDRESS',
+     *   ensureZeroBalance: true,
+     *   lease: 'lease',
+     *   note: 'note',
+     *   // You wouldn't normally set this field
+     *   firstValidRound: 1000n,
+     *   validityWindow: 10,
+     *   extraFee: (1000).microAlgo(),
+     *   staticFee: (1000).microAlgo(),
+     *   // Max fee doesn't make sense with extraFee AND staticFee
+     *   //  already specified, but here for completeness
+     *   maxFee: (3000).microAlgo(),
+     * })
+     * ```
      */
     addAssetOptOut(params: AssetOptOutParams): TransactionComposer;
     /**
@@ -532,6 +737,47 @@ export declare class TransactionComposer {
      * Note: we recommend using app clients to make it easier to make app calls.
      * @param params The application create transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example
+     * ```typescript
+     * composer.addAppCreate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * composer.addAppCreate({
+     *  sender: 'CREATORADDRESS',
+     *  approvalProgram: "TEALCODE",
+     *  clearStateProgram: "TEALCODE",
+     *  schema: {
+     *    globalInts: 1,
+     *    globalByteSlices: 2,
+     *    localInts: 3,
+     *    localByteSlices: 4
+     *  },
+     *  extraProgramPages: 1,
+     *  onComplete: algosdk.OnApplicationComplete.OptInOC,
+     *  args: [new Uint8Array(1, 2, 3, 4)]
+     *  accountReferences: ["ACCOUNT_1"]
+     *  appReferences: [123n, 1234n]
+     *  assetReferences: [12345n]
+     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+     *  lease: 'lease',
+     *  note: 'note',
+     *  // You wouldn't normally set this field
+     *  firstValidRound: 1000n,
+     *  validityWindow: 10,
+     *  extraFee: (1000).microAlgo(),
+     *  staticFee: (1000).microAlgo(),
+     *  // Max fee doesn't make sense with extraFee AND staticFee
+     *  //  already specified, but here for completeness
+     *  maxFee: (3000).microAlgo(),
+     *  // Signer only needed if you want to provide one,
+     *  //  generally you'd register it with AlgorandClient
+     *  //  against the sender and not need to pass it in
+     *  signer: transactionSigner,
+     *  maxRoundsToWaitForConfirmation: 5,
+     *  suppressLog: true,
+     *})
+     * ```
      */
     addAppCreate(params: AppCreateParams): TransactionComposer;
     /**
@@ -540,6 +786,34 @@ export declare class TransactionComposer {
      * Note: we recommend using app clients to make it easier to make app calls.
      * @param params The application update transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example
+     * ```typescript
+     * composer.addAppUpdate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * composer.addAppUpdate({
+     *  sender: 'CREATORADDRESS',
+     *  approvalProgram: "TEALCODE",
+     *  clearStateProgram: "TEALCODE",
+     *  onComplete: algosdk.OnApplicationComplete.UpdateApplicationOC,
+     *  args: [new Uint8Array(1, 2, 3, 4)]
+     *  accountReferences: ["ACCOUNT_1"]
+     *  appReferences: [123n, 1234n]
+     *  assetReferences: [12345n]
+     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+     *  lease: 'lease',
+     *  note: 'note',
+     *  // You wouldn't normally set this field
+     *  firstValidRound: 1000n,
+     *  validityWindow: 10,
+     *  extraFee: (1000).microAlgo(),
+     *  staticFee: (1000).microAlgo(),
+     *  // Max fee doesn't make sense with extraFee AND staticFee
+     *  //  already specified, but here for completeness
+     *  maxFee: (3000).microAlgo(),
+     *})
+     * ```
      */
     addAppUpdate(params: AppUpdateParams): TransactionComposer;
     /**
@@ -548,6 +822,32 @@ export declare class TransactionComposer {
      * Note: we recommend using app clients to make it easier to make app calls.
      * @param params The application delete transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example
+     * ```typescript
+     * composer.addAppDelete({ sender: 'CREATORADDRESS' })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * composer.addAppDelete({
+     *  sender: 'CREATORADDRESS',
+     *  onComplete: algosdk.OnApplicationComplete.DeleteApplicationOC,
+     *  args: [new Uint8Array(1, 2, 3, 4)]
+     *  accountReferences: ["ACCOUNT_1"]
+     *  appReferences: [123n, 1234n]
+     *  assetReferences: [12345n]
+     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+     *  lease: 'lease',
+     *  note: 'note',
+     *  // You wouldn't normally set this field
+     *  firstValidRound: 1000n,
+     *  validityWindow: 10,
+     *  extraFee: (1000).microAlgo(),
+     *  staticFee: (1000).microAlgo(),
+     *  // Max fee doesn't make sense with extraFee AND staticFee
+     *  //  already specified, but here for completeness
+     *  maxFee: (3000).microAlgo(),
+     *})
+     * ```
      */
     addAppDelete(params: AppDeleteParams): TransactionComposer;
     /**
@@ -558,6 +858,32 @@ export declare class TransactionComposer {
      * Note: we recommend using app clients to make it easier to make app calls.
      * @param params The application call transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example
+     * ```typescript
+     * composer.addAppCall({ sender: 'CREATORADDRESS' })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * composer.addAppCall({
+     *  sender: 'CREATORADDRESS',
+     *  onComplete: algosdk.OnApplicationComplete.OptInOC,
+     *  args: [new Uint8Array(1, 2, 3, 4)]
+     *  accountReferences: ["ACCOUNT_1"]
+     *  appReferences: [123n, 1234n]
+     *  assetReferences: [12345n]
+     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+     *  lease: 'lease',
+     *  note: 'note',
+     *  // You wouldn't normally set this field
+     *  firstValidRound: 1000n,
+     *  validityWindow: 10,
+     *  extraFee: (1000).microAlgo(),
+     *  staticFee: (1000).microAlgo(),
+     *  // Max fee doesn't make sense with extraFee AND staticFee
+     *  //  already specified, but here for completeness
+     *  maxFee: (3000).microAlgo(),
+     *})
+     * ```
      */
     addAppCall(params: AppCallParams): TransactionComposer;
     /**
@@ -566,6 +892,53 @@ export declare class TransactionComposer {
      * Note: we recommend using app clients to make it easier to make app calls.
      * @param params The ABI create method application call transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example
+     * ```typescript
+     * const method = new ABIMethod({
+     *   name: 'method',
+     *   args: [{ name: 'arg1', type: 'string' }],
+     *   returns: { type: 'string' },
+     * })
+     * composer.addAppCreateMethodCall({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE', method: method, args: ["arg1_value"] })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * const method = new ABIMethod({
+     *   name: 'method',
+     *   args: [{ name: 'arg1', type: 'string' }],
+     *   returns: { type: 'string' },
+     * })
+     * composer.addAppCreateMethodCall({
+     *  sender: 'CREATORADDRESS',
+     *  method: method,
+     *  args: ["arg1_value"],
+     *  approvalProgram: "TEALCODE",
+     *  clearStateProgram: "TEALCODE",
+     *  schema: {
+     *    globalInts: 1,
+     *    globalByteSlices: 2,
+     *    localInts: 3,
+     *    localByteSlices: 4
+     *  },
+     *  extraProgramPages: 1,
+     *  onComplete: algosdk.OnApplicationComplete.OptInOC,
+     *  args: [new Uint8Array(1, 2, 3, 4)]
+     *  accountReferences: ["ACCOUNT_1"]
+     *  appReferences: [123n, 1234n]
+     *  assetReferences: [12345n]
+     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+     *  lease: 'lease',
+     *  note: 'note',
+     *  // You wouldn't normally set this field
+     *  firstValidRound: 1000n,
+     *  validityWindow: 10,
+     *  extraFee: (1000).microAlgo(),
+     *  staticFee: (1000).microAlgo(),
+     *  // Max fee doesn't make sense with extraFee AND staticFee
+     *  //  already specified, but here for completeness
+     *  maxFee: (3000).microAlgo(),
+     *})
+     * ```
      */
     addAppCreateMethodCall(params: AppCreateMethodCall): this;
     /**
@@ -574,6 +947,46 @@ export declare class TransactionComposer {
      * Note: we recommend using app clients to make it easier to make app calls.
      * @param params The ABI update method application call transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example
+     * ```typescript
+     * const method = new ABIMethod({
+     *   name: 'method',
+     *   args: [{ name: 'arg1', type: 'string' }],
+     *   returns: { type: 'string' },
+     * })
+     * composer.addAppUpdateMethodCall({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE', method: method, args: ["arg1_value"] })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * const method = new ABIMethod({
+     *   name: 'method',
+     *   args: [{ name: 'arg1', type: 'string' }],
+     *   returns: { type: 'string' },
+     * })
+     * composer.addAppUpdateMethodCall({
+     *  sender: 'CREATORADDRESS',
+     *  method: method,
+     *  args: ["arg1_value"],
+     *  approvalProgram: "TEALCODE",
+     *  clearStateProgram: "TEALCODE",
+     *  onComplete: algosdk.OnApplicationComplete.UpdateApplicationOC,
+     *  args: [new Uint8Array(1, 2, 3, 4)]
+     *  accountReferences: ["ACCOUNT_1"]
+     *  appReferences: [123n, 1234n]
+     *  assetReferences: [12345n]
+     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+     *  lease: 'lease',
+     *  note: 'note',
+     *  // You wouldn't normally set this field
+     *  firstValidRound: 1000n,
+     *  validityWindow: 10,
+     *  extraFee: (1000).microAlgo(),
+     *  staticFee: (1000).microAlgo(),
+     *  // Max fee doesn't make sense with extraFee AND staticFee
+     *  //  already specified, but here for completeness
+     *  maxFee: (3000).microAlgo(),
+     *})
+     * ```
      */
     addAppUpdateMethodCall(params: AppUpdateMethodCall): this;
     /**
@@ -582,6 +995,44 @@ export declare class TransactionComposer {
      * Note: we recommend using app clients to make it easier to make app calls.
      * @param params The ABI delete method application call transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example
+     * ```typescript
+     * const method = new ABIMethod({
+     *   name: 'method',
+     *   args: [{ name: 'arg1', type: 'string' }],
+     *   returns: { type: 'string' },
+     * })
+     * composer.addAppDeleteMethodCall({ sender: 'CREATORADDRESS', method: method, args: ["arg1_value"] })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * const method = new ABIMethod({
+     *   name: 'method',
+     *   args: [{ name: 'arg1', type: 'string' }],
+     *   returns: { type: 'string' },
+     * })
+     * composer.addAppDeleteMethodCall({
+     *  sender: 'CREATORADDRESS',
+     *  method: method,
+     *  args: ["arg1_value"],
+     *  onComplete: algosdk.OnApplicationComplete.DeleteApplicationOC,
+     *  args: [new Uint8Array(1, 2, 3, 4)]
+     *  accountReferences: ["ACCOUNT_1"]
+     *  appReferences: [123n, 1234n]
+     *  assetReferences: [12345n]
+     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+     *  lease: 'lease',
+     *  note: 'note',
+     *  // You wouldn't normally set this field
+     *  firstValidRound: 1000n,
+     *  validityWindow: 10,
+     *  extraFee: (1000).microAlgo(),
+     *  staticFee: (1000).microAlgo(),
+     *  // Max fee doesn't make sense with extraFee AND staticFee
+     *  //  already specified, but here for completeness
+     *  maxFee: (3000).microAlgo(),
+     *})
+     * ```
      */
     addAppDeleteMethodCall(params: AppDeleteMethodCall): this;
     /**
@@ -590,24 +1041,128 @@ export declare class TransactionComposer {
      * Note: we recommend using app clients to make it easier to make app calls.
      * @param params The ABI method application call transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example
+     * ```typescript
+     * const method = new ABIMethod({
+     *   name: 'method',
+     *   args: [{ name: 'arg1', type: 'string' }],
+     *   returns: { type: 'string' },
+     * })
+     * composer.addAppCallMethodCall({ sender: 'CREATORADDRESS', method: method, args: ["arg1_value"] })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * const method = new ABIMethod({
+     *   name: 'method',
+     *   args: [{ name: 'arg1', type: 'string' }],
+     *   returns: { type: 'string' },
+     * })
+     * composer.addAppCallMethodCall({
+     *  sender: 'CREATORADDRESS',
+     *  method: method,
+     *  args: ["arg1_value"],
+     *  onComplete: algosdk.OnApplicationComplete.OptInOC,
+     *  args: [new Uint8Array(1, 2, 3, 4)]
+     *  accountReferences: ["ACCOUNT_1"]
+     *  appReferences: [123n, 1234n]
+     *  assetReferences: [12345n]
+     *  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
+     *  lease: 'lease',
+     *  note: 'note',
+     *  // You wouldn't normally set this field
+     *  firstValidRound: 1000n,
+     *  validityWindow: 10,
+     *  extraFee: (1000).microAlgo(),
+     *  staticFee: (1000).microAlgo(),
+     *  // Max fee doesn't make sense with extraFee AND staticFee
+     *  //  already specified, but here for completeness
+     *  maxFee: (3000).microAlgo(),
+     *})
+     * ```
      */
     addAppCallMethodCall(params: AppCallMethodCall): this;
     /**
      * Add an online key registration transaction to the transaction group.
      * @param params The online key registration transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example
+     * ```typescript
+     * composer.addOnlineKeyRegistration({
+     *   sender: 'SENDERADDRESS',
+     *   voteKey: Uint8Array.from(Buffer.from("voteKeyBase64", 'base64')),
+     *   selectionKey: Uint8Array.from(Buffer.from("selectionKeyBase64", 'base64')),
+     *   stateProofKey: Uint8Array.from(Buffer.from("stateProofKeyBase64", 'base64')),
+     *   voteFirst: 1n,
+     *   voteLast: 1000n,
+     *   voteKeyDilution: 1n,
+     * })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * composer.addOnlineKeyRegistration({
+     *   sender: 'SENDERADDRESS',
+     *   voteKey: Uint8Array.from(Buffer.from("voteKeyBase64", 'base64')),
+     *   selectionKey: Uint8Array.from(Buffer.from("selectionKeyBase64", 'base64')),
+     *   stateProofKey: Uint8Array.from(Buffer.from("stateProofKeyBase64", 'base64')),
+     *   voteFirst: 1n,
+     *   voteLast: 1000n,
+     *   voteKeyDilution: 1n,
+     *   lease: 'lease',
+     *   note: 'note',
+     *   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
+     *   rekeyTo: 'REKEYTOADDRESS',
+     *   // You wouldn't normally set this field
+     *   firstValidRound: 1000n,
+     *   validityWindow: 10,
+     *   extraFee: (1000).microAlgo(),
+     *   staticFee: (1000).microAlgo(),
+     *   // Max fee doesn't make sense with extraFee AND staticFee
+     *   //  already specified, but here for completeness
+     *   maxFee: (3000).microAlgo(),
+     * })
+     * ```
      */
     addOnlineKeyRegistration(params: OnlineKeyRegistrationParams): TransactionComposer;
     /**
      * Add an offline key registration transaction to the transaction group.
      * @param params The offline key registration transaction parameters
      * @returns The composer so you can chain method calls
+     * @example Basic example
+     * ```typescript
+     * composer.addOfflineKeyRegistration({
+     *   sender: 'SENDERADDRESS',
+     * })
+     * ```
+     * @example Advanced example
+     * ```typescript
+     * composer.addOfflineKeyRegistration({
+     *   sender: 'SENDERADDRESS',
+     *   lease: 'lease',
+     *   note: 'note',
+     *   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
+     *   rekeyTo: 'REKEYTOADDRESS',
+     *   // You wouldn't normally set this field
+     *   firstValidRound: 1000n,
+     *   validityWindow: 10,
+     *   extraFee: (1000).microAlgo(),
+     *   staticFee: (1000).microAlgo(),
+     *   // Max fee doesn't make sense with extraFee AND staticFee
+     *   //  already specified, but here for completeness
+     *   maxFee: (3000).microAlgo(),
+     * })
+     * ```
      */
     addOfflineKeyRegistration(params: OfflineKeyRegistrationParams): TransactionComposer;
     /**
      * Add the transactions within an `AtomicTransactionComposer` to the transaction group.
      * @param atc The `AtomicTransactionComposer` to build transactions from and add to the group
      * @returns The composer so you can chain method calls
+     * @example
+     * ```typescript
+     * const atc = new AtomicTransactionComposer()
+     *   .addPayment({ sender: 'SENDERADDRESS', receiver: 'RECEIVERADDRESS', amount: 1000n })
+     * composer.addAtc(atc)
+     * ```
      */
     addAtc(atc: algosdk.AtomicTransactionComposer): TransactionComposer;
     /** Build an ATC and return transactions ready to be incorporated into a broader set of transactions this composer is composing */
@@ -634,10 +1189,15 @@ export declare class TransactionComposer {
      * Compose all of the transactions without signers and return the transaction objects directly along with any ABI method calls.
      *
      * @returns The array of built transactions and any corresponding method calls
+     * @example
+     * ```typescript
+     * const { transactions, methodCalls, signers } = await composer.buildTransactions()
+     * ```
      */
     buildTransactions(): Promise<BuiltTransactions>;
     /**
      * Get the number of transactions currently added to this composer.
+     * @returns The number of transactions currently added to this composer
      */
     count(): Promise<number>;
     /**
@@ -647,7 +1207,11 @@ export declare class TransactionComposer {
      *
      * Once this method is called, no further transactions will be able to be added.
      * You can safely call this method multiple times to get the same result.
-     * @returns The built atomic transaction composer and the transactions
+     * @returns The built atomic transaction composer, the transactions and any corresponding method calls
+     * @example
+     * ```typescript
+     * const { atc, transactions, methodCalls } = await composer.build()
+     * ```
      */
     build(): Promise<{
         atc: algosdk.AtomicTransactionComposer;
@@ -658,6 +1222,10 @@ export declare class TransactionComposer {
      * Rebuild the group, discarding any previously built transactions.
      * This will potentially cause new signers and suggested params to be used if the callbacks return a new value compared to the first build.
      * @returns The newly built atomic transaction composer and the transactions
+     * @example
+     * ```typescript
+     * const { atc, transactions, methodCalls } = await composer.rebuild()
+     * ```
      */
     rebuild(): Promise<{
         atc: algosdk.AtomicTransactionComposer;
@@ -668,6 +1236,12 @@ export declare class TransactionComposer {
      * Compose the atomic transaction group and send it to the network.
      * @param params The parameters to control execution with
      * @returns The execution result
+     * @example
+     * ```typescript
+     * const result = await composer.send({
+     *   populateAppCallResources: true,
+     * })
+     * ```
      */
     send(params?: SendParams): Promise<SendAtomicTransactionComposerResults>;
     /**
@@ -683,13 +1257,37 @@ export declare class TransactionComposer {
     /**
      * Compose the atomic transaction group and simulate sending it to the network
      * @returns The simulation result
+     * @example
+     * ```typescript
+     * const result = await composer.simulate()
+     * ```
      */
     simulate(): Promise<SendAtomicTransactionComposerResults & {
         simulateResponse: SimulateResponse;
     }>;
+    /**
+     * Compose the atomic transaction group and simulate sending it to the network
+     * @returns The simulation result
+     * @example
+     * ```typescript
+     * const result = await composer.simulate({
+     *   skipSignatures: true,
+     * })
+     * ```
+     */
     simulate(options: SkipSignaturesSimulateOptions): Promise<SendAtomicTransactionComposerResults & {
         simulateResponse: SimulateResponse;
     }>;
+    /**
+     * Compose the atomic transaction group and simulate sending it to the network
+     * @returns The simulation result
+     * @example
+     * ```typescript
+     * const result = await composer.simulate({
+     *   extraOpcodeBudget: 1000,
+     * })
+     * ```
+     */
     simulate(options: RawSimulateOptions): Promise<SendAtomicTransactionComposerResults & {
         simulateResponse: SimulateResponse;
     }>;