// Automatically @generated by scripts/vm.py. Do not modify manually.

// SPDX-License-Identifier: MIT OR Apache-2.0

pragma solidity >=0.6.2 <0.9.0;

pragma experimental ABIEncoderV2;

/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may

/// result in Script simulations differing from on-chain execution. It is recommended to only use

/// these cheats in scripts.

interface VmSafe {

    /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.

    enum CallerMode {

        // No caller modification is currently active.

        None,

        // A one time broadcast triggered by a `vm.broadcast()` call is currently active.

        Broadcast,

        // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.

        RecurrentBroadcast,

        // A one time prank triggered by a `vm.prank()` call is currently active.

        Prank,

        // A recurrent prank triggered by a `vm.startPrank()` call is currently active.

        RecurrentPrank

    }

    /// The kind of account access that occurred.

    enum AccountAccessKind {

        // The account was called.

        Call,

        // The account was called via delegatecall.

        DelegateCall,

        // The account was called via callcode.

        CallCode,

        // The account was called via staticcall.

        StaticCall,

        // The account was created.

        Create,

        // The account was selfdestructed.

        SelfDestruct,

        // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).

        Resume,

        // The account's balance was read.

        Balance,

        // The account's codesize was read.

        Extcodesize,

        // The account's codehash was read.

        Extcodehash,

        // The account's code was copied.

        Extcodecopy

    }

    /// Forge execution contexts.

    enum ForgeContext {

        // Test group execution context (test, coverage or snapshot).

        TestGroup,

        // `forge test` execution context.

        Test,

        // `forge coverage` execution context.

        Coverage,

        // `forge snapshot` execution context.

        Snapshot,

        // Script group execution context (dry run, broadcast or resume).

        ScriptGroup,

        // `forge script` execution context.

        ScriptDryRun,

        // `forge script --broadcast` execution context.

        ScriptBroadcast,

        // `forge script --resume` execution context.

        ScriptResume,

        // Unknown `forge` execution context.

        Unknown

    }

    /// The transaction type (`txType`) of the broadcast.

    enum BroadcastTxType {

        // Represents a CALL broadcast tx.

        Call,

        // Represents a CREATE broadcast tx.

        Create,

        // Represents a CREATE2 broadcast tx.

        Create2

    }

    /// An Ethereum log. Returned by `getRecordedLogs`.

    struct Log {

        // The topics of the log, including the signature, if any.

        bytes32[] topics;

        // The raw data of the log.

        bytes data;

        // The address of the log's emitter.

        address emitter;

    }

    /// An RPC URL and its alias. Returned by `rpcUrlStructs`.

    struct Rpc {

        // The alias of the RPC URL.

        string key;

        // The RPC URL.

        string url;

    }

    /// An RPC log object. Returned by `eth_getLogs`.

    struct EthGetLogs {

        // The address of the log's emitter.

        address emitter;

        // The topics of the log, including the signature, if any.

        bytes32[] topics;

        // The raw data of the log.

        bytes data;

        // The block hash.

        bytes32 blockHash;

        // The block number.

        uint64 blockNumber;

        // The transaction hash.

        bytes32 transactionHash;

        // The transaction index in the block.

        uint64 transactionIndex;

        // The log index.

        uint256 logIndex;

        // Whether the log was removed.

        bool removed;

    }

    /// A single entry in a directory listing. Returned by `readDir`.

    struct DirEntry {

        // The error message, if any.

        string errorMessage;

        // The path of the entry.

        string path;

        // The depth of the entry.

        uint64 depth;

        // Whether the entry is a directory.

        bool isDir;

        // Whether the entry is a symlink.

        bool isSymlink;

    }

    /// Metadata information about a file.

    /// This structure is returned from the `fsMetadata` function and represents known

    /// metadata about a file such as its permissions, size, modification

    /// times, etc.

    struct FsMetadata {

        // True if this metadata is for a directory.

        bool isDir;

        // True if this metadata is for a symlink.

        bool isSymlink;

        // The size of the file, in bytes, this metadata is for.

        uint256 length;

        // True if this metadata is for a readonly (unwritable) file.

        bool readOnly;

        // The last modification time listed in this metadata.

        uint256 modified;

        // The last access time of this metadata.

        uint256 accessed;

        // The creation time listed in this metadata.

        uint256 created;

    }

    /// A wallet with a public and private key.

    struct Wallet {

        // The wallet's address.

        address addr;

        // The wallet's public key `X`.

        uint256 publicKeyX;

        // The wallet's public key `Y`.

        uint256 publicKeyY;

        // The wallet's private key.

        uint256 privateKey;

    }

    /// The result of a `tryFfi` call.

    struct FfiResult {

        // The exit code of the call.

        int32 exitCode;

        // The optionally hex-decoded `stdout` data.

        bytes stdout;

        // The `stderr` data.

        bytes stderr;

    }

    /// Information on the chain and fork.

    struct ChainInfo {

        // The fork identifier. Set to zero if no fork is active.

        uint256 forkId;

        // The chain ID of the current fork.

        uint256 chainId;

    }

    /// Information about a blockchain.

    struct Chain {

        // The chain name.

        string name;

        // The chain's Chain ID.

        uint256 chainId;

        // The chain's alias. (i.e. what gets specified in `foundry.toml`).

        string chainAlias;

        // A default RPC endpoint for this chain.

        string rpcUrl;

    }

    /// The result of a `stopAndReturnStateDiff` call.

    struct AccountAccess {

        // The chain and fork the access occurred.

        ChainInfo chainInfo;

        // The kind of account access that determines what the account is.

        // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.

        // If kind is Create, then the account is the newly created account.

        // If kind is SelfDestruct, then the account is the selfdestruct recipient.

        // If kind is a Resume, then account represents a account context that has resumed.

        AccountAccessKind kind;

        // The account that was accessed.

        // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.

        address account;

        // What accessed the account.

        address accessor;

        // If the account was initialized or empty prior to the access.

        // An account is considered initialized if it has code, a

        // non-zero nonce, or a non-zero balance.

        bool initialized;

        // The previous balance of the accessed account.

        uint256 oldBalance;

        // The potential new balance of the accessed account.

        // That is, all balance changes are recorded here, even if reverts occurred.

        uint256 newBalance;

        // Code of the account deployed by CREATE.

        bytes deployedCode;

        // Value passed along with the account access

        uint256 value;

        // Input data provided to the CREATE or CALL

        bytes data;

        // If this access reverted in either the current or parent context.

        bool reverted;

        // An ordered list of storage accesses made during an account access operation.

        StorageAccess[] storageAccesses;

        // Call depth traversed during the recording of state differences

        uint64 depth;

    }

    /// The storage accessed during an `AccountAccess`.

    struct StorageAccess {

        // The account whose storage was accessed.

        address account;

        // The slot that was accessed.

        bytes32 slot;

        // If the access was a write.

        bool isWrite;

        // The previous value of the slot.

        bytes32 previousValue;

        // The new value of the slot.

        bytes32 newValue;

        // If the access was reverted.

        bool reverted;

    }

    /// Gas used. Returned by `lastCallGas`.

    struct Gas {

        // The gas limit of the call.

        uint64 gasLimit;

        // The total gas used.

        uint64 gasTotalUsed;

        // DEPRECATED: The amount of gas used for memory expansion. Ref: <https://github.com/foundry-rs/foundry/pull/7934#pullrequestreview-2069236939>

        uint64 gasMemoryUsed;

        // The amount of gas refunded.

        int64 gasRefunded;

        // The amount of gas remaining.

        uint64 gasRemaining;

    }

    /// The result of the `stopDebugTraceRecording` call

    struct DebugStep {

        // The stack before executing the step of the run.

        // stack\[0\] represents the top of the stack.

        // and only stack data relevant to the opcode execution is contained.

        uint256[] stack;

        // The memory input data before executing the step of the run.

        // only input data relevant to the opcode execution is contained.

        // e.g. for MLOAD, it will have memory\[offset:offset+32\] copied here.

        // the offset value can be get by the stack data.

        bytes memoryInput;

        // The opcode that was accessed.

        uint8 opcode;

        // The call depth of the step.

        uint64 depth;

        // Whether the call end up with out of gas error.

        bool isOutOfGas;

        // The contract address where the opcode is running

        address contractAddr;

    }

    /// Represents a transaction's broadcast details.

    struct BroadcastTxSummary {

        // The hash of the transaction that was broadcasted

        bytes32 txHash;

        // Represent the type of transaction among CALL, CREATE, CREATE2

        BroadcastTxType txType;

        // The address of the contract that was called or created.

        // This is address of the contract that is created if the txType is CREATE or CREATE2.

        address contractAddress;

        // The block number the transaction landed in.

        uint64 blockNumber;

        // Status of the transaction, retrieved from the transaction receipt.

        bool success;

    }

    /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.

    struct SignedDelegation {

        // The y-parity of the recovered secp256k1 signature (0 or 1).

        uint8 v;

        // First 32 bytes of the signature.

        bytes32 r;

        // Second 32 bytes of the signature.

        bytes32 s;

        // The current nonce of the authority account at signing time.

        // Used to ensure signature can't be replayed after account nonce changes.

        uint64 nonce;

        // Address of the contract implementation that will be delegated to.

        // Gets encoded into delegation code: 0xef0100 || implementation.

        address implementation;

    }

    /// Represents a "potential" revert reason from a single subsequent call when using `vm.assumeNoReverts`.

    /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced

    /// as normal.

    struct PotentialRevert {

        // The allowed origin of the revert opcode; address(0) allows reverts from any address

        address reverter;

        // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data

        bool partialMatch;

        // The data to use to match encountered reverts

        bytes revertData;

    }

    /// An EIP-2930 access list item.

    struct AccessListItem {

        // The address to be added in access list.

        address target;

        // The storage keys to be added in access list.

        bytes32[] storageKeys;

    }

    // ======== Crypto ========

    /// Derives a private key from the name, labels the account with that name, and returns the wallet.

    function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);

    /// Generates a wallet from the private key and returns the wallet.

    function createWallet(uint256 privateKey) external returns (Wallet memory wallet);

    /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.

    function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);

    /// Derive a private key from a provided mnenomic string (or mnenomic file path)

    /// at the derivation path `m/44'/60'/0'/0/{index}`.

    function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);

    /// Derive a private key from a provided mnenomic string (or mnenomic file path)

    /// at `{derivationPath}{index}`.

    function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)

        external

        pure

        returns (uint256 privateKey);

    /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language

    /// at the derivation path `m/44'/60'/0'/0/{index}`.

    function deriveKey(string calldata mnemonic, uint32 index, string calldata language)

        external

        pure

        returns (uint256 privateKey);

    /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language

    /// at `{derivationPath}{index}`.

    function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)

        external

        pure

        returns (uint256 privateKey);

    /// Derives secp256r1 public key from the provided `privateKey`.

    function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);

    /// Adds a private key to the local forge wallet and returns the address.

    function rememberKey(uint256 privateKey) external returns (address keyAddr);

    /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.

    /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.

    function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)

        external

        returns (address[] memory keyAddrs);

    /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.

    /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.

    function rememberKeys(

        string calldata mnemonic,

        string calldata derivationPath,

        string calldata language,

        uint32 count

    ) external returns (address[] memory keyAddrs);

    /// Signs data with a `Wallet`.

    /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the

    /// signature's `s` value, and the recovery id `v` in a single bytes32.

    /// This format reduces the signature size from 65 to 64 bytes.

    function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);

    /// Signs `digest` with `privateKey` using the secp256k1 curve.

    /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the

    /// signature's `s` value, and the recovery id `v` in a single bytes32.

    /// This format reduces the signature size from 65 to 64 bytes.

    function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);

    /// Signs `digest` with signer provided to script using the secp256k1 curve.

    /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the

    /// signature's `s` value, and the recovery id `v` in a single bytes32.

    /// This format reduces the signature size from 65 to 64 bytes.

    /// If `--sender` is provided, the signer with provided address is used, otherwise,

    /// if exactly one signer is provided to the script, that signer is used.

    /// Raises error if signer passed through `--sender` does not match any unlocked signers or

    /// if `--sender` is not provided and not exactly one signer is passed to the script.

    function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);

    /// Signs `digest` with signer provided to script using the secp256k1 curve.

    /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the

    /// signature's `s` value, and the recovery id `v` in a single bytes32.

    /// This format reduces the signature size from 65 to 64 bytes.

    /// Raises error if none of the signers passed into the script have provided address.

    function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);

    /// Signs `digest` with `privateKey` using the secp256r1 curve.

    function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);

    /// Signs data with a `Wallet`.

    function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);

    /// Signs `digest` with `privateKey` using the secp256k1 curve.

    function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);

    /// Signs `digest` with signer provided to script using the secp256k1 curve.

    /// If `--sender` is provided, the signer with provided address is used, otherwise,

    /// if exactly one signer is provided to the script, that signer is used.

    /// Raises error if signer passed through `--sender` does not match any unlocked signers or

    /// if `--sender` is not provided and not exactly one signer is passed to the script.

    function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);

    /// Signs `digest` with signer provided to script using the secp256k1 curve.

    /// Raises error if none of the signers passed into the script have provided address.

    function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);

    // ======== Environment ========

    /// Gets the environment variable `name` and parses it as `address`.

    /// Reverts if the variable was not found or could not be parsed.

    function envAddress(string calldata name) external view returns (address value);

    /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.

    /// Reverts if the variable was not found or could not be parsed.

    function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);

    /// Gets the environment variable `name` and parses it as `bool`.

    /// Reverts if the variable was not found or could not be parsed.

    function envBool(string calldata name) external view returns (bool value);

    /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.

    /// Reverts if the variable was not found or could not be parsed.

    function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);

    /// Gets the environment variable `name` and parses it as `bytes32`.

    /// Reverts if the variable was not found or could not be parsed.

    function envBytes32(string calldata name) external view returns (bytes32 value);

    /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.

    /// Reverts if the variable was not found or could not be parsed.

    function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);

    /// Gets the environment variable `name` and parses it as `bytes`.

    /// Reverts if the variable was not found or could not be parsed.

    function envBytes(string calldata name) external view returns (bytes memory value);

    /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.

    /// Reverts if the variable was not found or could not be parsed.

    function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);

    /// Gets the environment variable `name` and returns true if it exists, else returns false.

    function envExists(string calldata name) external view returns (bool result);

    /// Gets the environment variable `name` and parses it as `int256`.

    /// Reverts if the variable was not found or could not be parsed.

    function envInt(string calldata name) external view returns (int256 value);

    /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.

    /// Reverts if the variable was not found or could not be parsed.

    function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);

    /// Gets the environment variable `name` and parses it as `bool`.

    /// Reverts if the variable could not be parsed.

    /// Returns `defaultValue` if the variable was not found.

    function envOr(string calldata name, bool defaultValue) external view returns (bool value);

    /// Gets the environment variable `name` and parses it as `uint256`.

    /// Reverts if the variable could not be parsed.

    /// Returns `defaultValue` if the variable was not found.

    function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);

    /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.

    /// Reverts if the variable could not be parsed.

    /// Returns `defaultValue` if the variable was not found.

    function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)

        external

        view

        returns (address[] memory value);

    /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.

    /// Reverts if the variable could not be parsed.

    /// Returns `defaultValue` if the variable was not found.

    function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)

        external

        view

        returns (bytes32[] memory value);

    /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.

    /// Reverts if the variable could not be parsed.

    /// Returns `defaultValue` if the variable was not found.

    function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)

        external

        view

        returns (string[] memory value);

    /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.

    /// Reverts if the variable could not be parsed.

    /// Returns `defaultValue` if the variable was not found.

    function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)

        external

        view

        returns (bytes[] memory value);

    /// Gets the environment variable `name` and parses it as `int256`.

    /// Reverts if the variable could not be parsed.

    /// Returns `defaultValue` if the variable was not found.

    function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);

    /// Gets the environment variable `name` and parses it as `address`.

    /// Reverts if the variable could not be parsed.

    /// Returns `defaultValue` if the variable was not found.

    function envOr(string calldata name, address defaultValue) external view returns (address value);

    /// Gets the environment variable `name` and parses it as `bytes32`.

    /// Reverts if the variable could not be parsed.

    /// Returns `defaultValue` if the variable was not found.

    function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);

    /// Gets the environment variable `name` and parses it as `string`.

    /// Reverts if the variable could not be parsed.

    /// Returns `defaultValue` if the variable was not found.

    function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);

    /// Gets the environment variable `name` and parses it as `bytes`.

    /// Reverts if the variable could not be parsed.

    /// Returns `defaultValue` if the variable was not found.

    function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);

    /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.

    /// Reverts if the variable could not be parsed.

    /// Returns `defaultValue` if the variable was not found.

    function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)

        external

        view

        returns (bool[] memory value);

    /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.

    /// Reverts if the variable could not be parsed.

    /// Returns `defaultValue` if the variable was not found.

    function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)

        external

        view

        returns (uint256[] memory value);

    /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.

    /// Reverts if the variable could not be parsed.

    /// Returns `defaultValue` if the variable was not found.

    function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)

        external

        view

        returns (int256[] memory value);

    /// Gets the environment variable `name` and parses it as `string`.

    /// Reverts if the variable was not found or could not be parsed.

    function envString(string calldata name) external view returns (string memory value);

    /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.

    /// Reverts if the variable was not found or could not be parsed.

    function envString(string calldata name, string calldata delim) external view returns (string[] memory value);

    /// Gets the environment variable `name` and parses it as `uint256`.

    /// Reverts if the variable was not found or could not be parsed.

    function envUint(string calldata name) external view returns (uint256 value);

    /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.

    /// Reverts if the variable was not found or could not be parsed.

    function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);

    /// Returns true if `forge` command was executed in given context.

    function isContext(ForgeContext context) external view returns (bool result);

    /// Sets environment variables.

    function setEnv(string calldata name, string calldata value) external;

    // ======== EVM ========

    /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.

    function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);

    /// Gets the address for a given private key.

    function addr(uint256 privateKey) external pure returns (address keyAddr);

    /// Gets all the logs according to specified filter.

    function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)

        external

        returns (EthGetLogs[] memory logs);

    /// Gets the current `block.blobbasefee`.

    /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,

    /// and as a result will get optimized out by the compiler.

    /// See https://github.com/foundry-rs/foundry/issues/6180

    function getBlobBaseFee() external view returns (uint256 blobBaseFee);

    /// Gets the current `block.number`.

    /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,

    /// and as a result will get optimized out by the compiler.

    /// See https://github.com/foundry-rs/foundry/issues/6180

    function getBlockNumber() external view returns (uint256 height);

    /// Gets the current `block.timestamp`.

    /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,

    /// and as a result will get optimized out by the compiler.

    /// See https://github.com/foundry-rs/foundry/issues/6180

    function getBlockTimestamp() external view returns (uint256 timestamp);

    /// Gets the map key and parent of a mapping at a given slot, for a given address.

    function getMappingKeyAndParentOf(address target, bytes32 elementSlot)

        external

        returns (bool found, bytes32 key, bytes32 parent);

    /// Gets the number of elements in the mapping at the given slot, for a given address.

    function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);

    /// Gets the elements at index idx of the mapping at the given slot, for a given address. The

    /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).

    function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);

    /// Gets the nonce of an account.

    function getNonce(address account) external view returns (uint64 nonce);

    /// Get the nonce of a `Wallet`.

    function getNonce(Wallet calldata wallet) external returns (uint64 nonce);

    /// Gets all the recorded logs.

    function getRecordedLogs() external returns (Log[] memory logs);

    /// Returns state diffs from current `vm.startStateDiffRecording` session.

    function getStateDiff() external view returns (string memory diff);

    /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.

    function getStateDiffJson() external view returns (string memory diff);

    /// Gets the gas used in the last call from the callee perspective.

    function lastCallGas() external view returns (Gas memory gas);

    /// Loads a storage slot from an address.

    function load(address target, bytes32 slot) external view returns (bytes32 data);

    /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.

    function pauseGasMetering() external;

    /// Records all storage reads and writes. Use `accesses` to get the recorded data.

    /// Subsequent calls to `record` will clear the previous data.

    function record() external;

    /// Record all the transaction logs.

    function recordLogs() external;

    /// Reset gas metering (i.e. gas usage is set to gas limit).

    function resetGasMetering() external;

    /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.

    function resumeGasMetering() external;

    /// Performs an Ethereum JSON-RPC request to the current fork URL.

    function rpc(string calldata method, string calldata params) external returns (bytes memory data);

    /// Performs an Ethereum JSON-RPC request to the given endpoint.

    function rpc(string calldata urlOrAlias, string calldata method, string calldata params)

        external

        returns (bytes memory data);

    /// Records the debug trace during the run.

    function startDebugTraceRecording() external;

    /// Starts recording all map SSTOREs for later retrieval.

    function startMappingRecording() external;

    /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,

    /// along with the context of the calls

    function startStateDiffRecording() external;

    /// Stop debug trace recording and returns the recorded debug trace.

    function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);

    /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.

    function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);

    /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.

    function stopMappingRecording() external;

    /// Stops recording storage reads and writes.

    function stopRecord() external;

    // ======== Filesystem ========

    /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.

    /// `path` is relative to the project root.

    function closeFile(string calldata path) external;

    /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.

    /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.

    /// Both `from` and `to` are relative to the project root.

    function copyFile(string calldata from, string calldata to) external returns (uint64 copied);

    /// Creates a new, empty directory at the provided path.

    /// This cheatcode will revert in the following situations, but is not limited to just these cases:

    /// - User lacks permissions to modify `path`.

    /// - A parent of the given path doesn't exist and `recursive` is false.

    /// - `path` already exists and `recursive` is false.

    /// `path` is relative to the project root.

    function createDir(string calldata path, bool recursive) external;

    /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the

    /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.

    function deployCode(string calldata artifactPath) external returns (address deployedAddress);

    /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the

    /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.

    /// Additionally accepts abi-encoded constructor arguments.

    function deployCode(string calldata artifactPath, bytes calldata constructorArgs)

        external

        returns (address deployedAddress);

    /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the

    /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.

    /// Additionally accepts `msg.value`.

    function deployCode(string calldata artifactPath, uint256 value) external returns (address deployedAddress);

    /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the

    /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.

    /// Additionally accepts abi-encoded constructor arguments and `msg.value`.

    function deployCode(string calldata artifactPath, bytes calldata constructorArgs, uint256 value)

        external

        returns (address deployedAddress);

    /// Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the

    /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.

    function deployCode(string calldata artifactPath, bytes32 salt) external returns (address deployedAddress);

    /// Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the

    /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.

    /// Additionally accepts abi-encoded constructor arguments.

    function deployCode(string calldata artifactPath, bytes calldata constructorArgs, bytes32 salt)

        external

        returns (address deployedAddress);

    /// Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the

    /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.

    /// Additionally accepts `msg.value`.

    function deployCode(string calldata artifactPath, uint256 value, bytes32 salt)

        external

        returns (address deployedAddress);

    /// Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the

    /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.

    /// Additionally accepts abi-encoded constructor arguments and `msg.value`.

    function deployCode(string calldata artifactPath, bytes calldata constructorArgs, uint256 value, bytes32 salt)

        external

        returns (address deployedAddress);

    /// Returns true if the given path points to an existing entity, else returns false.

    function exists(string calldata path) external view returns (bool result);

    /// Performs a foreign function call via the terminal.

    function ffi(string[] calldata commandInput) external returns (bytes memory result);

    /// Given a path, query the file system to get information about a file, directory, etc.

    function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);

    /// Gets the artifact path from code (aka. creation code).

    function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);

    /// Gets the artifact path from deployed code (aka. runtime code).

    function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);

    /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.

    /// For example:

    /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.

    /// The most recent call can be fetched by passing `txType` as `CALL`.

    function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)

        external

        view

        returns (BroadcastTxSummary memory);

    /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.

    /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.

    function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)

        external

        view

        returns (BroadcastTxSummary[] memory);

    /// Returns all broadcasts for the given contract on `chainId`.

    /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.

    function getBroadcasts(string calldata contractName, uint64 chainId)

        external

        view

        returns (BroadcastTxSummary[] memory);

    /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the

    /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.

    function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);

    /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the

    /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.

    function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);

    /// Returns the most recent deployment for the current `chainId`.

    function getDeployment(string calldata contractName) external view returns (address deployedAddress);

    /// Returns the most recent deployment for the given contract on `chainId`

    function getDeployment(string calldata contractName, uint64 chainId)

        external

        view

        returns (address deployedAddress);

    /// Returns all deployments for the given contract on `chainId`

    /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.

    /// The most recent deployment is the first element, and the oldest is the last.

    function getDeployments(string calldata contractName, uint64 chainId)

        external

        view

        returns (address[] memory deployedAddresses);

    /// Returns true if the path exists on disk and is pointing at a directory, else returns false.

    function isDir(string calldata path) external view returns (bool result);

    /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.

    function isFile(string calldata path) external view returns (bool result);

    /// Get the path of the current project root.

    function projectRoot() external view returns (string memory path);

    /// Prompts the user for a string value in the terminal.

    function prompt(string calldata promptText) external returns (string memory input);

    /// Prompts the user for an address in the terminal.

    function promptAddress(string calldata promptText) external returns (address);

    /// Prompts the user for a hidden string value in the terminal.

    function promptSecret(string calldata promptText) external returns (string memory input);

    /// Prompts the user for hidden uint256 in the terminal (usually pk).

    function promptSecretUint(string calldata promptText) external returns (uint256);

    /// Prompts the user for uint256 in the terminal.

    function promptUint(string calldata promptText) external returns (uint256);

    /// Reads the directory at the given path recursively, up to `maxDepth`.

    /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.

    /// Follows symbolic links if `followLinks` is true.

    function readDir(string calldata path) external view returns (DirEntry[] memory entries);

    /// See `readDir(string)`.

    function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);

    /// See `readDir(string)`.

    function readDir(string calldata path, uint64 maxDepth, bool followLinks)

        external

        view

        returns (DirEntry[] memory entries);

    /// Reads the entire content of file to string. `path` is relative to the project root.

    function readFile(string calldata path) external view returns (string memory data);

    /// Reads the entire content of file as binary. `path` is relative to the project root.

    function readFileBinary(string calldata path) external view returns (bytes memory data);

    /// Reads next line of file to string.

    function readLine(string calldata path) external view returns (string memory line);

    /// Reads a symbolic link, returning the path that the link points to.

    /// This cheatcode will revert in the following situations, but is not limited to just these cases:

    /// - `path` is not a symbolic link.

    /// - `path` does not exist.

    function readLink(string calldata linkPath) external view returns (string memory targetPath);

    /// Removes a directory at the provided path.

    /// This cheatcode will revert in the following situations, but is not limited to just these cases:

    /// - `path` doesn't exist.

    /// - `path` isn't a directory.

    /// - User lacks permissions to modify `path`.

    /// - The directory is not empty and `recursive` is false.

    /// `path` is relative to the project root.

    function removeDir(string calldata path, bool recursive) external;

    /// Removes a file from the filesystem.

    /// This cheatcode will revert in the following situations, but is not limited to just these cases:

    /// - `path` points to a directory.

    /// - The file doesn't exist.

    /// - The user lacks permissions to remove the file.

    /// `path` is relative to the project root.

    function removeFile(string calldata path) external;

    /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.

    function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);

    /// Returns the time since unix epoch in milliseconds.

    function unixTime() external view returns (uint256 milliseconds);

    /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.

    /// `path` is relative to the project root.

    function writeFile(string calldata path, string calldata data) external;

    /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.

    /// `path` is relative to the project root.

    function writeFileBinary(string calldata path, bytes calldata data) external;

    /// Writes line to file, creating a file if it does not exist.

    /// `path` is relative to the project root.

    function writeLine(string calldata path, string calldata data) external;

    // ======== JSON ========

    /// Checks if `key` exists in a JSON object.

    function keyExistsJson(string calldata json, string calldata key) external view returns (bool);

    /// Parses a string of JSON data at `key` and coerces it to `address`.

    function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);

    /// Parses a string of JSON data at `key` and coerces it to `address[]`.

    function parseJsonAddressArray(string calldata json, string calldata key)

        external

        pure

        returns (address[] memory);

    /// Parses a string of JSON data at `key` and coerces it to `bool`.

    function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);

    /// Parses a string of JSON data at `key` and coerces it to `bool[]`.

    function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);

    /// Parses a string of JSON data at `key` and coerces it to `bytes`.

    function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);

    /// Parses a string of JSON data at `key` and coerces it to `bytes32`.

    function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);

    /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.

    function parseJsonBytes32Array(string calldata json, string calldata key)

        external

        pure

        returns (bytes32[] memory);

    /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.

    function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);

    /// Parses a string of JSON data at `key` and coerces it to `int256`.

    function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);

    /// Parses a string of JSON data at `key` and coerces it to `int256[]`.

    function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);

    /// Returns an array of all the keys in a JSON object.

    function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);

    /// Parses a string of JSON data at `key` and coerces it to `string`.

    function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);

    /// Parses a string of JSON data at `key` and coerces it to `string[]`.

    function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);

    /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.

    function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)

        external

        pure

        returns (bytes memory);

    /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.

    function parseJsonType(string calldata json, string calldata typeDescription)

        external

        pure

        returns (bytes memory);

    /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.

    function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)

        external

        pure

        returns (bytes memory);

    /// Parses a string of JSON data at `key` and coerces it to `uint256`.

    function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);

    /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.

    function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);

    /// ABI-encodes a JSON object.

    function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);

    /// ABI-encodes a JSON object at `key`.

    function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);

    /// See `serializeJson`.

    function serializeAddress(string calldata objectKey, string calldata valueKey, address value)

        external

        returns (string memory json);

    /// See `serializeJson`.

    function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)

        external

        returns (string memory json);

    /// See `serializeJson`.

    function serializeBool(string calldata objectKey, string calldata valueKey, bool value)

        external

        returns (string memory json);

    /// See `serializeJson`.

    function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)

        external

        returns (string memory json);

    /// See `serializeJson`.

    function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)

        external

        returns (string memory json);

    /// See `serializeJson`.

    function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)

        external

        returns (string memory json);

    /// See `serializeJson`.

    function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)

        external

        returns (string memory json);

    /// See `serializeJson`.

    function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)

        external

        returns (string memory json);

    /// See `serializeJson`.

    function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)

        external

        returns (string memory json);

    /// See `serializeJson`.

    function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)

        external

        returns (string memory json);

    /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.

    /// Returns the stringified version of the specific JSON file up to that moment.

    function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);

    /// See `serializeJson`.

    function serializeJsonType(string calldata typeDescription, bytes calldata value)

        external

        pure

        returns (string memory json);

    /// See `serializeJson`.

    function serializeJsonType(

        string calldata objectKey,

        string calldata valueKey,

        string calldata typeDescription,

        bytes calldata value

    ) external returns (string memory json);

    /// See `serializeJson`.

    function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)

        external

        returns (string memory json);

    /// See `serializeJson`.

    function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)

        external

        returns (string memory json);

    /// See `serializeJson`.

    function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)

        external

        returns (string memory json);

    /// See `serializeJson`.

    function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)

        external

        returns (string memory json);

    /// See `serializeJson`.

    function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)

        external

        returns (string memory json);

    /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.

    function writeJson(string calldata json, string calldata path) external;

    /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = <value_key.>

    /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.

    function writeJson(string calldata json, string calldata path, string calldata valueKey) external;

    /// Checks if `key` exists in a JSON object

    /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.

    function keyExists(string calldata json, string calldata key) external view returns (bool);

    // ======== Scripting ========

    /// Attach an EIP-4844 blob to the next call

    function attachBlob(bytes calldata blob) external;

    /// Designate the next call as an EIP-7702 transaction

    function attachDelegation(SignedDelegation calldata signedDelegation) external;

    /// Designate the next call as an EIP-7702 transaction, with optional cross-chain validity.

    function attachDelegation(SignedDelegation calldata signedDelegation, bool crossChain) external;

    /// Takes a signed transaction and broadcasts it to the network.

    function broadcastRawTransaction(bytes calldata data) external;

    /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.

    /// Broadcasting address is determined by checking the following in order:

    /// 1. If `--sender` argument was provided, that address is used.

    /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.

    /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.

    function broadcast() external;

    /// Has the next call (at this call depth only) create a transaction with the address provided

    /// as the sender that can later be signed and sent onchain.

    function broadcast(address signer) external;

    /// Has the next call (at this call depth only) create a transaction with the private key

    /// provided as the sender that can later be signed and sent onchain.

    function broadcast(uint256 privateKey) external;

    /// Returns addresses of available unlocked wallets in the script environment.

    function getWallets() external returns (address[] memory wallets);

    /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction

    function signAndAttachDelegation(address implementation, uint256 privateKey)

        external

        returns (SignedDelegation memory signedDelegation);

    /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction for specific nonce

    function signAndAttachDelegation(address implementation, uint256 privateKey, uint64 nonce)

        external

        returns (SignedDelegation memory signedDelegation);

    /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction, with optional cross-chain validity.

    function signAndAttachDelegation(address implementation, uint256 privateKey, bool crossChain)

        external

        returns (SignedDelegation memory signedDelegation);

    /// Sign an EIP-7702 authorization for delegation

    function signDelegation(address implementation, uint256 privateKey)

        external

        returns (SignedDelegation memory signedDelegation);

    /// Sign an EIP-7702 authorization for delegation for specific nonce

    function signDelegation(address implementation, uint256 privateKey, uint64 nonce)

        external

        returns (SignedDelegation memory signedDelegation);

    /// Sign an EIP-7702 authorization for delegation, with optional cross-chain validity.

    function signDelegation(address implementation, uint256 privateKey, bool crossChain)

        external

        returns (SignedDelegation memory signedDelegation);

    /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.

    /// Broadcasting address is determined by checking the following in order:

    /// 1. If `--sender` argument was provided, that address is used.

    /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.

    /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.

    function startBroadcast() external;

    /// Has all subsequent calls (at this call depth only) create transactions with the address

    /// provided that can later be signed and sent onchain.

    function startBroadcast(address signer) external;

    /// Has all subsequent calls (at this call depth only) create transactions with the private key

    /// provided that can later be signed and sent onchain.

    function startBroadcast(uint256 privateKey) external;

    /// Stops collecting onchain transactions.

    function stopBroadcast() external;

    // ======== String ========

    /// Returns true if `search` is found in `subject`, false otherwise.

    function contains(string calldata subject, string calldata search) external returns (bool result);

    /// Returns the index of the first occurrence of a `key` in an `input` string.

    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.

    /// Returns 0 in case of an empty `key`.

    function indexOf(string calldata input, string calldata key) external pure returns (uint256);

    /// Parses the given `string` into an `address`.

    function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);

    /// Parses the given `string` into a `bool`.

    function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);

    /// Parses the given `string` into `bytes`.

    function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);

    /// Parses the given `string` into a `bytes32`.

    function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);

    /// Parses the given `string` into a `int256`.

    function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);

    /// Parses the given `string` into a `uint256`.

    function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);

    /// Replaces occurrences of `from` in the given `string` with `to`.

    function replace(string calldata input, string calldata from, string calldata to)

        external

        pure

        returns (string memory output);

    /// Splits the given `string` into an array of strings divided by the `delimiter`.

    function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);

    /// Converts the given `string` value to Lowercase.

    function toLowercase(string calldata input) external pure returns (string memory output);

    /// Converts the given value to a `string`.

    function toString(address value) external pure returns (string memory stringifiedValue);

    /// Converts the given value to a `string`.

    function toString(bytes calldata value) external pure returns (string memory stringifiedValue);

    /// Converts the given value to a `string`.

    function toString(bytes32 value) external pure returns (string memory stringifiedValue);

    /// Converts the given value to a `string`.

    function toString(bool value) external pure returns (string memory stringifiedValue);

    /// Converts the given value to a `string`.

    function toString(uint256 value) external pure returns (string memory stringifiedValue);

    /// Converts the given value to a `string`.

    function toString(int256 value) external pure returns (string memory stringifiedValue);

    /// Converts the given `string` value to Uppercase.

    function toUppercase(string calldata input) external pure returns (string memory output);

    /// Trims leading and trailing whitespace from the given `string` value.

    function trim(string calldata input) external pure returns (string memory output);

    // ======== Testing ========

    /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.

    /// Formats values with decimals in failure message.

    function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;

    /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.

    /// Formats values with decimals in failure message. Includes error message into revert string on failure.

    function assertApproxEqAbsDecimal(

        uint256 left,

        uint256 right,

        uint256 maxDelta,

        uint256 decimals,

        string calldata error

    ) external pure;

    /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.

    /// Formats values with decimals in failure message.

    function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;

    /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.

    /// Formats values with decimals in failure message. Includes error message into revert string on failure.

    function assertApproxEqAbsDecimal(

        int256 left,

        int256 right,

        uint256 maxDelta,

        uint256 decimals,

        string calldata error

    ) external pure;

    /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.

    function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;

    /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.

    /// Includes error message into revert string on failure.

    function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;

    /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.

    function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;

    /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.

    /// Includes error message into revert string on failure.

    function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;

    /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.

    /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%

    /// Formats values with decimals in failure message.

    function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)

        external

        pure;

    /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.

    /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%

    /// Formats values with decimals in failure message. Includes error message into revert string on failure.

    function assertApproxEqRelDecimal(

        uint256 left,

        uint256 right,

        uint256 maxPercentDelta,

        uint256 decimals,

        string calldata error

    ) external pure;

    /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.

    /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%

    /// Formats values with decimals in failure message.

    function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)

        external

        pure;

    /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.

    /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%

    /// Formats values with decimals in failure message. Includes error message into revert string on failure.

    function assertApproxEqRelDecimal(

        int256 left,

        int256 right,

        uint256 maxPercentDelta,

        uint256 decimals,

        string calldata error

    ) external pure;

    /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.

    /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%

    function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;

    /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.

    /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%

    /// Includes error message into revert string on failure.

    function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)

        external

        pure;

    /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.

    /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%

    function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;

    /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.

    /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%

    /// Includes error message into revert string on failure.

    function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error)

        external

        pure;

    /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.

    function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;

    /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.

    /// Includes error message into revert string on failure.

    function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;

    /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.

    function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;

    /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.

    /// Includes error message into revert string on failure.

    function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;

    /// Asserts that two `bool` values are equal.

    function assertEq(bool left, bool right) external pure;

    /// Asserts that two `bool` values are equal and includes error message into revert string on failure.

    function assertEq(bool left, bool right, string calldata error) external pure;

    /// Asserts that two `string` values are equal.

    function assertEq(string calldata left, string calldata right) external pure;

    /// Asserts that two `string` values are equal and includes error message into revert string on failure.

    function assertEq(string calldata left, string calldata right, string calldata error) external pure;

    /// Asserts that two `bytes` values are equal.

    function assertEq(bytes calldata left, bytes calldata right) external pure;

    /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.

    function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;

    /// Asserts that two arrays of `bool` values are equal.

    function assertEq(bool[] calldata left, bool[] calldata right) external pure;

    /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.

    function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;

    /// Asserts that two arrays of `uint256 values are equal.

    function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;

    /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.

    function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;

    /// Asserts that two arrays of `int256` values are equal.

    function assertEq(int256[] calldata left, int256[] calldata right) external pure;

    /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.

    function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;

    /// Asserts that two `uint256` values are equal.

    function assertEq(uint256 left, uint256 right) external pure;

    /// Asserts that two arrays of `address` values are equal.

    function assertEq(address[] calldata left, address[] calldata right) external pure;

    /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.

    function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;

    /// Asserts that two arrays of `bytes32` values are equal.

    function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;

    /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.

    function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;

    /// Asserts that two arrays of `string` values are equal.

    function assertEq(string[] calldata left, string[] calldata right) external pure;

    /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.

    function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;

    /// Asserts that two arrays of `bytes` values are equal.

    function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;

    /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.

    function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;

    /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.

    function assertEq(uint256 left, uint256 right, string calldata error) external pure;

    /// Asserts that two `int256` values are equal.

    function assertEq(int256 left, int256 right) external pure;

    /// Asserts that two `int256` values are equal and includes error message into revert string on failure.

    function assertEq(int256 left, int256 right, string calldata error) external pure;

    /// Asserts that two `address` values are equal.

    function assertEq(address left, address right) external pure;

    /// Asserts that two `address` values are equal and includes error message into revert string on failure.

    function assertEq(address left, address right, string calldata error) external pure;

    /// Asserts that two `bytes32` values are equal.

    function assertEq(bytes32 left, bytes32 right) external pure;

    /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.

    function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;

    /// Asserts that the given condition is false.

    function assertFalse(bool condition) external pure;

    /// Asserts that the given condition is false and includes error message into revert string on failure.

    function assertFalse(bool condition, string calldata error) external pure;

    /// Compares two `uint256` values. Expects first value to be greater than or equal to second.

    /// Formats values with decimals in failure message.

    function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;

    /// Compares two `uint256` values. Expects first value to be greater than or equal to second.

    /// Formats values with decimals in failure message. Includes error message into revert string on failure.

    function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;

    /// Compares two `int256` values. Expects first value to be greater than or equal to second.

    /// Formats values with decimals in failure message.

    function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;

    /// Compares two `int256` values. Expects first value to be greater than or equal to second.

    /// Formats values with decimals in failure message. Includes error message into revert string on failure.

    function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;

    /// Compares two `uint256` values. Expects first value to be greater than or equal to second.

    function assertGe(uint256 left, uint256 right) external pure;

    /// Compares two `uint256` values. Expects first value to be greater than or equal to second.

    /// Includes error message into revert string on failure.

    function assertGe(uint256 left, uint256 right, string calldata error) external pure;

    /// Compares two `int256` values. Expects first value to be greater than or equal to second.

    function assertGe(int256 left, int256 right) external pure;

    /// Compares two `int256` values. Expects first value to be greater than or equal to second.

    /// Includes error message into revert string on failure.

    function assertGe(int256 left, int256 right, string calldata error) external pure;

    /// Compares two `uint256` values. Expects first value to be greater than second.

    /// Formats values with decimals in failure message.

    function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;

    /// Compares two `uint256` values. Expects first value to be greater than second.

    /// Formats values with decimals in failure message. Includes error message into revert string on failure.

    function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;

    /// Compares two `int256` values. Expects first value to be greater than second.

    /// Formats values with decimals in failure message.

    function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;

    /// Compares two `int256` values. Expects first value to be greater than second.

    /// Formats values with decimals in failure message. Includes error message into revert string on failure.

    function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;

    /// Compares two `uint256` values. Expects first value to be greater than second.

    function assertGt(uint256 left, uint256 right) external pure;

    /// Compares two `uint256` values. Expects first value to be greater than second.

    /// Includes error message into revert string on failure.

    function assertGt(uint256 left, uint256 right, string calldata error) external pure;

    /// Compares two `int256` values. Expects first value to be greater than second.

    function assertGt(int256 left, int256 right) external pure;

    /// Compares two `int256` values. Expects first value to be greater than second.

    /// Includes error message into revert string on failure.

    function assertGt(int256 left, int256 right, string calldata error) external pure;

    /// Compares two `uint256` values. Expects first value to be less than or equal to second.

    /// Formats values with decimals in failure message.

    function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;

    /// Compares two `uint256` values. Expects first value to be less than or equal to second.

    /// Formats values with decimals in failure message. Includes error message into revert string on failure.

    function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;

    /// Compares two `int256` values. Expects first value to be less than or equal to second.

    /// Formats values with decimals in failure message.

    function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;

    /// Compares two `int256` values. Expects first value to be less than or equal to second.

    /// Formats values with decimals in failure message. Includes error message into revert string on failure.

    function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;

    /// Compares two `uint256` values. Expects first value to be less than or equal to second.

    function assertLe(uint256 left, uint256 right) external pure;

    /// Compares two `uint256` values. Expects first value to be less than or equal to second.

    /// Includes error message into revert string on failure.

    function assertLe(uint256 left, uint256 right, string calldata error) external pure;

    /// Compares two `int256` values. Expects first value to be less than or equal to second.

    function assertLe(int256 left, int256 right) external pure;

    /// Compares two `int256` values. Expects first value to be less than or equal to second.

    /// Includes error message into revert string on failure.

    function assertLe(int256 left, int256 right, string calldata error) external pure;

    /// Compares two `uint256` values. Expects first value to be less than second.

    /// Formats values with decimals in failure message.

    function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;

    /// Compares two `uint256` values. Expects first value to be less than second.

    /// Formats values with decimals in failure message. Includes error message into revert string on failure.

    function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;

    /// Compares two `int256` values. Expects first value to be less than second.

    /// Formats values with decimals in failure message.

    function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;

    /// Compares two `int256` values. Expects first value to be less than second.

    /// Formats values with decimals in failure message. Includes error message into revert string on failure.

    function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;

    /// Compares two `uint256` values. Expects first value to be less than second.

    function assertLt(uint256 left, uint256 right) external pure;

    /// Compares two `uint256` values. Expects first value to be less than second.

    /// Includes error message into revert string on failure.

    function assertLt(uint256 left, uint256 right, string calldata error) external pure;

    /// Compares two `int256` values. Expects first value to be less than second.

    function assertLt(int256 left, int256 right) external pure;

    /// Compares two `int256` values. Expects first value to be less than second.

    /// Includes error message into revert string on failure.

    function assertLt(int256 left, int256 right, string calldata error) external pure;

    /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.

    function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;

    /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.

    /// Includes error message into revert string on failure.

    function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;

    /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.

    function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;

    /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.

    /// Includes error message into revert string on failure.

    function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;