@algorandfoundation/algokit-utils 9.2.1-beta.3 → 9.2.2-beta.1

package/types/kmd-account-manager.d.ts

@@ -1,78 +1,73 @@
-import { AlgoAmount } from "./amount.js";
-import { SigningAccount, TransactionSignerAccount } from "./account.js";
-import { ClientManager } from "./client-manager.js";
-import algosdk, { Address } from "algosdk";
-
-//#region src/types/kmd-account-manager.d.ts
+import algosdk, { Address } from 'algosdk';
+import { SigningAccount, TransactionSignerAccount } from './account';
+import { AlgoAmount } from './amount';
+import { ClientManager } from './client-manager';
 /** Provides abstractions over a [KMD](https://github.com/algorand/go-algorand/blob/master/daemon/kmd/README.md) instance
  * that makes it easier to get and manage accounts using KMD. */
-declare class KmdAccountManager {
-  private _clientManager;
-  private _kmd?;
-  /**
-   * Create a new KMD manager.
-   * @param clientManager A ClientManager client to use for algod and kmd clients
-   */
-  constructor(clientManager: ClientManager);
-  kmd(): Promise<algosdk.Kmd>;
-  /**
-   * Returns an Algorand signing account with private key loaded from the given KMD wallet (identified by name).
-   *
-   * @param walletName The name of the wallet to retrieve an account from
-   * @param predicate An optional filter to use to find the account (otherwise it will return a random account from the wallet)
-   * @param sender The optional sender address to use this signer for (aka a rekeyed account)
-   * @example Get default funded account in a LocalNet
-   *
-   * ```typescript
-   * const defaultDispenserAccount = await kmdAccountManager.getWalletAccount(
-   *   'unencrypted-default-wallet',
-   *   a => a.status !== 'Offline' && a.amount > 1_000_000_000
-   * )
-   * ```
-   * @returns The signing account (with private key loaded) or undefined if no matching wallet or account was found
-   */
-  getWalletAccount(walletName: string, predicate?: (account: Record<string, any>) => boolean, sender?: string | Address): Promise<(TransactionSignerAccount & {
-    account: SigningAccount;
-  }) | undefined>;
-  private findWalletAccount;
-  /**
-   * Gets an account with private key loaded from a KMD wallet of the given name, or alternatively creates one with funds in it via a KMD wallet of the given name.
-   *
-   * This is useful to get idempotent accounts from LocalNet without having to specify the private key (which will change when resetting the LocalNet).
-   *
-   * This significantly speeds up local dev time and improves experience since you can write code that *just works* first go without manual config in a fresh LocalNet.
-   *
-   * If this is used via `mnemonicAccountFromEnvironment`, then you can even use the same code that runs on production without changes for local development!
-   *
-   * @param name The name of the wallet to retrieve / create
-   * @param fundWith The number of Algo to fund the account with when it gets created, if not specified then 1000 ALGO will be funded from the dispenser account
-   *
-   * @example
-   * ```typescript
-   * // Idempotently get (if exists) or create (if it doesn't exist yet) an account by name using KMD
-   * // if creating it then fund it with 2 ALGO from the default dispenser account
-   * const newAccount = await kmdAccountManager.getOrCreateWalletAccount('account1', (2).algo())
-   * // This will return the same account as above since the name matches
-   * const existingAccount = await kmdAccountManager.getOrCreateWalletAccount('account1')
-   * ```
-   *
-   * @returns An Algorand account with private key loaded - either one that already existed in the given KMD wallet, or a new one that is funded for you
-   */
-  getOrCreateWalletAccount(name: string, fundWith?: AlgoAmount): Promise<TransactionSignerAccount & {
-    account: SigningAccount;
-  }>;
-  /**
-   * Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts).
-   * @example
-   * ```typescript
-   * const dispenser = await kmdAccountManager.getLocalNetDispenserAccount()
-   * ```
-   * @returns The default LocalNet dispenser account
-   */
-  getLocalNetDispenserAccount(): Promise<TransactionSignerAccount & {
-    account: SigningAccount;
-  }>;
+export declare class KmdAccountManager {
+    private _clientManager;
+    private _kmd?;
+    /**
+     * Create a new KMD manager.
+     * @param clientManager A ClientManager client to use for algod and kmd clients
+     */
+    constructor(clientManager: ClientManager);
+    kmd(): Promise<algosdk.Kmd>;
+    /**
+     * Returns an Algorand signing account with private key loaded from the given KMD wallet (identified by name).
+     *
+     * @param walletName The name of the wallet to retrieve an account from
+     * @param predicate An optional filter to use to find the account (otherwise it will return a random account from the wallet)
+     * @param sender The optional sender address to use this signer for (aka a rekeyed account)
+     * @example Get default funded account in a LocalNet
+     *
+     * ```typescript
+     * const defaultDispenserAccount = await kmdAccountManager.getWalletAccount(
+     *   'unencrypted-default-wallet',
+     *   a => a.status !== 'Offline' && a.amount > 1_000_000_000
+     * )
+     * ```
+     * @returns The signing account (with private key loaded) or undefined if no matching wallet or account was found
+     */
+    getWalletAccount(walletName: string, predicate?: (account: Record<string, any>) => boolean, sender?: string | Address): Promise<(TransactionSignerAccount & {
+        account: SigningAccount;
+    }) | undefined>;
+    private findWalletAccount;
+    /**
+     * Gets an account with private key loaded from a KMD wallet of the given name, or alternatively creates one with funds in it via a KMD wallet of the given name.
+     *
+     * This is useful to get idempotent accounts from LocalNet without having to specify the private key (which will change when resetting the LocalNet).
+     *
+     * This significantly speeds up local dev time and improves experience since you can write code that *just works* first go without manual config in a fresh LocalNet.
+     *
+     * If this is used via `mnemonicAccountFromEnvironment`, then you can even use the same code that runs on production without changes for local development!
+     *
+     * @param name The name of the wallet to retrieve / create
+     * @param fundWith The number of Algo to fund the account with when it gets created, if not specified then 1000 ALGO will be funded from the dispenser account
+     *
+     * @example
+     * ```typescript
+     * // Idempotently get (if exists) or create (if it doesn't exist yet) an account by name using KMD
+     * // if creating it then fund it with 2 ALGO from the default dispenser account
+     * const newAccount = await kmdAccountManager.getOrCreateWalletAccount('account1', (2).algo())
+     * // This will return the same account as above since the name matches
+     * const existingAccount = await kmdAccountManager.getOrCreateWalletAccount('account1')
+     * ```
+     *
+     * @returns An Algorand account with private key loaded - either one that already existed in the given KMD wallet, or a new one that is funded for you
+     */
+    getOrCreateWalletAccount(name: string, fundWith?: AlgoAmount): Promise<TransactionSignerAccount & {
+        account: SigningAccount;
+    }>;
+    /**
+     * Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts).
+     * @example
+     * ```typescript
+     * const dispenser = await kmdAccountManager.getLocalNetDispenserAccount()
+     * ```
+     * @returns The default LocalNet dispenser account
+     */
+    getLocalNetDispenserAccount(): Promise<TransactionSignerAccount & {
+        account: SigningAccount;
+    }>;
 }
-//#endregion
-export { KmdAccountManager };
-//# sourceMappingURL=kmd-account-manager.d.ts.map

package/types/lifecycle-events.d.ts

@@ -1,15 +1,10 @@
-import { AVMTracesEventData, TealSourcesDebugEventData } from "./debugging.js";
-
-//#region src/types/lifecycle-events.d.ts
-declare enum EventType {
-  TxnGroupSimulated = "TxnGroupSimulated",
-  AppCompiled = "AppCompiled"
+import { AVMTracesEventData, TealSourcesDebugEventData } from './debugging';
+export declare enum EventType {
+    TxnGroupSimulated = "TxnGroupSimulated",
+    AppCompiled = "AppCompiled"
 }
-type EventDataMap = {
-  [EventType.TxnGroupSimulated]: AVMTracesEventData;
-  [EventType.AppCompiled]: TealSourcesDebugEventData;
-  [key: string]: unknown;
+export type EventDataMap = {
+    [EventType.TxnGroupSimulated]: AVMTracesEventData;
+    [EventType.AppCompiled]: TealSourcesDebugEventData;
+    [key: string]: unknown;
 };
-//#endregion
-export { EventDataMap, EventType };
-//# sourceMappingURL=lifecycle-events.d.ts.map

package/types/logging.d.ts

@@ -1,19 +1,15 @@
-//#region src/types/logging.d.ts
 /** General purpose logger type, compatible with Winston and others. */
-type Logger = {
-  error(message: string, ...optionalParams: unknown[]): void;
-  warn(message: string, ...optionalParams: unknown[]): void;
-  info(message: string, ...optionalParams: unknown[]): void;
-  verbose(message: string, ...optionalParams: unknown[]): void;
-  debug(message: string, ...optionalParams: unknown[]): void;
+export type Logger = {
+    error(message: string, ...optionalParams: unknown[]): void;
+    warn(message: string, ...optionalParams: unknown[]): void;
+    info(message: string, ...optionalParams: unknown[]): void;
+    verbose(message: string, ...optionalParams: unknown[]): void;
+    debug(message: string, ...optionalParams: unknown[]): void;
 };
 /** A logger implementation that writes to console */
-declare const consoleLogger: Logger;
-declare const infoConsoleLogger: Logger;
-declare const verboseConsoleLogger: Logger;
-declare const warningConsoleLogger: Logger;
+export declare const consoleLogger: Logger;
+export declare const infoConsoleLogger: Logger;
+export declare const verboseConsoleLogger: Logger;
+export declare const warningConsoleLogger: Logger;
 /** A logger implementation that does nothing */
-declare const nullLogger: Logger;
-//#endregion
-export { Logger, consoleLogger, infoConsoleLogger, nullLogger, verboseConsoleLogger, warningConsoleLogger };
-//# sourceMappingURL=logging.d.ts.map
+export declare const nullLogger: Logger;

package/types/logic-error.d.ts

@@ -1,39 +1,35 @@
-//#region src/types/logic-error.d.ts
 /**
  * Details about a smart contract logic error
  */
-interface LogicErrorDetails {
-  /** The ID of the transaction with the logic error */
-  txId: string;
-  /** The program counter where the error was */
-  pc: number;
-  /** The error message */
-  msg: string;
-  /** The full error description */
-  desc: string;
-  /** Any trace information included in the error */
-  traces: Record<string, unknown>[];
+export interface LogicErrorDetails {
+    /** The ID of the transaction with the logic error */
+    txId: string;
+    /** The program counter where the error was */
+    pc: number;
+    /** The error message */
+    msg: string;
+    /** The full error description */
+    desc: string;
+    /** Any trace information included in the error */
+    traces: Record<string, unknown>[];
 }
 /** Wraps key functionality around processing logic errors */
-declare class LogicError extends Error {
-  /** Takes an error message and parses out the details of any logic errors in there.
-   * @param error The error message to parse
-   * @returns The logic error details if any, or undefined
-   */
-  static parseLogicError(error: any): LogicErrorDetails | undefined;
-  led: LogicErrorDetails;
-  program: string[];
-  lines: number;
-  teal_line: number;
-  stack?: string;
-  /**
-   * Create a new logic error object.
-   * @param errorDetails The details of the logic error
-   * @param program The TEAL source code, split by line
-   * @param getLineForPc The source map of the TEAL source code
-   */
-  constructor(errorDetails: LogicErrorDetails, program: string[], getLineForPc: (pc: number) => number | undefined);
+export declare class LogicError extends Error {
+    /** Takes an error message and parses out the details of any logic errors in there.
+     * @param error The error message to parse
+     * @returns The logic error details if any, or undefined
+     */
+    static parseLogicError(error: any): LogicErrorDetails | undefined;
+    led: LogicErrorDetails;
+    program: string[];
+    lines: number;
+    teal_line: number;
+    stack?: string;
+    /**
+     * Create a new logic error object.
+     * @param errorDetails The details of the logic error
+     * @param program The TEAL source code, split by line
+     * @param getLineForPc The source map of the TEAL source code
+     */
+    constructor(errorDetails: LogicErrorDetails, program: string[], getLineForPc: (pc: number) => number | undefined);
 }
-//#endregion
-export { LogicError, LogicErrorDetails };
-//# sourceMappingURL=logic-error.d.ts.map

package/types/network-client.d.ts

@@ -1,43 +1,38 @@
-import { TokenHeader } from "algosdk";
-
-//#region src/types/network-client.d.ts
+import { TokenHeader } from 'algosdk';
 /** Config for an Algorand SDK client. */
-interface AlgoClientConfig {
-  /** Base URL of the server e.g. http://localhost, https://testnet-api.algonode.cloud/, etc. */
-  server: string;
-  /** The port to use e.g. 4001, 443, etc. */
-  port?: string | number;
-  /** The token to use for API authentication (or undefined if none needed) - can be a string, or an object with the header key => value */
-  token?: string | TokenHeader;
+export interface AlgoClientConfig {
+    /** Base URL of the server e.g. http://localhost, https://testnet-api.algonode.cloud/, etc. */
+    server: string;
+    /** The port to use e.g. 4001, 443, etc. */
+    port?: string | number;
+    /** The token to use for API authentication (or undefined if none needed) - can be a string, or an object with the header key => value */
+    token?: string | TokenHeader;
 }
 /** Configuration for algod, indexer and kmd clients. */
-interface AlgoConfig {
-  /** Algod client configuration */
-  algodConfig: AlgoClientConfig;
-  /** Indexer client configuration */
-  indexerConfig?: AlgoClientConfig;
-  /** Kmd configuration */
-  kmdConfig?: AlgoClientConfig;
+export interface AlgoConfig {
+    /** Algod client configuration */
+    algodConfig: AlgoClientConfig;
+    /** Indexer client configuration */
+    indexerConfig?: AlgoClientConfig;
+    /** Kmd configuration */
+    kmdConfig?: AlgoClientConfig;
 }
 /** Details of the current network. */
-interface NetworkDetails {
-  /** Whether or not the network is TestNet. */
-  isTestNet: boolean;
-  /** Whether or not the network is MainNet. */
-  isMainNet: boolean;
-  /** Whether or not the network is LocalNet. */
-  isLocalNet: boolean;
-  /** The genesis ID of the current network. */
-  genesisId: string;
-  /** The base64 genesis hash of the current network. */
-  genesisHash: string;
+export interface NetworkDetails {
+    /** Whether or not the network is TestNet. */
+    isTestNet: boolean;
+    /** Whether or not the network is MainNet. */
+    isMainNet: boolean;
+    /** Whether or not the network is LocalNet. */
+    isLocalNet: boolean;
+    /** The genesis ID of the current network. */
+    genesisId: string;
+    /** The base64 genesis hash of the current network. */
+    genesisHash: string;
 }
 /**
  * Returns true if the given network genesisId is associated with a LocalNet network.
  * @param genesisId The network genesis ID
  * @returns Whether the given genesis ID is associated with a LocalNet network
  */
-declare function genesisIdIsLocalNet(genesisId: string): genesisId is "devnet-v1" | "sandnet-v1" | "dockernet-v1";
-//#endregion
-export { AlgoClientConfig, AlgoConfig, NetworkDetails, genesisIdIsLocalNet };
-//# sourceMappingURL=network-client.d.ts.map
+export declare function genesisIdIsLocalNet(genesisId: string): genesisId is "devnet-v1" | "sandnet-v1" | "dockernet-v1";

package/types/testing.d.ts

@@ -1,149 +1,150 @@
-import { AlgoAmount } from "./amount.js";
-import { MultisigAccount, SigningAccount, TransactionSignerAccount } from "./account.js";
-import { AlgoConfig } from "./network-client.js";
-import { AlgorandClient } from "./algorand-client.js";
-import { TestLogger } from "../testing/test-logger.js";
-import { TransactionLogger } from "../testing/transaction-logger.js";
-import algosdk, { Address } from "algosdk";
-
-//#region src/types/testing.d.ts
+import algosdk, { Address } from 'algosdk';
+import { TransactionLogger } from '../testing';
+import { TestLogger } from '../testing/test-logger';
+import { AlgoAmount } from '../types/amount';
+import { MultisigAccount, SigningAccount, TransactionSignerAccount } from './account';
+import { AlgorandClient } from './algorand-client';
+import { AlgoConfig } from './network-client';
+import Account = algosdk.Account;
+import Algodv2 = algosdk.Algodv2;
+import Indexer = algosdk.Indexer;
+import Kmd = algosdk.Kmd;
+import LogicSigAccount = algosdk.LogicSigAccount;
+import Transaction = algosdk.Transaction;
 /**
  * Test automation context.
  */
-interface AlgorandTestAutomationContext {
-  /** An AlgorandClient instance loaded with the current context, including testAccount and any generated accounts loaded as signers */
-  algorand: AlgorandClient;
-  /** Algod client instance that will log transactions in `transactionLogger` */
-  algod: Algodv2;
-  /** Indexer client instance */
-  indexer: Indexer;
-  /** KMD client instance */
-  kmd: Kmd;
-  /** Transaction logger that will log transaction IDs for all transactions issued by `algod` */
-  transactionLogger: TransactionLogger;
-  /** Default, funded test account that is ephemerally created */
-  testAccount: Address & TransactionSignerAccount & Account;
-  /** Generate and fund an additional ephemerally created account */
-  generateAccount: (params: GetTestAccountParams) => Promise<Address & Account & TransactionSignerAccount>;
-  /** Wait for the indexer to catch up with all transactions logged by `transactionLogger` */
-  waitForIndexer: () => Promise<void>;
-  /** Wait for the indexer to catch up with the given transaction ID */
-  waitForIndexerTransaction: (transactionId: string) => Promise<algosdk.indexerModels.TransactionResponse>;
+export interface AlgorandTestAutomationContext {
+    /** An AlgorandClient instance loaded with the current context, including testAccount and any generated accounts loaded as signers */
+    algorand: AlgorandClient;
+    /** Algod client instance that will log transactions in `transactionLogger` */
+    algod: Algodv2;
+    /** Indexer client instance */
+    indexer: Indexer;
+    /** KMD client instance */
+    kmd: Kmd;
+    /** Transaction logger that will log transaction IDs for all transactions issued by `algod` */
+    transactionLogger: TransactionLogger;
+    /** Default, funded test account that is ephemerally created */
+    testAccount: Address & TransactionSignerAccount & Account;
+    /** Generate and fund an additional ephemerally created account */
+    generateAccount: (params: GetTestAccountParams) => Promise<Address & Account & TransactionSignerAccount>;
+    /** Wait for the indexer to catch up with all transactions logged by `transactionLogger` */
+    waitForIndexer: () => Promise<void>;
+    /** Wait for the indexer to catch up with the given transaction ID */
+    waitForIndexerTransaction: (transactionId: string) => Promise<algosdk.indexerModels.TransactionResponse>;
 }
 /**
  * Parameters for the `getTestAccount` function.
  */
-interface GetTestAccountParams {
-  /** Initial funds to ensure the account has */
-  initialFunds: AlgoAmount;
-  /** Whether to suppress the log (which includes a mnemonic) or not (default: do not suppress the log) */
-  suppressLog?: boolean;
-  /** Optional override for how to get a test account; this allows you to retrieve accounts from a known or cached list of accounts. */
-  accountGetter?: (algorand: AlgorandClient) => Promise<Account>;
+export interface GetTestAccountParams {
+    /** Initial funds to ensure the account has */
+    initialFunds: AlgoAmount;
+    /** Whether to suppress the log (which includes a mnemonic) or not (default: do not suppress the log) */
+    suppressLog?: boolean;
+    /** Optional override for how to get a test account; this allows you to retrieve accounts from a known or cached list of accounts. */
+    accountGetter?: (algorand: AlgorandClient) => Promise<Account>;
 }
 /** Configuration for creating an Algorand testing fixture. */
-interface AlgorandFixtureConfig extends Partial<AlgoConfig> {
-  /** An optional algod client, if not specified then it will create one against `algodConfig` (if present) then environment variables defined network (if present) or default LocalNet. */
-  algod?: Algodv2;
-  /** An optional indexer client, if not specified then it will create one against `indexerConfig` (if present) then environment variables defined network (if present) or default LocalNet. */
-  indexer?: Indexer;
-  /** An optional kmd client, if not specified then it will create one against `kmdConfig` (if present) then environment variables defined network (if present) or default LocalNet. */
-  kmd?: Kmd;
-  /** The amount of funds to allocate to the default testing account, if not specified then it will get 10 ALGO. */
-  testAccountFunding?: AlgoAmount;
-  /** Optional override for how to get an account; this allows you to retrieve accounts from a known or cached list of accounts. */
-  accountGetter?: (algod: Algodv2, kmd?: Kmd) => Promise<Account>;
+export interface AlgorandFixtureConfig extends Partial<AlgoConfig> {
+    /** An optional algod client, if not specified then it will create one against `algodConfig` (if present) then environment variables defined network (if present) or default LocalNet. */
+    algod?: Algodv2;
+    /** An optional indexer client, if not specified then it will create one against `indexerConfig` (if present) then environment variables defined network (if present) or default LocalNet. */
+    indexer?: Indexer;
+    /** An optional kmd client, if not specified then it will create one against `kmdConfig` (if present) then environment variables defined network (if present) or default LocalNet. */
+    kmd?: Kmd;
+    /** The amount of funds to allocate to the default testing account, if not specified then it will get 10 ALGO. */
+    testAccountFunding?: AlgoAmount;
+    /** Optional override for how to get an account; this allows you to retrieve accounts from a known or cached list of accounts. */
+    accountGetter?: (algod: Algodv2, kmd?: Kmd) => Promise<Account>;
 }
 /** An Algorand automated testing fixture */
-interface AlgorandFixture {
-  /**
-   * Retrieve the current context.
-   * Useful with destructuring.
-   *
-   * If you haven't called `newScope` then this will throw an error.
-   * @example
-   * ```typescript
-   * test('My test', () => {
-   *     const {algod, indexer, testAccount, ...} = fixture.context
-   * })
-   * ```
-   */
-  get context(): AlgorandTestAutomationContext;
-  /**
-   * Retrieve an `AlgorandClient` loaded with the current context, including testAccount and any generated accounts loaded as signers.
-   */
-  get algorand(): AlgorandClient;
-  /**
-   * @deprecated Use newScope instead.
-   * Testing framework agnostic handler method to run before each test to prepare the `context` for that test with per test isolation.
-   */
-  beforeEach: () => Promise<void>;
-  /**
-   * Creates a new isolated fixture scope (clean transaction logger, AlgorandClient, testAccount, etc.).
-   *
-   * You can call this from any testing framework specific hook method to control when you want a new scope.
-   *
-   * @example Jest / vitest - per test isolation (beforeEach)
-   * ```typescript
-   * describe('MY MODULE', () => {
-   *   const fixture = algorandFixture()
-   *   beforeEach(fixture.newScope)
-   *
-   *   test('MY TEST', async () => {
-   *     const { algorand, testAccount } = fixture.context
-   *
-   *     // Test stuff!
-   *   })
-   * })
-   * ```
-   *
-   * @example Jest / vitest - test suite isolation (beforeAll)
-   * ```typescript
-   * describe('MY MODULE', () => {
-   *   const fixture = algorandFixture()
-   *   beforeAll(fixture.newScope)
-   *
-   *   test('test1', async () => {
-   *     const { algorand, testAccount } = fixture.context
-   *
-   *     // Test stuff!
-   *   })
-   *   test('test2', async () => {
-   *     const { algorand, testAccount } = fixture.context
-   *     // algorand and testAccount are the same as in test1
-   *   })
-   * })
-   * ```
-   *
-   */
-  newScope: () => Promise<void>;
+export interface AlgorandFixture {
+    /**
+     * Retrieve the current context.
+     * Useful with destructuring.
+     *
+     * If you haven't called `newScope` then this will throw an error.
+     * @example
+     * ```typescript
+     * test('My test', () => {
+     *     const {algod, indexer, testAccount, ...} = fixture.context
+     * })
+     * ```
+     */
+    get context(): AlgorandTestAutomationContext;
+    /**
+     * Retrieve an `AlgorandClient` loaded with the current context, including testAccount and any generated accounts loaded as signers.
+     */
+    get algorand(): AlgorandClient;
+    /**
+     * @deprecated Use newScope instead.
+     * Testing framework agnostic handler method to run before each test to prepare the `context` for that test with per test isolation.
+     */
+    beforeEach: () => Promise<void>;
+    /**
+     * Creates a new isolated fixture scope (clean transaction logger, AlgorandClient, testAccount, etc.).
+     *
+     * You can call this from any testing framework specific hook method to control when you want a new scope.
+     *
+     * @example Jest / vitest - per test isolation (beforeEach)
+     * ```typescript
+     * describe('MY MODULE', () => {
+     *   const fixture = algorandFixture()
+     *   beforeEach(fixture.newScope)
+     *
+     *   test('MY TEST', async () => {
+     *     const { algorand, testAccount } = fixture.context
+     *
+     *     // Test stuff!
+     *   })
+     * })
+     * ```
+     *
+     * @example Jest / vitest - test suite isolation (beforeAll)
+     * ```typescript
+     * describe('MY MODULE', () => {
+     *   const fixture = algorandFixture()
+     *   beforeAll(fixture.newScope)
+     *
+     *   test('test1', async () => {
+     *     const { algorand, testAccount } = fixture.context
+     *
+     *     // Test stuff!
+     *   })
+     *   test('test2', async () => {
+     *     const { algorand, testAccount } = fixture.context
+     *     // algorand and testAccount are the same as in test1
+     *   })
+     * })
+     * ```
+     *
+     */
+    newScope: () => Promise<void>;
 }
 /** Configuration for preparing a captured log snapshot.
  * This helps ensure that the provided configuration items won't appear
  *  with random values in the log snapshot, but rather will get substituted with predictable ids.
  */
-interface LogSnapshotConfig {
-  /** Any transaction IDs or transactions to replace the ID for predictably */
-  transactions?: (string | Transaction)[];
-  /** Any accounts/addresses to replace the address for predictably */
-  accounts?: (string | Address | Account | SigningAccount | LogicSigAccount | MultisigAccount | TransactionSignerAccount)[];
-  /** Any app IDs to replace predictably */
-  apps?: (string | number | bigint)[];
-  /** Optional filter predicate to filter out logs */
-  filterPredicate?: (log: string) => boolean;
+export interface LogSnapshotConfig {
+    /** Any transaction IDs or transactions to replace the ID for predictably */
+    transactions?: (string | Transaction)[];
+    /** Any accounts/addresses to replace the address for predictably */
+    accounts?: (string | Address | Account | SigningAccount | LogicSigAccount | MultisigAccount | TransactionSignerAccount)[];
+    /** Any app IDs to replace predictably */
+    apps?: (string | number | bigint)[];
+    /** Optional filter predicate to filter out logs */
+    filterPredicate?: (log: string) => boolean;
 }
-interface AlgoKitLogCaptureFixture {
-  /** The test logger instance for the current test */
-  get testLogger(): TestLogger;
-  /**
-   * Testing framework agnostic handler method to run before each test to prepare the `testLogger` for that test.
-   */
-  beforeEach: () => void;
-  /**
-   * Testing framework agnostic handler method to run after each test to reset the logger.
-   */
-  afterEach: () => void;
+export interface AlgoKitLogCaptureFixture {
+    /** The test logger instance for the current test */
+    get testLogger(): TestLogger;
+    /**
+     * Testing framework agnostic handler method to run before each test to prepare the `testLogger` for that test.
+     */
+    beforeEach: () => void;
+    /**
+     * Testing framework agnostic handler method to run after each test to reset the logger.
+     */
+    afterEach: () => void;
 }
-//#endregion
-export { AlgoKitLogCaptureFixture, AlgorandFixture, AlgorandFixtureConfig, AlgorandTestAutomationContext, GetTestAccountParams, LogSnapshotConfig };
-//# sourceMappingURL=testing.d.ts.map