type ApiRequestOptions = {
    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
    readonly url: string;
    readonly path?: Record<string, any>;
    readonly cookies?: Record<string, any>;
    readonly headers?: Record<string, any>;
    readonly query?: Record<string, any>;
    readonly formData?: Record<string, any>;
    readonly body?: any;
    readonly mediaType?: string;
    readonly responseHeader?: string;
    readonly errors?: Record<number, string>;
};

type ApiResult = {
    readonly url: string;
    readonly ok: boolean;
    readonly status: number;
    readonly statusText: string;
    readonly body: any;
};

declare class ApiError extends Error {
    readonly url: string;
    readonly status: number;
    readonly statusText: string;
    readonly body: any;
    readonly request: ApiRequestOptions;
    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
}

declare class CancelError extends Error {
    constructor(message: string);
    get isCancelled(): boolean;
}
interface OnCancel {
    readonly isResolved: boolean;
    readonly isRejected: boolean;
    readonly isCancelled: boolean;
    (cancelHandler: () => void): void;
}
declare class CancelablePromise<T> implements Promise<T> {
    #private;
    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
    get [Symbol.toStringTag](): string;
    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
    finally(onFinally?: (() => void) | null): Promise<T>;
    cancel(): void;
    get isCancelled(): boolean;
}

type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
type Headers = Record<string, string>;
type OpenAPIConfig = {
    BASE: string;
    VERSION: string;
    WITH_CREDENTIALS: boolean;
    CREDENTIALS: 'include' | 'omit' | 'same-origin';
    TOKEN?: string | Resolver<string> | undefined;
    USERNAME?: string | Resolver<string> | undefined;
    PASSWORD?: string | Resolver<string> | undefined;
    HEADERS?: Headers | Resolver<Headers> | undefined;
    ENCODE_PATH?: ((path: string) => string) | undefined;
};
declare const OpenAPI: OpenAPIConfig;

type AnyInputQuoteWithdrawal = {
    /**
     * Withdrawal status
     */
    status: AnyInputQuoteWithdrawal.status;
    /**
     * Amount out in readable format
     */
    amountOutFormatted: string;
    /**
     * Amount out in USD
     */
    amountOutUsd: string;
    /**
     * Amount out in smallest unit
     */
    amountOut: string;
    /**
     * Withdrawal fee in readable format
     */
    withdrawFeeFormatted: string;
    /**
     * Withdrawal fee in smallest unit
     */
    withdrawFee: string;
    /**
     * Withdrawal fee in USD
     */
    withdrawFeeUsd: string;
    /**
     * Timestamp of withdrawal
     */
    timestamp: string;
    /**
     * Transaction hash
     */
    hash: string;
};
declare namespace AnyInputQuoteWithdrawal {
    /**
     * Withdrawal status
     */
    enum status {
        SUCCESS = "SUCCESS",
        FAILED = "FAILED"
    }
}

type AppFee = {
    /**
     * Account ID within Intents to which this fee will be transferred
     */
    recipient: string;
    /**
     * Fee for this recipient as part of amountIn in basis points (1/100th of a percent), e.g. 100 for 1% fee
     */
    fee: number;
};

/**
 * Call [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) with `signer_id` of intent.
 */
type AuthCall = {
    /**
     * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
     *
     * NOTE: the `wNEAR` will not be refunded in case of fail.
     */
    attached_deposit?: string;
    /**
     * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
     */
    contract_id: string;
    /**
     * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
     *
     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
     */
    min_gas?: string | null;
    /**
     * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
     */
    msg: string;
    /**
     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
     */
    state_init?: {
        code: ({
            hash: string;
        } | {
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            account_id: string;
        });
        data: Record<string, string>;
        version: AuthCall.version;
    } | null;
};
declare namespace AuthCall {
    enum version {
        V1 = "v1"
    }
}

/**
 * Assuming wallets want to interact with Intents protocol, besides preparing the data in a certain form, they have to have the capability to sign raw messages (off-chain signatures) using an algorithm we understand. This enum solves that problem.
 *
 * For example, because we support ERC-191 and know how to verify messages with that standard, we can allow wallets, like Metamask, sign messages to perform intents without having to support new cryptographic primitives and signing standards.
 */
type MultiPayload = ({
    /**
     * See [NEP-413](https://github.com/near/NEPs/blob/master/neps/nep-0413.md)
     */
    payload: {
        callbackUrl?: string | null;
        message: string;
        /**
         * Encoding: base64
         */
        nonce: string;
        recipient: string;
    };
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
    standard: MultiPayload.standard;
} | {
    /**
     * See [ERC-191](https://github.com/ethereum/ercs/blob/master/ERCS/erc-191.md)
     */
    payload: string;
    /**
     * There is no public key member because the public key can be recovered via `ecrecover()` knowing the data and the signature. Encoding: base58
     */
    signature: string;
    standard: MultiPayload.standard;
} | {
    /**
     * See [TIP-191](https://github.com/tronprotocol/tips/blob/master/tip-191.md)
     */
    payload: string;
    /**
     * There is no public key member because the public key can be recovered via `ecrecover()` knowing the data and the signature. Encoding: base58
     */
    signature: string;
    standard: MultiPayload.standard;
} | {
    payload: string;
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
    standard: MultiPayload.standard;
} | {
    /**
     * Base64Url-encoded [authenticatorData](https://w3c.github.io/webauthn/#authenticator-data). Encoding: base64
     */
    authenticator_data: string;
    /**
     * Serialized [clientDataJSON](https://w3c.github.io/webauthn/#dom-authenticatorresponse-clientdatajson)
     */
    client_data_json: string;
    payload: string;
    standard: MultiPayload.standard;
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
} | {
    /**
     * Wallet address in either [Raw](https://docs.ton.org/v3/documentation/smart-contracts/addresses/address-formats#raw-address) representation or [user-friendly](https://docs.ton.org/v3/documentation/smart-contracts/addresses/address-formats#user-friendly-address) format
     */
    address: string;
    /**
     * dApp domain
     */
    domain: string;
    /**
     * See <https://docs.tonconsole.com/academy/sign-data#choosing-the-right-format>
     */
    payload: {
        text: string;
        type: MultiPayload.type;
    };
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
    standard: MultiPayload.standard;
    /**
     * UNIX timestamp (in seconds or RFC3339) at the time of singing
     */
    timestamp: (string | number);
});
declare namespace MultiPayload {
    enum standard {
        NEP413 = "nep413"
    }
    enum type {
        TEXT = "text"
    }
}

type AuthenticateRequestDto = {
    signedData: MultiPayload;
};

type AuthenticateResponseDto = {
    /**
     * JWT access token for API calls
     */
    accessToken: string;
    /**
     * JWT refresh token for getting new access tokens
     */
    refreshToken: string;
    /**
     * Access token expiration time in seconds
     */
    expiresIn: number;
    /**
     * Refresh token expiration time in seconds
     */
    refreshExpiresIn: number;
};

type BadRequestResponse = {
    message: string;
};

type BalanceEntry = {
    /**
     * Token identifier
     */
    tokenId: string;
    /**
     * Available balance (as string to preserve precision)
     */
    available: string;
    /**
     * Balance source
     */
    source: BalanceEntry.source;
};
declare namespace BalanceEntry {
    /**
     * Balance source
     */
    enum source {
        PRIVATE = "private"
    }
}

type ChainDepositAddress = {
    /**
     * Blockchain on which this deposit address accepts funds for the quote.
     */
    blockchain: ChainDepositAddress.blockchain;
    /**
     * Deposit address on `blockchain`. Funds sent here are credited to the same Intents account.
     */
    address: string;
    /**
     * Memo required together with `address` on chains that need it (e.g. Stellar, XRP, TON).
     */
    memo?: string;
};
declare namespace ChainDepositAddress {
    /**
     * Blockchain on which this deposit address accepts funds for the quote.
     */
    enum blockchain {
        NEAR = "near",
        ETH = "eth",
        BASE = "base",
        ARB = "arb",
        BTC = "btc",
        SOL = "sol",
        TON = "ton",
        DASH = "dash",
        DOGE = "doge",
        XRP = "xrp",
        ZEC = "zec",
        GNOSIS = "gnosis",
        BERA = "bera",
        BSC = "bsc",
        POL = "pol",
        TRON = "tron",
        SUI = "sui",
        MOVEMENT = "movement",
        OP = "op",
        AVAX = "avax",
        STELLAR = "stellar",
        APTOS = "aptos",
        CARDANO = "cardano",
        LTC = "ltc",
        XLAYER = "xlayer",
        MONAD = "monad",
        BCH = "bch",
        ADI = "adi",
        PLASMA = "plasma",
        SCROLL = "scroll",
        STARKNET = "starknet",
        ALEO = "aleo",
        HYPERCORE = "hypercore"
    }
}

type Deadline = string;

type DefuseConfig = {
    fees: {
        /**
         * 1 pip == 1/100th of bip == 0.0001%
         */
        fee: number;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        fee_collector: string;
    };
    roles?: {
        admins?: Record<string, Array<string>>;
        grantees?: Record<string, Array<string>>;
        super_admins?: Array<string>;
    };
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    wnear_id: string;
};

type DefusePayload_for_DefuseIntents = {
    deadline: string;
    /**
     * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
     */
    intents?: Array<({
        intent: 'add_public_key';
        /**
         * Encoding: base58
         */
        public_key: string;
    } | {
        intent: 'remove_public_key';
        /**
         * Encoding: base58
         */
        public_key: string;
    } | {
        intent: 'transfer';
        memo?: string | null;
        /**
         * Minimum gas for `mt_on_transfer()`
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * Message to pass to `mt_on_transfer`
         */
        msg?: string;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        receiver_id: string;
        /**
         * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
         */
        state_init?: {
            code: ({
                hash: string;
            } | {
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                account_id: string;
            });
            data: Record<string, string>;
            version: 'v1';
        } | null;
        tokens: Record<string, string>;
    } | {
        amount: string;
        intent: 'ft_withdraw';
        memo?: string | null;
        /**
         * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
         */
        msg?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        receiver_id: string;
        /**
         * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
         */
        storage_deposit?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        token: string;
    } | {
        intent: 'nft_withdraw';
        memo?: string | null;
        /**
         * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
         */
        msg?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        receiver_id: string;
        /**
         * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
         */
        storage_deposit?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        token: string;
        token_id: string;
    } | {
        amounts: Array<string>;
        intent: 'mt_withdraw';
        memo?: string | null;
        /**
         * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
         */
        msg?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        receiver_id: string;
        /**
         * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
         */
        storage_deposit?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        token: string;
        token_ids: Array<string>;
    } | {
        amount: string;
        intent: 'native_withdraw';
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        receiver_id: string;
    } | {
        amount: string;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        contract_id: string;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        deposit_for_account_id: string;
        intent: 'storage_deposit';
    } | {
        diff: Record<string, string>;
        intent: 'token_diff';
        memo?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        referral?: string | null;
    } | {
        enabled: boolean;
        intent: 'set_auth_by_predecessor_id';
    } | {
        /**
         * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
         *
         * NOTE: the `wNEAR` will not be refunded in case of fail.
         */
        attached_deposit?: string;
        /**
         * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
         */
        contract_id: string;
        intent: 'auth_call';
        /**
         * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
         */
        msg: string;
        /**
         * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
         */
        state_init?: {
            code: ({
                hash: string;
            } | {
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                account_id: string;
            });
            data: Record<string, string>;
            version: 'v1';
        } | null;
    } | {
        intent: 'imt_mint';
        memo?: string | null;
        /**
         * Minimum gas for `mt_on_transfer()`
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * Message to pass to `mt_on_transfer`
         */
        msg?: string;
        /**
         * Receiver of the minted tokens
         */
        receiver_id: string;
        /**
         * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
         */
        state_init?: {
            code: ({
                hash: string;
            } | {
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                account_id: string;
            });
            data: Record<string, string>;
            version: 'v1';
        } | null;
        /**
         * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
         */
        tokens: Record<string, string>;
    } | {
        intent: 'imt_burn';
        memo?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        minter_id: string;
        /**
         * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
         */
        tokens: Record<string, string>;
    })>;
    /**
     * Encoding: base64
     */
    nonce: string;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    signer_id: string;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    verifying_contract: string;
};

/**
 * See [ERC-191](https://github.com/ethereum/ercs/blob/master/ERCS/erc-191.md)
 */
type Erc191Payload = string;

type FeesConfig = {
    /**
     * 1 pip == 1/100th of bip == 0.0001%
     */
    fee: number;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    fee_collector: string;
};

/**
 * Withdraw given FT tokens from the intents contract to a given external account id (external being outside of intents).
 */
type FtWithdraw = {
    amount: string;
    memo?: string | null;
    /**
     * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
     *
     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
     */
    min_gas?: string | null;
    /**
     * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
     */
    msg?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    receiver_id: string;
    /**
     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
     */
    storage_deposit?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    token: string;
};

type MultiPayloadErc191Narrowed = {
    standard: 'erc191';
    payload: Erc191Payload;
};

/**
 * See [NEP-413](https://github.com/near/NEPs/blob/master/neps/nep-0413.md)
 */
type Nep413Payload = {
    callbackUrl?: string | null;
    message: string;
    /**
     * Encoding: base64
     */
    nonce: string;
    recipient: string;
};

type MultiPayloadNep413Narrowed = {
    standard: 'nep413';
    payload: Nep413Payload;
};

/**
 * Raw Ed25519 payload is an inline string
 */
type MultiPayloadRawEd25519Narrowed = {
    standard: 'raw_ed25519';
    payload: string;
};

/**
 * Sep53 payload is an inline string
 */
type MultiPayloadSep53Narrowed = {
    standard: 'sep53';
    payload: string;
};

/**
 * See [TIP-191](https://github.com/tronprotocol/tips/blob/master/tip-191.md)
 */
type Tip191Payload = string;

type MultiPayloadTip191Narrowed = {
    standard: 'tip191';
    payload: Tip191Payload;
};

/**
 * See <https://docs.tonconsole.com/academy/sign-data#choosing-the-right-format>
 */
type TonConnectPayloadSchema = {
    text: string;
    type: TonConnectPayloadSchema.type;
};
declare namespace TonConnectPayloadSchema {
    enum type {
        TEXT = "text"
    }
}

type MultiPayloadTonConnectNarrowed = {
    standard: 'ton_connect';
    payload: TonConnectPayloadSchema;
};

/**
 * Webauthn payload is an inline string
 */
type MultiPayloadWebauthnNarrowed = {
    standard: 'webauthn';
    payload: string;
};

/**
 * Narrowed MultiPayload union with only 'standard' and 'payload' properties exposed
 */
type MultiPayloadNarrowed = (MultiPayloadNep413Narrowed | MultiPayloadErc191Narrowed | MultiPayloadTip191Narrowed | MultiPayloadRawEd25519Narrowed | MultiPayloadWebauthnNarrowed | MultiPayloadTonConnectNarrowed | MultiPayloadSep53Narrowed);

type GenerateIntentResponse = {
    intent: MultiPayloadNarrowed;
    /**
     * Unique identifier for tracing this request
     */
    correlationId: string;
};

declare enum IntentStandardEnum {
    NEP413 = "nep413",
    ERC191 = "erc191",
    RAW_ED25519 = "raw_ed25519",
    WEBAUTHN = "webauthn",
    TON_CONNECT = "ton_connect",
    SEP53 = "sep53",
    TIP191 = "tip191"
}

type GenerateSwapTransferIntentRequest = {
    /**
     * The type of intent action
     */
    type: GenerateSwapTransferIntentRequest.type;
    /**
     * The standard used for signing the intent
     */
    standard: IntentStandardEnum;
    /**
     * The account ID of the signer
     */
    signerId: string;
    /**
     * The deposit address from the quote response
     */
    depositAddress: string;
};
declare namespace GenerateSwapTransferIntentRequest {
    /**
     * The type of intent action
     */
    enum type {
        SWAP_TRANSFER = "swap_transfer"
    }
}

type GetAnyInputQuoteWithdrawals = {
    /**
     * ID of the destination asset.
     */
    asset: string;
    /**
     * Recipient address
     */
    recipient: string;
    /**
     * Affiliate recipient address
     */
    affiliateRecipient: string;
    /**
     * Details of withdrawals
     */
    withdrawals?: AnyInputQuoteWithdrawal;
};

type GetBalancesResponse = {
    /**
     * List of token balances
     */
    balances: Array<BalanceEntry>;
};

type Quote = {
    /**
     * The deposit address on the chain of `originAsset` when `depositType` is `ORIGIN_CHAIN`.
     *
     * The deposit address inside NEAR Intents (the verifier smart contract) when `depositType` is `INTENTS`.
     *
     * The account ID within Confidential Intents to which assets are to be transferred when `depositType` is `CONFIDENTIAL_INTENTS`. Fund the swap by submitting a signed transfer intent to this value. Direct token transfers are not supported.
     */
    depositAddress?: string;
    /**
     * Some deposit addresses **REQUIRE** a `memo` together with `depositAddress` for the deposit to be processed. This field is deposit-side metadata.
     */
    depositMemo?: string;
    /**
     * Deposit addresses across all bridge-supported blockchains for funding the same Intents account. Present only for public `ANY_INPUT` quotes (`depositType` `INTENTS`); the confidential rail does not support multi-chain funding addresses yet. Each entry forwards to the Intents account in `depositAddress`, so the user may deposit from any listed chain.
     */
    chainDepositAddresses?: Array<ChainDepositAddress>;
    /**
     * Amount of the origin asset
     */
    amountIn: string;
    /**
     * Amount of the origin asset in readable format
     */
    amountInFormatted: string;
    /**
     * Amount of the origin assets equivalent in USD
     */
    amountInUsd: string;
    /**
     * Minimum amount of the origin asset that will be used for the swap
     */
    minAmountIn: string;
    /**
     * Amount of the destination asset
     */
    amountOut: string;
    /**
     * Amount of the destination asset in readable format
     */
    amountOutFormatted: string;
    /**
     * Amount of the destination asset equivalent in USD
     */
    amountOutUsd: string;
    /**
     * Minimum output amount after slippage is applied
     */
    minAmountOut: string;
    /**
     * Time when the deposit address becomes inactive and funds may be lost
     */
    deadline?: string;
    /**
     * Time when the deposit address becomes cold, causing swap processing to take longer
     */
    timeWhenInactive?: string;
    /**
     * Estimated time in seconds for the swap to be executed after the deposit transaction is confirmed
     */
    timeEstimate: number;
    /**
     * EVM address of a transfer recipient in a virtual chain
     */
    virtualChainRecipient?: string;
    /**
     * EVM address of a refund recipient in a virtual chain
     */
    virtualChainRefundRecipient?: string;
    /**
     * **HIGHLY EXPERIMENTAL** Message passed to `ft_transfer_call` when withdrawing assets to NEAR.
     *
     * Otherwise, `ft_transfer` will be used.
     *
     * **WARNING**: Funds will be lost if used with non NEP-141 tokens, in case of insufficient `storage_deposit` or if the recipient does not implement `ft_on_transfer` method.
     */
    customRecipientMsg?: string;
    /**
     * Fee charged for refunding assets to the refund address in the smallest unit of the origin asset
     */
    refundFee?: string;
    /**
     * Fee charged for withdrawing assets to the recipient in the smallest unit of the destination asset. This fee is already accounted for in the final amountOut result
     */
    withdrawFee?: string;
};

type Rebate = {
    /**
     * Confidential Intents account identifier that receives this rebate share. Rebate delivery uses signed transfer intent on Confidential Intents; direct token transfers are not supported.
     */
    recipient: string;
    /**
     * Rebate share for this recipient in percent.
     */
    share: number;
};

type QuoteRequest = {
    /**
     * Flag indicating whether this is a dry run request.
     * If `true`, the response will **NOT** contain the following fields:
     * - `depositAddress`
     * - `timeWhenInactive`
     * - `deadline`
     */
    dry: boolean;
    /**
     * What deposit address mode you will get in the response, most chain supports only `SIMPLE` and some(for example `stellar`) only `MEMO`:
     * - `SIMPLE` - usual deposit with only deposit address.
     * - `MEMO` - some chains will **REQUIRE** the `memo` together with `depositAddress` for swap to work.
     *
     * `depositMode` applies only to deposit transaction metadata.
     */
    depositMode?: QuoteRequest.depositMode;
    /**
     * How to interpret `amount` (and refunds) when performing the swap:
     *
     * - `EXACT_INPUT` — requests the output amount for an exact input.
     * - If deposit is less than `amountIn`, the deposit is refunded by deadline.
     * - If deposit is above than `amountIn`, the swap is processed and the excess is refunded to `refundTo` address after swap is complete.
     *
     * - `EXACT_OUTPUT` — requests the input amount for an exact output.
     * - The output amount (`amountOut`) is fixed; slippage is applied to the **input** side.
     * - The quote response includes `amountIn` (the proposed input with slippage tolerance baked in) and `minAmountIn` (the minimum input required).
     * - **Important**: `amountIn` will appear higher than `minAmountIn` by approximately your `slippageTolerance`. This is **not** price degradation—it is a buffer to ensure successful execution. Any input amount above what is actually needed for the swap is **refunded** to your `refundTo` address after the swap completes.
     * - If the deposit is above `amountIn`, the swap is processed and the excess is refunded to `refundTo` address after swap is complete.
     * - If the deposit is less than `minAmountIn`, the deposit is refunded by deadline.
     *
     * - `FLEX_INPUT` — a flexible input amount that allows for partial deposits and variable amounts.
     * - `slippage` applies both to `amountOut` and `amountIn` and defines an acceptable range (`minAmountIn` and `minAmountOut`).
     * - Any amount higher than `minAmountIn` is accepted and converted to the output asset as long as `minAmountOut` is met.
     * - The deposit must be at least `minAmountIn`, after applying the slippage constraint to the quoted amount. Deposits below `minAmountIn` are refunded if the total received by the deadline is below this amount.
     * - If deposits exceed the upper bound, the swap is still processed
     *
     * - `ANY_INPUT` — collects deposits and converts them to a destination asset. Used for fee aggregation and similar use cases. Only available for authorized partners.
     */
    swapType: QuoteRequest.swapType;
    /**
     * Slippage tolerance for the swap. This value is in basis points (1/100th of a percent), e.g. 100 for 1% slippage.
     */
    slippageTolerance: number;
    /**
     * ID of the origin asset.
     */
    originAsset: string;
    /**
     * Type of deposit address:
     * - `ORIGIN_CHAIN` - deposit address on the origin chain.
     * - `INTENTS` - the account ID within NEAR Intents to which you should transfer assets.
     * - `CONFIDENTIAL_INTENTS` - the account ID within Confidential Intents to which assets are to be transferred. Fund the swap from a Confidential Intents account by submitting a signed transfer intent to the quote `depositAddress`. Direct token transfers are not supported.
     */
    depositType: QuoteRequest.depositType;
    /**
     * ID of the destination asset.
     */
    destinationAsset: string;
    /**
     * Amount to swap as the base amount. It is interpreted as the input or output amount based on the `swapType` flag and is specified in the smallest unit of the currency (e.g., wei for ETH). Must be an integer string; decimal values like "0.01" are invalid—use base units (e.g. "10000000000000000" for 0.01 with 18 decimals).
     */
    amount: string;
    /**
     * Address used for refunds.
     */
    refundTo: string;
    /**
     * Type of refund address:
     * - `ORIGIN_CHAIN` - assets are refunded to the `refundTo` address on the origin chain.
     * - `INTENTS` - assets are refunded to the `refundTo` Intents account.
     * - `CONFIDENTIAL_INTENTS` - assets are refunded to the `refundTo` Confidential Intents account. On Confidential Intents, 1Click settles refunds via signed transfer intent rather than direct token transfer.
     */
    refundType: QuoteRequest.refundType;
    /**
     * Recipient address. The format must match `recipientType`. Destination routing metadata, when required, must be encoded according to the destination chain address format.
     */
    recipient: string;
    /**
     * Addresses of connected wallets.
     */
    connectedWallets?: Array<string>;
    /**
     * Unique client session identifier for 1Click.
     */
    sessionId?: string;
    /**
     * EVM address of a transfer recipient in a virtual chain
     */
    virtualChainRecipient?: string;
    /**
     * EVM address of a refund recipient in a virtual chain
     */
    virtualChainRefundRecipient?: string;
    /**
     * **HIGHLY EXPERIMENTAL** Message to pass to `ft_transfer_call` when withdrawing assets to NEAR.
     *
     * Otherwise, `ft_transfer` will be used.
     *
     * **WARNING**: Funds will be lost if used with non NEP-141 tokens, in case of insufficient `storage_deposit` or if the recipient does not implement `ft_on_transfer` method.
     */
    customRecipientMsg?: string;
    /**
     * Type of recipient address:
     * - `DESTINATION_CHAIN` - assets are transferred to the chain of `destinationAsset`.
     * - `INTENTS` - assets are transferred to an account inside Intents.
     * - `CONFIDENTIAL_INTENTS` - assets are transferred to the `recipient` account inside Confidential Intents. On Confidential Intents, 1Click settles swap output via signed transfer intent rather than direct token transfer.
     */
    recipientType: QuoteRequest.recipientType;
    /**
     * Timestamp in ISO format that identifies when the user refund begins if the swap isn't completed by then. It must exceed the time required for the deposit transaction to be mined. For example, Bitcoin may require around one hour depending on the fees paid.
     */
    deadline: string;
    /**
     * Confidentiality mode for this quote. Invite-only for now: if set, API may return an invite-only message until rollout is enabled for your integration.
     */
    confidentiality?: QuoteRequest.confidentiality;
    /**
     * Distribution channel / venue identifier (for example: ledger, trustwallet). Keep lowercase for consistency.
     */
    referral?: string;
    /**
     * Rebate distribution for this quote. Provide up to 3 confidential Intents recipients (for example, `rebate-recipient.near` on confidential Intents); each item defines a recipient and its percent share, and all shares must add up to 100.
     */
    rebates?: Array<Rebate>;
    /**
     * Time in milliseconds the user is willing to wait for a quote from the relay.
     * **Defaults to 0ms delay if not specified, if you want to receive the fastest quote.
     */
    quoteWaitingTimeMs?: number;
    /**
     * List of recipients and their fees
     */
    appFees?: Array<AppFee>;
};
declare namespace QuoteRequest {
    /**
     * What deposit address mode you will get in the response, most chain supports only `SIMPLE` and some(for example `stellar`) only `MEMO`:
     * - `SIMPLE` - usual deposit with only deposit address.
     * - `MEMO` - some chains will **REQUIRE** the `memo` together with `depositAddress` for swap to work.
     *
     * `depositMode` applies only to deposit transaction metadata.
     */
    enum depositMode {
        SIMPLE = "SIMPLE",
        MEMO = "MEMO"
    }
    /**
     * How to interpret `amount` (and refunds) when performing the swap:
     *
     * - `EXACT_INPUT` — requests the output amount for an exact input.
     * - If deposit is less than `amountIn`, the deposit is refunded by deadline.
     * - If deposit is above than `amountIn`, the swap is processed and the excess is refunded to `refundTo` address after swap is complete.
     *
     * - `EXACT_OUTPUT` — requests the input amount for an exact output.
     * - The output amount (`amountOut`) is fixed; slippage is applied to the **input** side.
     * - The quote response includes `amountIn` (the proposed input with slippage tolerance baked in) and `minAmountIn` (the minimum input required).
     * - **Important**: `amountIn` will appear higher than `minAmountIn` by approximately your `slippageTolerance`. This is **not** price degradation—it is a buffer to ensure successful execution. Any input amount above what is actually needed for the swap is **refunded** to your `refundTo` address after the swap completes.
     * - If the deposit is above `amountIn`, the swap is processed and the excess is refunded to `refundTo` address after swap is complete.
     * - If the deposit is less than `minAmountIn`, the deposit is refunded by deadline.
     *
     * - `FLEX_INPUT` — a flexible input amount that allows for partial deposits and variable amounts.
     * - `slippage` applies both to `amountOut` and `amountIn` and defines an acceptable range (`minAmountIn` and `minAmountOut`).
     * - Any amount higher than `minAmountIn` is accepted and converted to the output asset as long as `minAmountOut` is met.
     * - The deposit must be at least `minAmountIn`, after applying the slippage constraint to the quoted amount. Deposits below `minAmountIn` are refunded if the total received by the deadline is below this amount.
     * - If deposits exceed the upper bound, the swap is still processed
     *
     * - `ANY_INPUT` — collects deposits and converts them to a destination asset. Used for fee aggregation and similar use cases. Only available for authorized partners.
     */
    enum swapType {
        EXACT_INPUT = "EXACT_INPUT",
        EXACT_OUTPUT = "EXACT_OUTPUT",
        FLEX_INPUT = "FLEX_INPUT",
        ANY_INPUT = "ANY_INPUT"
    }
    /**
     * Type of deposit address:
     * - `ORIGIN_CHAIN` - deposit address on the origin chain.
     * - `INTENTS` - the account ID within NEAR Intents to which you should transfer assets.
     * - `CONFIDENTIAL_INTENTS` - the account ID within Confidential Intents to which assets are to be transferred. Fund the swap from a Confidential Intents account by submitting a signed transfer intent to the quote `depositAddress`. Direct token transfers are not supported.
     */
    enum depositType {
        ORIGIN_CHAIN = "ORIGIN_CHAIN",
        INTENTS = "INTENTS",
        CONFIDENTIAL_INTENTS = "CONFIDENTIAL_INTENTS"
    }
    /**
     * Type of refund address:
     * - `ORIGIN_CHAIN` - assets are refunded to the `refundTo` address on the origin chain.
     * - `INTENTS` - assets are refunded to the `refundTo` Intents account.
     * - `CONFIDENTIAL_INTENTS` - assets are refunded to the `refundTo` Confidential Intents account. On Confidential Intents, 1Click settles refunds via signed transfer intent rather than direct token transfer.
     */
    enum refundType {
        ORIGIN_CHAIN = "ORIGIN_CHAIN",
        INTENTS = "INTENTS",
        CONFIDENTIAL_INTENTS = "CONFIDENTIAL_INTENTS"
    }
    /**
     * Type of recipient address:
     * - `DESTINATION_CHAIN` - assets are transferred to the chain of `destinationAsset`.
     * - `INTENTS` - assets are transferred to an account inside Intents.
     * - `CONFIDENTIAL_INTENTS` - assets are transferred to the `recipient` account inside Confidential Intents. On Confidential Intents, 1Click settles swap output via signed transfer intent rather than direct token transfer.
     */
    enum recipientType {
        DESTINATION_CHAIN = "DESTINATION_CHAIN",
        INTENTS = "INTENTS",
        CONFIDENTIAL_INTENTS = "CONFIDENTIAL_INTENTS"
    }
    /**
     * Confidentiality mode for this quote. Invite-only for now: if set, API may return an invite-only message until rollout is enabled for your integration.
     */
    enum confidentiality {
        PUBLIC = "public",
        BASIC = "basic",
        ADVANCED = "advanced"
    }
}

type QuoteResponse = {
    /**
     * Unique identifier for request tracing and debugging
     */
    correlationId: string;
    /**
     * Timestamp in ISO format that was used to derive the deposit address
     */
    timestamp: string;
    /**
     * Signature of the 1Click service confirming the quote for the specific deposit address. Must be saved on the client side (along with the whole quote) in order to resolve any disputes or mistakes.
     */
    signature: string;
    /**
     * User request
     */
    quoteRequest: QuoteRequest;
    /**
     * Response containing the deposit address for sending the `amount` of `originAsset` and the expected output amount.
     */
    quote: Quote;
};

type TransactionDetails = {
    /**
     * Transaction hash
     */
    hash: string;
    /**
     * Explorer URL for the transaction
     */
    explorerUrl: string;
};

type SwapDetails = {
    /**
     * All intent hashes that took part in this swap
     */
    intentHashes: Array<string>;
    /**
     * All NEAR transactions executed for this swap
     */
    nearTxHashes: Array<string>;
    /**
     * Exact amount of `originToken` after the trade was settled
     */
    amountIn?: string;
    /**
     * Exact amount of `originToken` in readable format after the trade was settled
     */
    amountInFormatted?: string;
    /**
     * Exact amount of `originToken` equivalent in USD
     */
    amountInUsd?: string;
    /**
     * Exact amount of `destinationToken` after the trade was settled
     */
    amountOut?: string;
    /**
     * Exact amount of `destinationToken` in readable format after the trade was settled
     */
    amountOutFormatted?: string;
    /**
     * Exact amount of `destinationToken` equivalent in USD
     */
    amountOutUsd?: string;
    /**
     * Actual slippage
     */
    slippage?: number;
    /**
     * Hashes and explorer URLs for all transactions on the origin chain
     */
    originChainTxHashes: Array<TransactionDetails>;
    /**
     * Hashes and explorer URLs for all transactions on the destination chain
     */
    destinationChainTxHashes: Array<TransactionDetails>;
    /**
     * Amount of `originAsset` transferred to `refundTo`
     */
    refundedAmount?: string;
    /**
     * Refunded amount in readable format
     */
    refundedAmountFormatted?: string;
    /**
     * Refunded amount equivalent in USD
     */
    refundedAmountUsd?: string;
    /**
     * Reason for refund
     */
    refundReason?: string;
    /**
     * Amount deposited to `depositAddress` onchain
     */
    depositedAmount?: string;
    /**
     * Amount deposited in readable format
     */
    depositedAmountFormatted?: string;
    /**
     * Amount deposited equivalent in USD
     */
    depositedAmountUsd?: string;
    /**
     * Fee charged for withdrawing assets to the recipient in the smallest unit of the destination asset. This fee is already accounted for in the final amountOut result
     */
    withdrawFee?: string;
    /**
     * Referral identifier
     */
    referral?: string;
};

type GetExecutionStatusResponse = {
    /**
     * Unique identifier for request tracing and debugging
     */
    correlationId: string;
    /**
     * Quote response from the original request
     */
    quoteResponse: QuoteResponse;
    status: GetExecutionStatusResponse.status;
    /**
     * Last time the state was updated
     */
    updatedAt: string;
    /**
     * Details of actual swaps and withdrawals
     */
    swapDetails: SwapDetails;
};
declare namespace GetExecutionStatusResponse {
    enum status {
        KNOWN_DEPOSIT_TX = "KNOWN_DEPOSIT_TX",
        PENDING_DEPOSIT = "PENDING_DEPOSIT",
        INCOMPLETE_DEPOSIT = "INCOMPLETE_DEPOSIT",
        PROCESSING = "PROCESSING",
        SUCCESS = "SUCCESS",
        REFUNDED = "REFUNDED",
        FAILED = "FAILED"
    }
}

type GlobalContractId = ({
    hash: string;
} | {
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    account_id: string;
});

type HistoryItem = {
    /**
     * Execution status
     */
    status: HistoryItem.status;
    /**
     * Deposit type
     */
    depositType: HistoryItem.depositType;
    /**
     * Recipient type
     */
    recipientType: HistoryItem.recipientType;
    /**
     * Creation timestamp (ISO 8601)
     */
    createdAt: string;
    /**
     * Deposit address
     */
    depositAddress: string;
    /**
     * Deposit memo
     */
    depositMemo: string | null;
    /**
     * ID of the origin asset
     */
    originAsset?: string;
    /**
     * Amount of the origin asset in readable format
     */
    amountInFormatted?: string;
    /**
     * Amount of the origin asset equivalent in USD
     */
    amountInUsd?: string;
    /**
     * ID of the destination asset
     */
    destinationAsset?: string;
    /**
     * Amount of the destination asset in readable format
     */
    amountOutFormatted?: string;
    /**
     * Amount of the destination asset equivalent in USD
     */
    amountOutUsd?: string;
    /**
     * Recipient address
     */
    recipient?: string;
    /**
     * Deposit transactions with sender and tx hash
     */
    quoteTransactions?: Array<{
        sender?: string;
        txHash?: string;
    }>;
    /**
     * Refund-to address
     */
    refundTo?: string;
    /**
     * Refund type
     */
    refundType: HistoryItem.refundType;
    /**
     * Refund reason, null when no refund occurred
     */
    refundReason?: string | null;
    /**
     * Refunded amount in readable format
     */
    refundedAmountFormatted?: string;
    /**
     * Refunded amount equivalent in USD
     */
    refundedAmountUsd?: string;
    /**
     * Refund fee in base units of the origin asset
     */
    refundFee?: string | null;
    /**
     * Formatted refund fee
     */
    refundFeeFormatted?: string;
};
declare namespace HistoryItem {
    /**
     * Execution status
     */
    enum status {
        PENDING_DEPOSIT = "PENDING_DEPOSIT",
        INCOMPLETE_DEPOSIT = "INCOMPLETE_DEPOSIT",
        PROCESSING = "PROCESSING",
        SUCCESS = "SUCCESS",
        REFUNDED = "REFUNDED",
        FAILED = "FAILED"
    }
    /**
     * Deposit type
     */
    enum depositType {
        ORIGIN_CHAIN = "ORIGIN_CHAIN",
        INTENTS = "INTENTS",
        CONFIDENTIAL_INTENTS = "CONFIDENTIAL_INTENTS"
    }
    /**
     * Recipient type
     */
    enum recipientType {
        DESTINATION_CHAIN = "DESTINATION_CHAIN",
        INTENTS = "INTENTS",
        CONFIDENTIAL_INTENTS = "CONFIDENTIAL_INTENTS"
    }
    /**
     * Refund type
     */
    enum refundType {
        ORIGIN_CHAIN = "ORIGIN_CHAIN",
        INTENTS = "INTENTS",
        CONFIDENTIAL_INTENTS = "CONFIDENTIAL_INTENTS"
    }
}

type HistoryResponse = {
    /**
     * History items for the current page. When fetching older items (via prevCursor), fewer items than limit means you reached the end — no need to fetch further. For newer items (via nextCursor), new data can always appear later.
     */
    items: Array<HistoryItem>;
    /**
     * Pass it back as nextCursor to poll for newer items.
     */
    nextCursor?: string;
    /**
     * Pass it back as prevCursor to fetch older items.
     */
    prevCursor?: string;
};

type Intent = ({
    intent: Intent.intent;
    /**
     * Encoding: base58
     */
    public_key: string;
} | {
    intent: Intent.intent;
    memo?: string | null;
    /**
     * Minimum gas for `mt_on_transfer()`
     *
     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
     */
    min_gas?: string | null;
    /**
     * Message to pass to `mt_on_transfer`
     */
    msg?: string;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    receiver_id: string;
    /**
     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
     */
    state_init?: {
        code: ({
            hash: string;
        } | {
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            account_id: string;
        });
        data: Record<string, string>;
        version: Intent.version;
    } | null;
    tokens: Record<string, string>;
} | {
    amount: string;
    intent: Intent.intent;
    memo?: string | null;
    /**
     * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
     *
     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
     */
    min_gas?: string | null;
    /**
     * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
     */
    msg?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    receiver_id: string;
    /**
     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
     */
    storage_deposit?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    token: string;
} | {
    intent: Intent.intent;
    memo?: string | null;
    /**
     * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
     *
     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
     */
    min_gas?: string | null;
    /**
     * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
     */
    msg?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    receiver_id: string;
    /**
     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
     */
    storage_deposit?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    token: string;
    token_id: string;
} | {
    amounts: Array<string>;
    intent: Intent.intent;
    memo?: string | null;
    /**
     * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
     *
     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
     */
    min_gas?: string | null;
    /**
     * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
     */
    msg?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    receiver_id: string;
    /**
     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
     */
    storage_deposit?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    token: string;
    token_ids: Array<string>;
} | {
    amount: string;
    intent: Intent.intent;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    receiver_id: string;
} | {
    amount: string;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    contract_id: string;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    deposit_for_account_id: string;
    intent: Intent.intent;
} | {
    diff: Record<string, string>;
    intent: Intent.intent;
    memo?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    referral?: string | null;
} | {
    enabled: boolean;
    intent: Intent.intent;
} | {
    /**
     * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
     *
     * NOTE: the `wNEAR` will not be refunded in case of fail.
     */
    attached_deposit?: string;
    /**
     * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
     */
    contract_id: string;
    intent: Intent.intent;
    /**
     * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
     *
     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
     */
    min_gas?: string | null;
    /**
     * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
     */
    msg: string;
    /**
     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
     */
    state_init?: {
        code: ({
            hash: string;
        } | {
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            account_id: string;
        });
        data: Record<string, string>;
        version: Intent.version;
    } | null;
} | {
    intent: Intent.intent;
    memo?: string | null;
    /**
     * Minimum gas for `mt_on_transfer()`
     *
     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
     */
    min_gas?: string | null;
    /**
     * Message to pass to `mt_on_transfer`
     */
    msg?: string;
    /**
     * Receiver of the minted tokens
     */
    receiver_id: string;
    /**
     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
     */
    state_init?: {
        code: ({
            hash: string;
        } | {
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            account_id: string;
        });
        data: Record<string, string>;
        version: Intent.version;
    } | null;
    /**
     * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
     */
    tokens: Record<string, string>;
} | {
    intent: Intent.intent;
    memo?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    minter_id: string;
    /**
     * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
     */
    tokens: Record<string, string>;
});
declare namespace Intent {
    enum intent {
        ADD_PUBLIC_KEY = "add_public_key"
    }
    enum version {
        V1 = "v1"
    }
}

/**
 * See [`AddPublicKey`]
 */
type IntentAddPublicKey = {
    intent: IntentAddPublicKey.intent;
    /**
     * Encoding: base58
     */
    public_key: string;
};
declare namespace IntentAddPublicKey {
    enum intent {
        ADD_PUBLIC_KEY = "add_public_key"
    }
}

/**
 * See [`AuthCall`]
 */
type IntentAuthCall = {
    /**
     * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
     *
     * NOTE: the `wNEAR` will not be refunded in case of fail.
     */
    attached_deposit?: string;
    /**
     * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
     */
    contract_id: string;
    intent: IntentAuthCall.intent;
    /**
     * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
     *
     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
     */
    min_gas?: string | null;
    /**
     * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
     */
    msg: string;
    /**
     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
     */
    state_init?: {
        code: ({
            hash: string;
        } | {
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            account_id: string;
        });
        data: Record<string, string>;
        version: IntentAuthCall.version;
    } | null;
};
declare namespace IntentAuthCall {
    enum intent {
        AUTH_CALL = "auth_call"
    }
    enum version {
        V1 = "v1"
    }
}

type IntentEvent_for_AccountEvent_for_NonceEvent = {
    /**
     * Account identifier. This is the human readable UTF-8 string which is used internally to index accounts on the network and their respective state.
     *
     * This is the "referenced" version of the account ID. It is to [`AccountId`] what [`str`] is to [`String`], and works quite similarly to [`Path`]. Like with [`str`] and [`Path`], you can't have a value of type `AccountIdRef`, but you can have a reference like `&AccountIdRef` or `&mut AccountIdRef`.
     *
     * This type supports zero-copy deserialization offered by [`serde`](https://docs.rs/serde/), but cannot do the same for [`borsh`](https://docs.rs/borsh/) since the latter does not support zero-copy.
     *
     * # Examples ``` use near_account_id::{AccountId, AccountIdRef}; use std::convert::{TryFrom, TryInto};
     *
     * // Construction let alice = AccountIdRef::new("alice.near").unwrap(); assert!(AccountIdRef::new("invalid.").is_err()); ```
     *
     * [`FromStr`]: std::str::FromStr [`Path`]: std::path::Path
     */
    account_id: string;
    /**
     * Encoding: base58
     */
    intent_hash: string;
    /**
     * Encoding: base64
     */
    nonce: string;
};

/**
 * See [`FtWithdraw`]
 */
type IntentFtWithdraw = {
    amount: string;
    intent: IntentFtWithdraw.intent;
    memo?: string | null;
    /**
     * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
     *
     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
     */
    min_gas?: string | null;
    /**
     * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
     */
    msg?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    receiver_id: string;
    /**
     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
     */
    storage_deposit?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    token: string;
};
declare namespace IntentFtWithdraw {
    enum intent {
        FT_WITHDRAW = "ft_withdraw"
    }
}

/**
 * Burn a set of imt tokens, within the intents contract.
 */
type IntentImtBurn = {
    intent: IntentImtBurn.intent;
    memo?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    minter_id: string;
    /**
     * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
     */
    tokens: Record<string, string>;
};
declare namespace IntentImtBurn {
    enum intent {
        IMT_BURN = "imt_burn"
    }
}

/**
 * Mint a set of tokens from the signer to a specified account id, within the intents contract.
 */
type IntentImtMint = {
    intent: IntentImtMint.intent;
    memo?: string | null;
    /**
     * Minimum gas for `mt_on_transfer()`
     *
     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
     */
    min_gas?: string | null;
    /**
     * Message to pass to `mt_on_transfer`
     */
    msg?: string;
    /**
     * Receiver of the minted tokens
     */
    receiver_id: string;
    /**
     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
     */
    state_init?: {
        code: ({
            hash: string;
        } | {
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            account_id: string;
        });
        data: Record<string, string>;
        version: IntentImtMint.version;
    } | null;
    /**
     * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
     */
    tokens: Record<string, string>;
};
declare namespace IntentImtMint {
    enum intent {
        IMT_MINT = "imt_mint"
    }
    enum version {
        V1 = "v1"
    }
}

/**
 * See [`MtWithdraw`]
 */
type IntentMtWithdraw = {
    amounts: Array<string>;
    intent: IntentMtWithdraw.intent;
    memo?: string | null;
    /**
     * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
     *
     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
     */
    min_gas?: string | null;
    /**
     * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
     */
    msg?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    receiver_id: string;
    /**
     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
     */
    storage_deposit?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    token: string;
    token_ids: Array<string>;
};
declare namespace IntentMtWithdraw {
    enum intent {
        MT_WITHDRAW = "mt_withdraw"
    }
}

/**
 * See [`NativeWithdraw`]
 */
type IntentNativeWithdraw = {
    amount: string;
    intent: IntentNativeWithdraw.intent;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    receiver_id: string;
};
declare namespace IntentNativeWithdraw {
    enum intent {
        NATIVE_WITHDRAW = "native_withdraw"
    }
}

/**
 * See [`NftWithdraw`]
 */
type IntentNftWithdraw = {
    intent: IntentNftWithdraw.intent;
    memo?: string | null;
    /**
     * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
     *
     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
     */
    min_gas?: string | null;
    /**
     * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
     */
    msg?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    receiver_id: string;
    /**
     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
     */
    storage_deposit?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    token: string;
    token_id: string;
};
declare namespace IntentNftWithdraw {
    enum intent {
        NFT_WITHDRAW = "nft_withdraw"
    }
}

/**
 * See [`RemovePublicKey`]
 */
type IntentRemovePublicKey = {
    intent: IntentRemovePublicKey.intent;
    /**
     * Encoding: base58
     */
    public_key: string;
};
declare namespace IntentRemovePublicKey {
    enum intent {
        REMOVE_PUBLIC_KEY = "remove_public_key"
    }
}

/**
 * See [`SetAuthByPredecessorId`]
 */
type IntentSetAuthByPredecessorId = {
    enabled: boolean;
    intent: IntentSetAuthByPredecessorId.intent;
};
declare namespace IntentSetAuthByPredecessorId {
    enum intent {
        SET_AUTH_BY_PREDECESSOR_ID = "set_auth_by_predecessor_id"
    }
}

/**
 * See [`StorageDeposit`]
 */
type IntentStorageDeposit = {
    amount: string;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    contract_id: string;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    deposit_for_account_id: string;
    intent: IntentStorageDeposit.intent;
};
declare namespace IntentStorageDeposit {
    enum intent {
        STORAGE_DEPOSIT = "storage_deposit"
    }
}

/**
 * See [`TokenDiff`]
 */
type IntentTokenDiff = {
    diff: Record<string, string>;
    intent: IntentTokenDiff.intent;
    memo?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    referral?: string | null;
};
declare namespace IntentTokenDiff {
    enum intent {
        TOKEN_DIFF = "token_diff"
    }
}

/**
 * See [`Transfer`]
 */
type IntentTransfer = {
    intent: IntentTransfer.intent;
    memo?: string | null;
    /**
     * Minimum gas for `mt_on_transfer()`
     *
     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
     */
    min_gas?: string | null;
    /**
     * Message to pass to `mt_on_transfer`
     */
    msg?: string;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    receiver_id: string;
    /**
     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
     */
    state_init?: {
        code: ({
            hash: string;
        } | {
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            account_id: string;
        });
        data: Record<string, string>;
        version: IntentTransfer.version;
    } | null;
    tokens: Record<string, string>;
};
declare namespace IntentTransfer {
    enum intent {
        TRANSFER = "transfer"
    }
    enum version {
        V1 = "v1"
    }
}

type InvariantViolated = ({
    error: InvariantViolated.error;
    unmatched_deltas: Record<string, string>;
} | {
    error: InvariantViolated.error;
});
declare namespace InvariantViolated {
    enum error {
        UNMATCHED_DELTAS = "unmatched_deltas"
    }
}

type InvariantViolatedOverflow = {
    error: InvariantViolatedOverflow.error;
};
declare namespace InvariantViolatedOverflow {
    enum error {
        OVERFLOW = "overflow"
    }
}

type InvariantViolatedUnmatchedDeltas = {
    error: InvariantViolatedUnmatchedDeltas.error;
    unmatched_deltas: Record<string, string>;
};
declare namespace InvariantViolatedUnmatchedDeltas {
    enum error {
        UNMATCHED_DELTAS = "unmatched_deltas"
    }
}

/**
 * Withdraw given MT tokens (i.e. [NEP-245](https://github.com/near/NEPs/blob/master/neps/nep-0245.md)) from the intents contract to a given to an external account id (external being outside of intents).
 *
 * If `msg` is given, `mt_batch_transfer_call()` will be used to transfer to the `receiver_id`. Otherwise, `mt_batch_transfer()` will be used.
 */
type MtWithdraw = {
    amounts: Array<string>;
    memo?: string | null;
    /**
     * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
     *
     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
     */
    min_gas?: string | null;
    /**
     * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
     */
    msg?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    receiver_id: string;
    /**
     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
     */
    storage_deposit?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    token: string;
    token_ids: Array<string>;
};

type MultiPayload__Parsed = ({
    /**
     * See [NEP-413](https://github.com/near/NEPs/blob/master/neps/nep-0413.md)
     */
    payload: {
        callbackUrl?: string | null;
        message: {
            original: string;
            parsed: {
                deadline: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                signer_id: string;
                /**
                 * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
                 */
                intents?: Array<({
                    intent: 'add_public_key';
                    /**
                     * Encoding: base58
                     */
                    public_key: string;
                } | {
                    intent: 'remove_public_key';
                    /**
                     * Encoding: base58
                     */
                    public_key: string;
                } | {
                    intent: 'transfer';
                    memo?: string | null;
                    /**
                     * Minimum gas for `mt_on_transfer()`
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_on_transfer`
                     */
                    msg?: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                    tokens: Record<string, string>;
                } | {
                    amount: string;
                    intent: 'ft_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                } | {
                    intent: 'nft_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                    token_id: string;
                } | {
                    amounts: Array<string>;
                    intent: 'mt_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                    token_ids: Array<string>;
                } | {
                    amount: string;
                    intent: 'native_withdraw';
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                } | {
                    amount: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    contract_id: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    deposit_for_account_id: string;
                    intent: 'storage_deposit';
                } | {
                    diff: Record<string, string>;
                    intent: 'token_diff';
                    memo?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    referral?: string | null;
                } | {
                    enabled: boolean;
                    intent: 'set_auth_by_predecessor_id';
                } | {
                    /**
                     * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                     *
                     * NOTE: the `wNEAR` will not be refunded in case of fail.
                     */
                    attached_deposit?: string;
                    /**
                     * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                     */
                    contract_id: string;
                    intent: 'auth_call';
                    /**
                     * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                     */
                    msg: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                } | {
                    intent: 'imt_mint';
                    memo?: string | null;
                    /**
                     * Minimum gas for `mt_on_transfer()`
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_on_transfer`
                     */
                    msg?: string;
                    /**
                     * Receiver of the minted tokens
                     */
                    receiver_id: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                    /**
                     * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                     */
                    tokens: Record<string, string>;
                } | {
                    intent: 'imt_burn';
                    memo?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    minter_id: string;
                    /**
                     * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                     */
                    tokens: Record<string, string>;
                })>;
            };
        };
        /**
         * Encoding: base64
         */
        nonce: string;
        recipient: string;
    };
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
    standard: MultiPayload__Parsed.standard;
} | {
    payload: {
        original: string;
        parsed: {
            deadline: string;
            /**
             * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
             */
            intents?: Array<({
                intent: 'add_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'remove_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'transfer';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                tokens: Record<string, string>;
            } | {
                amount: string;
                intent: 'ft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
            } | {
                intent: 'nft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_id: string;
            } | {
                amounts: Array<string>;
                intent: 'mt_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_ids: Array<string>;
            } | {
                amount: string;
                intent: 'native_withdraw';
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
            } | {
                amount: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                contract_id: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                deposit_for_account_id: string;
                intent: 'storage_deposit';
            } | {
                diff: Record<string, string>;
                intent: 'token_diff';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                referral?: string | null;
            } | {
                enabled: boolean;
                intent: 'set_auth_by_predecessor_id';
            } | {
                /**
                 * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                 *
                 * NOTE: the `wNEAR` will not be refunded in case of fail.
                 */
                attached_deposit?: string;
                /**
                 * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                contract_id: string;
                intent: 'auth_call';
                /**
                 * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                msg: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
            } | {
                intent: 'imt_mint';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * Receiver of the minted tokens
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            } | {
                intent: 'imt_burn';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                minter_id: string;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            })>;
            /**
             * Encoding: base64
             */
            nonce: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            signer_id: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            verifying_contract: string;
        };
    };
    /**
     * There is no public key member because the public key can be recovered via `ecrecover()` knowing the data and the signature. Encoding: base58
     */
    signature: string;
    standard: MultiPayload__Parsed.standard;
} | {
    payload: {
        original: string;
        parsed: {
            deadline: string;
            /**
             * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
             */
            intents?: Array<({
                intent: 'add_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'remove_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'transfer';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                tokens: Record<string, string>;
            } | {
                amount: string;
                intent: 'ft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
            } | {
                intent: 'nft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_id: string;
            } | {
                amounts: Array<string>;
                intent: 'mt_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_ids: Array<string>;
            } | {
                amount: string;
                intent: 'native_withdraw';
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
            } | {
                amount: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                contract_id: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                deposit_for_account_id: string;
                intent: 'storage_deposit';
            } | {
                diff: Record<string, string>;
                intent: 'token_diff';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                referral?: string | null;
            } | {
                enabled: boolean;
                intent: 'set_auth_by_predecessor_id';
            } | {
                /**
                 * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                 *
                 * NOTE: the `wNEAR` will not be refunded in case of fail.
                 */
                attached_deposit?: string;
                /**
                 * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                contract_id: string;
                intent: 'auth_call';
                /**
                 * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                msg: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
            } | {
                intent: 'imt_mint';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * Receiver of the minted tokens
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            } | {
                intent: 'imt_burn';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                minter_id: string;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            })>;
            /**
             * Encoding: base64
             */
            nonce: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            signer_id: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            verifying_contract: string;
        };
    };
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
    standard: MultiPayload__Parsed.standard;
} | {
    /**
     * Base64Url-encoded [authenticatorData](https://w3c.github.io/webauthn/#authenticator-data). Encoding: base64
     */
    authenticator_data: string;
    /**
     * Serialized [clientDataJSON](https://w3c.github.io/webauthn/#dom-authenticatorresponse-clientdatajson)
     */
    client_data_json: string;
    payload: {
        original: string;
        parsed: {
            deadline: string;
            /**
             * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
             */
            intents?: Array<({
                intent: 'add_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'remove_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'transfer';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                tokens: Record<string, string>;
            } | {
                amount: string;
                intent: 'ft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
            } | {
                intent: 'nft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_id: string;
            } | {
                amounts: Array<string>;
                intent: 'mt_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_ids: Array<string>;
            } | {
                amount: string;
                intent: 'native_withdraw';
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
            } | {
                amount: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                contract_id: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                deposit_for_account_id: string;
                intent: 'storage_deposit';
            } | {
                diff: Record<string, string>;
                intent: 'token_diff';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                referral?: string | null;
            } | {
                enabled: boolean;
                intent: 'set_auth_by_predecessor_id';
            } | {
                /**
                 * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                 *
                 * NOTE: the `wNEAR` will not be refunded in case of fail.
                 */
                attached_deposit?: string;
                /**
                 * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                contract_id: string;
                intent: 'auth_call';
                /**
                 * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                msg: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
            } | {
                intent: 'imt_mint';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * Receiver of the minted tokens
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            } | {
                intent: 'imt_burn';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                minter_id: string;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            })>;
            /**
             * Encoding: base64
             */
            nonce: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            signer_id: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            verifying_contract: string;
        };
    };
    standard: MultiPayload__Parsed.standard;
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
} | {
    /**
     * Wallet address in either [Raw](https://docs.ton.org/v3/documentation/smart-contracts/addresses/address-formats#raw-address) representation or [user-friendly](https://docs.ton.org/v3/documentation/smart-contracts/addresses/address-formats#user-friendly-address) format
     */
    address: string;
    /**
     * dApp domain
     */
    domain: string;
    payload: {
        text: {
            original: string;
            parsed: {
                deadline: string;
                /**
                 * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
                 */
                intents?: Array<({
                    intent: 'add_public_key';
                    /**
                     * Encoding: base58
                     */
                    public_key: string;
                } | {
                    intent: 'remove_public_key';
                    /**
                     * Encoding: base58
                     */
                    public_key: string;
                } | {
                    intent: 'transfer';
                    memo?: string | null;
                    /**
                     * Minimum gas for `mt_on_transfer()`
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_on_transfer`
                     */
                    msg?: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                    tokens: Record<string, string>;
                } | {
                    amount: string;
                    intent: 'ft_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                } | {
                    intent: 'nft_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                    token_id: string;
                } | {
                    amounts: Array<string>;
                    intent: 'mt_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                    token_ids: Array<string>;
                } | {
                    amount: string;
                    intent: 'native_withdraw';
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                } | {
                    amount: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    contract_id: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    deposit_for_account_id: string;
                    intent: 'storage_deposit';
                } | {
                    diff: Record<string, string>;
                    intent: 'token_diff';
                    memo?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    referral?: string | null;
                } | {
                    enabled: boolean;
                    intent: 'set_auth_by_predecessor_id';
                } | {
                    /**
                     * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                     *
                     * NOTE: the `wNEAR` will not be refunded in case of fail.
                     */
                    attached_deposit?: string;
                    /**
                     * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                     */
                    contract_id: string;
                    intent: 'auth_call';
                    /**
                     * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                     */
                    msg: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                } | {
                    intent: 'imt_mint';
                    memo?: string | null;
                    /**
                     * Minimum gas for `mt_on_transfer()`
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_on_transfer`
                     */
                    msg?: string;
                    /**
                     * Receiver of the minted tokens
                     */
                    receiver_id: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                    /**
                     * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                     */
                    tokens: Record<string, string>;
                } | {
                    intent: 'imt_burn';
                    memo?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    minter_id: string;
                    /**
                     * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                     */
                    tokens: Record<string, string>;
                })>;
                /**
                 * Encoding: base64
                 */
                nonce: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                signer_id: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                verifying_contract: string;
            };
        };
        type: MultiPayload__Parsed.type;
    };
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
    standard: MultiPayload__Parsed.standard;
    /**
     * UNIX timestamp (in seconds or RFC3339) at the time of singing
     */
    timestamp: (string | number);
});
declare namespace MultiPayload__Parsed {
    enum standard {
        NEP413 = "nep413"
    }
    enum type {
        TEXT = "text"
    }
}

/**
 * ERC-191: The standard for message signing in Ethereum, commonly used with `personal_sign()`. For more details, refer to [EIP-191](https://eips.ethereum.org/EIPS/eip-191).
 */
type MultiPayloadErc191 = {
    /**
     * See [ERC-191](https://github.com/ethereum/ercs/blob/master/ERCS/erc-191.md)
     */
    payload: string;
    /**
     * There is no public key member because the public key can be recovered via `ecrecover()` knowing the data and the signature. Encoding: base58
     */
    signature: string;
    standard: MultiPayloadErc191.standard;
};
declare namespace MultiPayloadErc191 {
    enum standard {
        ERC191 = "erc191"
    }
}

/**
 * ERC-191: The standard for message signing in Ethereum, commonly used with `personal_sign()`. For more details, refer to [EIP-191](https://eips.ethereum.org/EIPS/eip-191).
 */
type MultiPayloadErc191__Parsed = {
    payload: {
        original: string;
        parsed: {
            deadline: string;
            /**
             * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
             */
            intents?: Array<({
                intent: 'add_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'remove_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'transfer';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                tokens: Record<string, string>;
            } | {
                amount: string;
                intent: 'ft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
            } | {
                intent: 'nft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_id: string;
            } | {
                amounts: Array<string>;
                intent: 'mt_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_ids: Array<string>;
            } | {
                amount: string;
                intent: 'native_withdraw';
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
            } | {
                amount: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                contract_id: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                deposit_for_account_id: string;
                intent: 'storage_deposit';
            } | {
                diff: Record<string, string>;
                intent: 'token_diff';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                referral?: string | null;
            } | {
                enabled: boolean;
                intent: 'set_auth_by_predecessor_id';
            } | {
                /**
                 * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                 *
                 * NOTE: the `wNEAR` will not be refunded in case of fail.
                 */
                attached_deposit?: string;
                /**
                 * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                contract_id: string;
                intent: 'auth_call';
                /**
                 * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                msg: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
            } | {
                intent: 'imt_mint';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * Receiver of the minted tokens
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            } | {
                intent: 'imt_burn';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                minter_id: string;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            })>;
            /**
             * Encoding: base64
             */
            nonce: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            signer_id: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            verifying_contract: string;
        };
    };
    /**
     * There is no public key member because the public key can be recovered via `ecrecover()` knowing the data and the signature. Encoding: base58
     */
    signature: string;
    standard: MultiPayloadErc191__Parsed.standard;
};
declare namespace MultiPayloadErc191__Parsed {
    enum standard {
        ERC191 = "erc191"
    }
}

type MultiPayloadNarrowed__Parsed = ({
    standard: MultiPayloadNarrowed__Parsed.standard;
    /**
     * See [NEP-413](https://github.com/near/NEPs/blob/master/neps/nep-0413.md)
     */
    payload: {
        callbackUrl?: string | null;
        message: {
            original: string;
            parsed: {
                deadline: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                signer_id: string;
                /**
                 * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
                 */
                intents?: Array<({
                    intent: 'add_public_key';
                    /**
                     * Encoding: base58
                     */
                    public_key: string;
                } | {
                    intent: 'remove_public_key';
                    /**
                     * Encoding: base58
                     */
                    public_key: string;
                } | {
                    intent: 'transfer';
                    memo?: string | null;
                    /**
                     * Minimum gas for `mt_on_transfer()`
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_on_transfer`
                     */
                    msg?: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                    tokens: Record<string, string>;
                } | {
                    amount: string;
                    intent: 'ft_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                } | {
                    intent: 'nft_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                    token_id: string;
                } | {
                    amounts: Array<string>;
                    intent: 'mt_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                    token_ids: Array<string>;
                } | {
                    amount: string;
                    intent: 'native_withdraw';
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                } | {
                    amount: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    contract_id: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    deposit_for_account_id: string;
                    intent: 'storage_deposit';
                } | {
                    diff: Record<string, string>;
                    intent: 'token_diff';
                    memo?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    referral?: string | null;
                } | {
                    enabled: boolean;
                    intent: 'set_auth_by_predecessor_id';
                } | {
                    /**
                     * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                     *
                     * NOTE: the `wNEAR` will not be refunded in case of fail.
                     */
                    attached_deposit?: string;
                    /**
                     * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                     */
                    contract_id: string;
                    intent: 'auth_call';
                    /**
                     * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                     */
                    msg: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                } | {
                    intent: 'imt_mint';
                    memo?: string | null;
                    /**
                     * Minimum gas for `mt_on_transfer()`
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_on_transfer`
                     */
                    msg?: string;
                    /**
                     * Receiver of the minted tokens
                     */
                    receiver_id: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                    /**
                     * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                     */
                    tokens: Record<string, string>;
                } | {
                    intent: 'imt_burn';
                    memo?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    minter_id: string;
                    /**
                     * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                     */
                    tokens: Record<string, string>;
                })>;
            };
        };
        /**
         * Encoding: base64
         */
        nonce: string;
        recipient: string;
    };
} | {
    standard: MultiPayloadNarrowed__Parsed.standard;
    payload: {
        original: string;
        parsed: {
            deadline: string;
            /**
             * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
             */
            intents?: Array<({
                intent: 'add_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'remove_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'transfer';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                tokens: Record<string, string>;
            } | {
                amount: string;
                intent: 'ft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
            } | {
                intent: 'nft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_id: string;
            } | {
                amounts: Array<string>;
                intent: 'mt_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_ids: Array<string>;
            } | {
                amount: string;
                intent: 'native_withdraw';
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
            } | {
                amount: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                contract_id: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                deposit_for_account_id: string;
                intent: 'storage_deposit';
            } | {
                diff: Record<string, string>;
                intent: 'token_diff';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                referral?: string | null;
            } | {
                enabled: boolean;
                intent: 'set_auth_by_predecessor_id';
            } | {
                /**
                 * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                 *
                 * NOTE: the `wNEAR` will not be refunded in case of fail.
                 */
                attached_deposit?: string;
                /**
                 * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                contract_id: string;
                intent: 'auth_call';
                /**
                 * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                msg: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
            } | {
                intent: 'imt_mint';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * Receiver of the minted tokens
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            } | {
                intent: 'imt_burn';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                minter_id: string;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            })>;
            /**
             * Encoding: base64
             */
            nonce: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            signer_id: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            verifying_contract: string;
        };
    };
} | {
    standard: MultiPayloadNarrowed__Parsed.standard;
    payload: {
        text: {
            original: string;
            parsed: {
                deadline: string;
                /**
                 * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
                 */
                intents?: Array<({
                    intent: 'add_public_key';
                    /**
                     * Encoding: base58
                     */
                    public_key: string;
                } | {
                    intent: 'remove_public_key';
                    /**
                     * Encoding: base58
                     */
                    public_key: string;
                } | {
                    intent: 'transfer';
                    memo?: string | null;
                    /**
                     * Minimum gas for `mt_on_transfer()`
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_on_transfer`
                     */
                    msg?: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                    tokens: Record<string, string>;
                } | {
                    amount: string;
                    intent: 'ft_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                } | {
                    intent: 'nft_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                    token_id: string;
                } | {
                    amounts: Array<string>;
                    intent: 'mt_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                    token_ids: Array<string>;
                } | {
                    amount: string;
                    intent: 'native_withdraw';
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                } | {
                    amount: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    contract_id: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    deposit_for_account_id: string;
                    intent: 'storage_deposit';
                } | {
                    diff: Record<string, string>;
                    intent: 'token_diff';
                    memo?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    referral?: string | null;
                } | {
                    enabled: boolean;
                    intent: 'set_auth_by_predecessor_id';
                } | {
                    /**
                     * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                     *
                     * NOTE: the `wNEAR` will not be refunded in case of fail.
                     */
                    attached_deposit?: string;
                    /**
                     * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                     */
                    contract_id: string;
                    intent: 'auth_call';
                    /**
                     * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                     */
                    msg: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                } | {
                    intent: 'imt_mint';
                    memo?: string | null;
                    /**
                     * Minimum gas for `mt_on_transfer()`
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_on_transfer`
                     */
                    msg?: string;
                    /**
                     * Receiver of the minted tokens
                     */
                    receiver_id: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                    /**
                     * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                     */
                    tokens: Record<string, string>;
                } | {
                    intent: 'imt_burn';
                    memo?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    minter_id: string;
                    /**
                     * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                     */
                    tokens: Record<string, string>;
                })>;
                /**
                 * Encoding: base64
                 */
                nonce: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                signer_id: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                verifying_contract: string;
            };
        };
        type: MultiPayloadNarrowed__Parsed.type;
    };
});
declare namespace MultiPayloadNarrowed__Parsed {
    enum standard {
        NEP413 = "nep413"
    }
    enum type {
        TEXT = "text"
    }
}

/**
 * NEP-413: The standard for message signing in Near Protocol. For more details, refer to [NEP-413](https://github.com/near/NEPs/blob/master/neps/nep-0413.md).
 */
type MultiPayloadNep413 = {
    /**
     * See [NEP-413](https://github.com/near/NEPs/blob/master/neps/nep-0413.md)
     */
    payload: {
        callbackUrl?: string | null;
        message: string;
        /**
         * Encoding: base64
         */
        nonce: string;
        recipient: string;
    };
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
    standard: MultiPayloadNep413.standard;
};
declare namespace MultiPayloadNep413 {
    enum standard {
        NEP413 = "nep413"
    }
}

/**
 * NEP-413: The standard for message signing in Near Protocol. For more details, refer to [NEP-413](https://github.com/near/NEPs/blob/master/neps/nep-0413.md).
 */
type MultiPayloadNep413__Parsed = {
    /**
     * See [NEP-413](https://github.com/near/NEPs/blob/master/neps/nep-0413.md)
     */
    payload: {
        callbackUrl?: string | null;
        message: {
            original: string;
            parsed: {
                deadline: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                signer_id: string;
                /**
                 * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
                 */
                intents?: Array<({
                    intent: 'add_public_key';
                    /**
                     * Encoding: base58
                     */
                    public_key: string;
                } | {
                    intent: 'remove_public_key';
                    /**
                     * Encoding: base58
                     */
                    public_key: string;
                } | {
                    intent: 'transfer';
                    memo?: string | null;
                    /**
                     * Minimum gas for `mt_on_transfer()`
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_on_transfer`
                     */
                    msg?: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                    tokens: Record<string, string>;
                } | {
                    amount: string;
                    intent: 'ft_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                } | {
                    intent: 'nft_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                    token_id: string;
                } | {
                    amounts: Array<string>;
                    intent: 'mt_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                    token_ids: Array<string>;
                } | {
                    amount: string;
                    intent: 'native_withdraw';
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                } | {
                    amount: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    contract_id: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    deposit_for_account_id: string;
                    intent: 'storage_deposit';
                } | {
                    diff: Record<string, string>;
                    intent: 'token_diff';
                    memo?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    referral?: string | null;
                } | {
                    enabled: boolean;
                    intent: 'set_auth_by_predecessor_id';
                } | {
                    /**
                     * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                     *
                     * NOTE: the `wNEAR` will not be refunded in case of fail.
                     */
                    attached_deposit?: string;
                    /**
                     * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                     */
                    contract_id: string;
                    intent: 'auth_call';
                    /**
                     * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                     */
                    msg: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                } | {
                    intent: 'imt_mint';
                    memo?: string | null;
                    /**
                     * Minimum gas for `mt_on_transfer()`
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_on_transfer`
                     */
                    msg?: string;
                    /**
                     * Receiver of the minted tokens
                     */
                    receiver_id: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                    /**
                     * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                     */
                    tokens: Record<string, string>;
                } | {
                    intent: 'imt_burn';
                    memo?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    minter_id: string;
                    /**
                     * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                     */
                    tokens: Record<string, string>;
                })>;
            };
        };
        /**
         * Encoding: base64
         */
        nonce: string;
        recipient: string;
    };
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
    standard: MultiPayloadNep413__Parsed.standard;
};
declare namespace MultiPayloadNep413__Parsed {
    enum standard {
        NEP413 = "nep413"
    }
}

/**
 * Raw Ed25519: The standard used by Solana Phantom wallets for message signing. For more details, refer to [Phantom Wallet's documentation](https://docs.phantom.com/solana/signing-a-message).
 */
type MultiPayloadRawEd25519 = {
    payload: string;
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
    standard: MultiPayloadRawEd25519.standard;
};
declare namespace MultiPayloadRawEd25519 {
    enum standard {
        RAW_ED25519 = "raw_ed25519"
    }
}

/**
 * Raw Ed25519: The standard used by Solana Phantom wallets for message signing. For more details, refer to [Phantom Wallet's documentation](https://docs.phantom.com/solana/signing-a-message).
 */
type MultiPayloadRawEd25519__Parsed = {
    payload: {
        original: string;
        parsed: {
            deadline: string;
            /**
             * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
             */
            intents?: Array<({
                intent: 'add_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'remove_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'transfer';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                tokens: Record<string, string>;
            } | {
                amount: string;
                intent: 'ft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
            } | {
                intent: 'nft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_id: string;
            } | {
                amounts: Array<string>;
                intent: 'mt_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_ids: Array<string>;
            } | {
                amount: string;
                intent: 'native_withdraw';
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
            } | {
                amount: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                contract_id: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                deposit_for_account_id: string;
                intent: 'storage_deposit';
            } | {
                diff: Record<string, string>;
                intent: 'token_diff';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                referral?: string | null;
            } | {
                enabled: boolean;
                intent: 'set_auth_by_predecessor_id';
            } | {
                /**
                 * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                 *
                 * NOTE: the `wNEAR` will not be refunded in case of fail.
                 */
                attached_deposit?: string;
                /**
                 * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                contract_id: string;
                intent: 'auth_call';
                /**
                 * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                msg: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
            } | {
                intent: 'imt_mint';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * Receiver of the minted tokens
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            } | {
                intent: 'imt_burn';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                minter_id: string;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            })>;
            /**
             * Encoding: base64
             */
            nonce: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            signer_id: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            verifying_contract: string;
        };
    };
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
    standard: MultiPayloadRawEd25519__Parsed.standard;
};
declare namespace MultiPayloadRawEd25519__Parsed {
    enum standard {
        RAW_ED25519 = "raw_ed25519"
    }
}

/**
 * SEP-53: The standard for signing data off-chain for Stellar accounts. See [SEP-53](https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0053.md)
 */
type MultiPayloadSep53 = {
    payload: string;
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
    standard: MultiPayloadSep53.standard;
};
declare namespace MultiPayloadSep53 {
    enum standard {
        SEP53 = "sep53"
    }
}

/**
 * SEP-53: The standard for signing data off-chain for Stellar accounts. See [SEP-53](https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0053.md)
 */
type MultiPayloadSep53__Parsed = {
    payload: {
        original: string;
        parsed: {
            deadline: string;
            /**
             * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
             */
            intents?: Array<({
                intent: 'add_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'remove_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'transfer';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                tokens: Record<string, string>;
            } | {
                amount: string;
                intent: 'ft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
            } | {
                intent: 'nft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_id: string;
            } | {
                amounts: Array<string>;
                intent: 'mt_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_ids: Array<string>;
            } | {
                amount: string;
                intent: 'native_withdraw';
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
            } | {
                amount: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                contract_id: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                deposit_for_account_id: string;
                intent: 'storage_deposit';
            } | {
                diff: Record<string, string>;
                intent: 'token_diff';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                referral?: string | null;
            } | {
                enabled: boolean;
                intent: 'set_auth_by_predecessor_id';
            } | {
                /**
                 * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                 *
                 * NOTE: the `wNEAR` will not be refunded in case of fail.
                 */
                attached_deposit?: string;
                /**
                 * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                contract_id: string;
                intent: 'auth_call';
                /**
                 * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                msg: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
            } | {
                intent: 'imt_mint';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * Receiver of the minted tokens
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            } | {
                intent: 'imt_burn';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                minter_id: string;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            })>;
            /**
             * Encoding: base64
             */
            nonce: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            signer_id: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            verifying_contract: string;
        };
    };
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
    standard: MultiPayloadSep53__Parsed.standard;
};
declare namespace MultiPayloadSep53__Parsed {
    enum standard {
        SEP53 = "sep53"
    }
}

/**
 * TIP-191: The standard for message signing in Tron. For more details, refer to [TIP-191](https://github.com/tronprotocol/tips/blob/master/tip-191.md).
 */
type MultiPayloadTip191 = {
    /**
     * See [TIP-191](https://github.com/tronprotocol/tips/blob/master/tip-191.md)
     */
    payload: string;
    /**
     * There is no public key member because the public key can be recovered via `ecrecover()` knowing the data and the signature. Encoding: base58
     */
    signature: string;
    standard: MultiPayloadTip191.standard;
};
declare namespace MultiPayloadTip191 {
    enum standard {
        TIP191 = "tip191"
    }
}

/**
 * TIP-191: The standard for message signing in Tron. For more details, refer to [TIP-191](https://github.com/tronprotocol/tips/blob/master/tip-191.md).
 */
type MultiPayloadTip191__Parsed = {
    payload: {
        original: string;
        parsed: {
            deadline: string;
            /**
             * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
             */
            intents?: Array<({
                intent: 'add_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'remove_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'transfer';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                tokens: Record<string, string>;
            } | {
                amount: string;
                intent: 'ft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
            } | {
                intent: 'nft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_id: string;
            } | {
                amounts: Array<string>;
                intent: 'mt_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_ids: Array<string>;
            } | {
                amount: string;
                intent: 'native_withdraw';
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
            } | {
                amount: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                contract_id: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                deposit_for_account_id: string;
                intent: 'storage_deposit';
            } | {
                diff: Record<string, string>;
                intent: 'token_diff';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                referral?: string | null;
            } | {
                enabled: boolean;
                intent: 'set_auth_by_predecessor_id';
            } | {
                /**
                 * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                 *
                 * NOTE: the `wNEAR` will not be refunded in case of fail.
                 */
                attached_deposit?: string;
                /**
                 * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                contract_id: string;
                intent: 'auth_call';
                /**
                 * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                msg: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
            } | {
                intent: 'imt_mint';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * Receiver of the minted tokens
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            } | {
                intent: 'imt_burn';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                minter_id: string;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            })>;
            /**
             * Encoding: base64
             */
            nonce: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            signer_id: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            verifying_contract: string;
        };
    };
    /**
     * There is no public key member because the public key can be recovered via `ecrecover()` knowing the data and the signature. Encoding: base58
     */
    signature: string;
    standard: MultiPayloadTip191__Parsed.standard;
};
declare namespace MultiPayloadTip191__Parsed {
    enum standard {
        TIP191 = "tip191"
    }
}

/**
 * TonConnect: The standard for data signing in TON blockchain platform. For more details, refer to [TonConnect documentation](https://docs.tonconsole.com/academy/sign-data).
 */
type MultiPayloadTonConnect = {
    /**
     * Wallet address in either [Raw](https://docs.ton.org/v3/documentation/smart-contracts/addresses/address-formats#raw-address) representation or [user-friendly](https://docs.ton.org/v3/documentation/smart-contracts/addresses/address-formats#user-friendly-address) format
     */
    address: string;
    /**
     * dApp domain
     */
    domain: string;
    /**
     * See <https://docs.tonconsole.com/academy/sign-data#choosing-the-right-format>
     */
    payload: {
        text: string;
        type: MultiPayloadTonConnect.type;
    };
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
    standard: MultiPayloadTonConnect.standard;
    /**
     * UNIX timestamp (in seconds or RFC3339) at the time of singing
     */
    timestamp: (string | number);
};
declare namespace MultiPayloadTonConnect {
    enum type {
        TEXT = "text"
    }
    enum standard {
        TON_CONNECT = "ton_connect"
    }
}

/**
 * TonConnect: The standard for data signing in TON blockchain platform. For more details, refer to [TonConnect documentation](https://docs.tonconsole.com/academy/sign-data).
 */
type MultiPayloadTonConnect__Parsed = {
    /**
     * Wallet address in either [Raw](https://docs.ton.org/v3/documentation/smart-contracts/addresses/address-formats#raw-address) representation or [user-friendly](https://docs.ton.org/v3/documentation/smart-contracts/addresses/address-formats#user-friendly-address) format
     */
    address: string;
    /**
     * dApp domain
     */
    domain: string;
    payload: {
        text: {
            original: string;
            parsed: {
                deadline: string;
                /**
                 * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
                 */
                intents?: Array<({
                    intent: 'add_public_key';
                    /**
                     * Encoding: base58
                     */
                    public_key: string;
                } | {
                    intent: 'remove_public_key';
                    /**
                     * Encoding: base58
                     */
                    public_key: string;
                } | {
                    intent: 'transfer';
                    memo?: string | null;
                    /**
                     * Minimum gas for `mt_on_transfer()`
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_on_transfer`
                     */
                    msg?: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                    tokens: Record<string, string>;
                } | {
                    amount: string;
                    intent: 'ft_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                } | {
                    intent: 'nft_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                    token_id: string;
                } | {
                    amounts: Array<string>;
                    intent: 'mt_withdraw';
                    memo?: string | null;
                    /**
                     * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                     */
                    msg?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                    /**
                     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                     */
                    storage_deposit?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    token: string;
                    token_ids: Array<string>;
                } | {
                    amount: string;
                    intent: 'native_withdraw';
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    receiver_id: string;
                } | {
                    amount: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    contract_id: string;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    deposit_for_account_id: string;
                    intent: 'storage_deposit';
                } | {
                    diff: Record<string, string>;
                    intent: 'token_diff';
                    memo?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    referral?: string | null;
                } | {
                    enabled: boolean;
                    intent: 'set_auth_by_predecessor_id';
                } | {
                    /**
                     * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                     *
                     * NOTE: the `wNEAR` will not be refunded in case of fail.
                     */
                    attached_deposit?: string;
                    /**
                     * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                     */
                    contract_id: string;
                    intent: 'auth_call';
                    /**
                     * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                     */
                    msg: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                } | {
                    intent: 'imt_mint';
                    memo?: string | null;
                    /**
                     * Minimum gas for `mt_on_transfer()`
                     *
                     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                     */
                    min_gas?: string | null;
                    /**
                     * Message to pass to `mt_on_transfer`
                     */
                    msg?: string;
                    /**
                     * Receiver of the minted tokens
                     */
                    receiver_id: string;
                    /**
                     * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                     */
                    state_init?: {
                        code: ({
                            hash: string;
                        } | {
                            /**
                             * NEAR Account Identifier.
                             *
                             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                             *
                             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                             *
                             * Also see [Error kind precedence](AccountId#error-kind-precedence).
                             *
                             * ## Examples
                             *
                             * ``` use near_account_id::AccountId;
                             *
                             * let alice: AccountId = "alice.near".parse().unwrap();
                             *
                             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                             */
                            account_id: string;
                        });
                        data: Record<string, string>;
                        version: 'v1';
                    } | null;
                    /**
                     * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                     */
                    tokens: Record<string, string>;
                } | {
                    intent: 'imt_burn';
                    memo?: string | null;
                    /**
                     * NEAR Account Identifier.
                     *
                     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                     *
                     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                     *
                     * Also see [Error kind precedence](AccountId#error-kind-precedence).
                     *
                     * ## Examples
                     *
                     * ``` use near_account_id::AccountId;
                     *
                     * let alice: AccountId = "alice.near".parse().unwrap();
                     *
                     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                     */
                    minter_id: string;
                    /**
                     * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                     */
                    tokens: Record<string, string>;
                })>;
                /**
                 * Encoding: base64
                 */
                nonce: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                signer_id: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                verifying_contract: string;
            };
        };
        type: MultiPayloadTonConnect__Parsed.type;
    };
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
    standard: MultiPayloadTonConnect__Parsed.standard;
    /**
     * UNIX timestamp (in seconds or RFC3339) at the time of singing
     */
    timestamp: (string | number);
};
declare namespace MultiPayloadTonConnect__Parsed {
    enum type {
        TEXT = "text"
    }
    enum standard {
        TON_CONNECT = "ton_connect"
    }
}

/**
 * [COSE EdDSA (-8) algorithm](https://www.iana.org/assignments/cose/cose.xhtml#algorithms): ed25519 curve
 */
type MultiPayloadWebauthnEd25519 = {
    /**
     * Base64Url-encoded [authenticatorData](https://w3c.github.io/webauthn/#authenticator-data). Encoding: base64
     */
    authenticator_data: string;
    /**
     * Serialized [clientDataJSON](https://w3c.github.io/webauthn/#dom-authenticatorresponse-clientdatajson)
     */
    client_data_json: string;
    payload: string;
    standard: MultiPayloadWebauthnEd25519.standard;
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
};
declare namespace MultiPayloadWebauthnEd25519 {
    enum standard {
        WEBAUTHN = "webauthn"
    }
}

/**
 * [COSE EdDSA (-8) algorithm](https://www.iana.org/assignments/cose/cose.xhtml#algorithms): ed25519 curve
 */
type MultiPayloadWebauthnEd25519__Parsed = {
    /**
     * Base64Url-encoded [authenticatorData](https://w3c.github.io/webauthn/#authenticator-data). Encoding: base64
     */
    authenticator_data: string;
    /**
     * Serialized [clientDataJSON](https://w3c.github.io/webauthn/#dom-authenticatorresponse-clientdatajson)
     */
    client_data_json: string;
    payload: {
        original: string;
        parsed: {
            deadline: string;
            /**
             * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
             */
            intents?: Array<({
                intent: 'add_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'remove_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'transfer';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                tokens: Record<string, string>;
            } | {
                amount: string;
                intent: 'ft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
            } | {
                intent: 'nft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_id: string;
            } | {
                amounts: Array<string>;
                intent: 'mt_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_ids: Array<string>;
            } | {
                amount: string;
                intent: 'native_withdraw';
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
            } | {
                amount: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                contract_id: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                deposit_for_account_id: string;
                intent: 'storage_deposit';
            } | {
                diff: Record<string, string>;
                intent: 'token_diff';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                referral?: string | null;
            } | {
                enabled: boolean;
                intent: 'set_auth_by_predecessor_id';
            } | {
                /**
                 * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                 *
                 * NOTE: the `wNEAR` will not be refunded in case of fail.
                 */
                attached_deposit?: string;
                /**
                 * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                contract_id: string;
                intent: 'auth_call';
                /**
                 * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                msg: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
            } | {
                intent: 'imt_mint';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * Receiver of the minted tokens
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            } | {
                intent: 'imt_burn';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                minter_id: string;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            })>;
            /**
             * Encoding: base64
             */
            nonce: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            signer_id: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            verifying_contract: string;
        };
    };
    standard: MultiPayloadWebauthnEd25519__Parsed.standard;
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
};
declare namespace MultiPayloadWebauthnEd25519__Parsed {
    enum standard {
        WEBAUTHN = "webauthn"
    }
}

/**
 * [COSE ES256 (-7) algorithm](https://www.iana.org/assignments/cose/cose.xhtml#algorithms): NIST P-256 curve (a.k.a secp256r1) over SHA-256
 */
type MultiPayloadWebauthnP256 = {
    /**
     * Base64Url-encoded [authenticatorData](https://w3c.github.io/webauthn/#authenticator-data). Encoding: base64
     */
    authenticator_data: string;
    /**
     * Serialized [clientDataJSON](https://w3c.github.io/webauthn/#dom-authenticatorresponse-clientdatajson)
     */
    client_data_json: string;
    payload: string;
    standard: MultiPayloadWebauthnP256.standard;
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
};
declare namespace MultiPayloadWebauthnP256 {
    enum standard {
        WEBAUTHN = "webauthn"
    }
}

/**
 * [COSE ES256 (-7) algorithm](https://www.iana.org/assignments/cose/cose.xhtml#algorithms): NIST P-256 curve (a.k.a secp256r1) over SHA-256
 */
type MultiPayloadWebauthnP256__Parsed = {
    /**
     * Base64Url-encoded [authenticatorData](https://w3c.github.io/webauthn/#authenticator-data). Encoding: base64
     */
    authenticator_data: string;
    /**
     * Serialized [clientDataJSON](https://w3c.github.io/webauthn/#dom-authenticatorresponse-clientdatajson)
     */
    client_data_json: string;
    payload: {
        original: string;
        parsed: {
            deadline: string;
            /**
             * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
             */
            intents?: Array<({
                intent: 'add_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'remove_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'transfer';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                tokens: Record<string, string>;
            } | {
                amount: string;
                intent: 'ft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
            } | {
                intent: 'nft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_id: string;
            } | {
                amounts: Array<string>;
                intent: 'mt_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_ids: Array<string>;
            } | {
                amount: string;
                intent: 'native_withdraw';
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
            } | {
                amount: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                contract_id: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                deposit_for_account_id: string;
                intent: 'storage_deposit';
            } | {
                diff: Record<string, string>;
                intent: 'token_diff';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                referral?: string | null;
            } | {
                enabled: boolean;
                intent: 'set_auth_by_predecessor_id';
            } | {
                /**
                 * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                 *
                 * NOTE: the `wNEAR` will not be refunded in case of fail.
                 */
                attached_deposit?: string;
                /**
                 * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                contract_id: string;
                intent: 'auth_call';
                /**
                 * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                msg: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
            } | {
                intent: 'imt_mint';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * Receiver of the minted tokens
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            } | {
                intent: 'imt_burn';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                minter_id: string;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            })>;
            /**
             * Encoding: base64
             */
            nonce: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            signer_id: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            verifying_contract: string;
        };
    };
    standard: MultiPayloadWebauthnP256__Parsed.standard;
    /**
     * Encoding: base58
     */
    public_key: string;
    /**
     * Encoding: base58
     */
    signature: string;
};
declare namespace MultiPayloadWebauthnP256__Parsed {
    enum standard {
        WEBAUTHN = "webauthn"
    }
}

/**
 * Withdraw native tokens (NEAR) from the intents contract to a given external account id (external being outside of intents). This will subtract from the account's wNEAR balance, and will be sent to the account specified as native NEAR. NOTE: the `wNEAR` will not be refunded in case of fail (e.g. `receiver_id` account does not exist).
 */
type NativeWithdraw = {
    amount: string;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    receiver_id: string;
};

type Nep413DefuseMessage_for_DefuseIntents = {
    deadline: string;
    /**
     * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
     */
    intents?: Array<({
        intent: 'add_public_key';
        /**
         * Encoding: base58
         */
        public_key: string;
    } | {
        intent: 'remove_public_key';
        /**
         * Encoding: base58
         */
        public_key: string;
    } | {
        intent: 'transfer';
        memo?: string | null;
        /**
         * Minimum gas for `mt_on_transfer()`
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * Message to pass to `mt_on_transfer`
         */
        msg?: string;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        receiver_id: string;
        /**
         * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
         */
        state_init?: {
            code: ({
                hash: string;
            } | {
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                account_id: string;
            });
            data: Record<string, string>;
            version: 'v1';
        } | null;
        tokens: Record<string, string>;
    } | {
        amount: string;
        intent: 'ft_withdraw';
        memo?: string | null;
        /**
         * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
         */
        msg?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        receiver_id: string;
        /**
         * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
         */
        storage_deposit?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        token: string;
    } | {
        intent: 'nft_withdraw';
        memo?: string | null;
        /**
         * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
         */
        msg?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        receiver_id: string;
        /**
         * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
         */
        storage_deposit?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        token: string;
        token_id: string;
    } | {
        amounts: Array<string>;
        intent: 'mt_withdraw';
        memo?: string | null;
        /**
         * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
         */
        msg?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        receiver_id: string;
        /**
         * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
         */
        storage_deposit?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        token: string;
        token_ids: Array<string>;
    } | {
        amount: string;
        intent: 'native_withdraw';
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        receiver_id: string;
    } | {
        amount: string;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        contract_id: string;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        deposit_for_account_id: string;
        intent: 'storage_deposit';
    } | {
        diff: Record<string, string>;
        intent: 'token_diff';
        memo?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        referral?: string | null;
    } | {
        enabled: boolean;
        intent: 'set_auth_by_predecessor_id';
    } | {
        /**
         * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
         *
         * NOTE: the `wNEAR` will not be refunded in case of fail.
         */
        attached_deposit?: string;
        /**
         * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
         */
        contract_id: string;
        intent: 'auth_call';
        /**
         * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
         */
        msg: string;
        /**
         * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
         */
        state_init?: {
            code: ({
                hash: string;
            } | {
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                account_id: string;
            });
            data: Record<string, string>;
            version: 'v1';
        } | null;
    } | {
        intent: 'imt_mint';
        memo?: string | null;
        /**
         * Minimum gas for `mt_on_transfer()`
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * Message to pass to `mt_on_transfer`
         */
        msg?: string;
        /**
         * Receiver of the minted tokens
         */
        receiver_id: string;
        /**
         * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
         */
        state_init?: {
            code: ({
                hash: string;
            } | {
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                account_id: string;
            });
            data: Record<string, string>;
            version: 'v1';
        } | null;
        /**
         * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
         */
        tokens: Record<string, string>;
    } | {
        intent: 'imt_burn';
        memo?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        minter_id: string;
        /**
         * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
         */
        tokens: Record<string, string>;
    })>;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    signer_id: string;
};

type Nep413DefusePayload = {
    deadline: string;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    signer_id: string;
    /**
     * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
     */
    intents?: Array<({
        intent: 'add_public_key';
        /**
         * Encoding: base58
         */
        public_key: string;
    } | {
        intent: 'remove_public_key';
        /**
         * Encoding: base58
         */
        public_key: string;
    } | {
        intent: 'transfer';
        memo?: string | null;
        /**
         * Minimum gas for `mt_on_transfer()`
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * Message to pass to `mt_on_transfer`
         */
        msg?: string;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        receiver_id: string;
        /**
         * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
         */
        state_init?: {
            code: ({
                hash: string;
            } | {
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                account_id: string;
            });
            data: Record<string, string>;
            version: 'v1';
        } | null;
        tokens: Record<string, string>;
    } | {
        amount: string;
        intent: 'ft_withdraw';
        memo?: string | null;
        /**
         * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
         */
        msg?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        receiver_id: string;
        /**
         * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
         */
        storage_deposit?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        token: string;
    } | {
        intent: 'nft_withdraw';
        memo?: string | null;
        /**
         * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
         */
        msg?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        receiver_id: string;
        /**
         * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
         */
        storage_deposit?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        token: string;
        token_id: string;
    } | {
        amounts: Array<string>;
        intent: 'mt_withdraw';
        memo?: string | null;
        /**
         * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
         */
        msg?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        receiver_id: string;
        /**
         * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
         */
        storage_deposit?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        token: string;
        token_ids: Array<string>;
    } | {
        amount: string;
        intent: 'native_withdraw';
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        receiver_id: string;
    } | {
        amount: string;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        contract_id: string;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        deposit_for_account_id: string;
        intent: 'storage_deposit';
    } | {
        diff: Record<string, string>;
        intent: 'token_diff';
        memo?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        referral?: string | null;
    } | {
        enabled: boolean;
        intent: 'set_auth_by_predecessor_id';
    } | {
        /**
         * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
         *
         * NOTE: the `wNEAR` will not be refunded in case of fail.
         */
        attached_deposit?: string;
        /**
         * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
         */
        contract_id: string;
        intent: 'auth_call';
        /**
         * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
         */
        msg: string;
        /**
         * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
         */
        state_init?: {
            code: ({
                hash: string;
            } | {
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                account_id: string;
            });
            data: Record<string, string>;
            version: 'v1';
        } | null;
    } | {
        intent: 'imt_mint';
        memo?: string | null;
        /**
         * Minimum gas for `mt_on_transfer()`
         *
         * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
         */
        min_gas?: string | null;
        /**
         * Message to pass to `mt_on_transfer`
         */
        msg?: string;
        /**
         * Receiver of the minted tokens
         */
        receiver_id: string;
        /**
         * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
         */
        state_init?: {
            code: ({
                hash: string;
            } | {
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                account_id: string;
            });
            data: Record<string, string>;
            version: 'v1';
        } | null;
        /**
         * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
         */
        tokens: Record<string, string>;
    } | {
        intent: 'imt_burn';
        memo?: string | null;
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        minter_id: string;
        /**
         * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
         */
        tokens: Record<string, string>;
    })>;
};

/**
 * See [NEP-413](https://github.com/near/NEPs/blob/master/neps/nep-0413.md)
 */
type Nep413Payload__Parsed = {
    callbackUrl?: string | null;
    message: {
        original: string;
        parsed: {
            deadline: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            signer_id: string;
            /**
             * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
             */
            intents?: Array<({
                intent: 'add_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'remove_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'transfer';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                tokens: Record<string, string>;
            } | {
                amount: string;
                intent: 'ft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
            } | {
                intent: 'nft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_id: string;
            } | {
                amounts: Array<string>;
                intent: 'mt_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_ids: Array<string>;
            } | {
                amount: string;
                intent: 'native_withdraw';
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
            } | {
                amount: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                contract_id: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                deposit_for_account_id: string;
                intent: 'storage_deposit';
            } | {
                diff: Record<string, string>;
                intent: 'token_diff';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                referral?: string | null;
            } | {
                enabled: boolean;
                intent: 'set_auth_by_predecessor_id';
            } | {
                /**
                 * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                 *
                 * NOTE: the `wNEAR` will not be refunded in case of fail.
                 */
                attached_deposit?: string;
                /**
                 * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                contract_id: string;
                intent: 'auth_call';
                /**
                 * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                msg: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
            } | {
                intent: 'imt_mint';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * Receiver of the minted tokens
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            } | {
                intent: 'imt_burn';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                minter_id: string;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            })>;
        };
    };
    /**
     * Encoding: base64
     */
    nonce: string;
    recipient: string;
};

/**
 * Withdraw given NFT tokens from the intents contract to a given external account id (external being outside of intents).
 */
type NftWithdraw = {
    memo?: string | null;
    /**
     * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
     *
     * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
     */
    min_gas?: string | null;
    /**
     * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
     */
    msg?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    receiver_id: string;
    /**
     * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
     */
    storage_deposit?: string | null;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    token: string;
    token_id: string;
};

/**
 * Collects super admin accounts and accounts that have been granted permissions defined by `AccessControlRole`.
 *
 * # Data structure
 *
 * Assume `AccessControlRole` is derived for the following enum, which is then passed as `role` attribute to `AccessControllable`.
 *
 * ```rust pub enum Role { PauseManager, UnpauseManager, } ```
 *
 * Then the returned data has the following structure:
 *
 * ```ignore PermissionedAccounts { super_admins: vec!["acc1.near", "acc2.near"], roles: HashMap::from([ ("PauseManager", PermissionedAccountsPerRole { admins: vec!["acc3.near", "acc4.near"], grantees: vec!["acc5.near", "acc6.near"], }), ("UnpauseManager", PermissionedAccountsPerRole { admins: vec!["acc7.near", "acc8.near"], grantees: vec!["acc9.near", "acc10.near"], }), ]) } ```
 *
 * # Uniqueness and ordering
 *
 * Account ids returned in vectors are unique but not ordered.
 */
type PermissionedAccounts = {
    /**
     * The admins and grantees of all roles.
     */
    roles: Record<string, {
        /**
         * The accounts that have admin permissions for the role.
         */
        admins: Array<string>;
        /**
         * The accounts that have been granted the role.
         */
        grantees: Array<string>;
    }>;
    /**
     * The accounts that have super admin permissions.
     */
    super_admins: Array<string>;
};

/**
 * Collects all admins and grantees of a role.
 *
 * # Uniqueness and ordering
 *
 * Account ids returned in vectors are unique but not ordered.
 */
type PermissionedAccountsPerRole = {
    /**
     * The accounts that have admin permissions for the role.
     */
    admins: Array<string>;
    /**
     * The accounts that have been granted the role.
     */
    grantees: Array<string>;
};

type PickFirst_DateTimeint64_ = (string | number);

/**
 * 1 pip == 1/100th of bip == 0.0001%
 */
type Pips = number;

type RefreshRequestDto = {
    /**
     * Refresh token obtained from authenticate endpoint
     */
    refreshToken: string;
};

type RefreshResponseDto = {
    /**
     * New JWT access token
     */
    accessToken: string;
    /**
     * Access token expiration time in seconds
     */
    expiresIn: number;
};

type RolesConfig = {
    admins?: Record<string, Array<string>>;
    grantees?: Record<string, Array<string>>;
    super_admins?: Array<string>;
};

type SimulationOutput = {
    intents_executed: Array<{
        /**
         * Account identifier. This is the human readable UTF-8 string which is used internally to index accounts on the network and their respective state.
         *
         * This is the "referenced" version of the account ID. It is to [`AccountId`] what [`str`] is to [`String`], and works quite similarly to [`Path`]. Like with [`str`] and [`Path`], you can't have a value of type `AccountIdRef`, but you can have a reference like `&AccountIdRef` or `&mut AccountIdRef`.
         *
         * This type supports zero-copy deserialization offered by [`serde`](https://docs.rs/serde/), but cannot do the same for [`borsh`](https://docs.rs/borsh/) since the latter does not support zero-copy.
         *
         * # Examples ``` use near_account_id::{AccountId, AccountIdRef}; use std::convert::{TryFrom, TryInto};
         *
         * // Construction let alice = AccountIdRef::new("alice.near").unwrap(); assert!(AccountIdRef::new("invalid.").is_err()); ```
         *
         * [`FromStr`]: std::str::FromStr [`Path`]: std::path::Path
         */
        account_id: string;
        /**
         * Encoding: base58
         */
        intent_hash: string;
        /**
         * Encoding: base64
         */
        nonce: string;
    }>;
    /**
     * Unmatched token deltas needed to keep the invariant. If not empty, can be used along with fee to calculate `token_diff` closure.
     */
    invariant_violated?: ({
        error: SimulationOutput.error;
        unmatched_deltas: Record<string, string>;
    } | {
        error: SimulationOutput.error;
    }) | null;
    logs: Array<string>;
    min_deadline: string;
    /**
     * Additional info about current state
     */
    state: {
        /**
         * Encoding: hex
         */
        current_salt: string;
        /**
         * 1 pip == 1/100th of bip == 0.0001%
         */
        fee: number;
    };
};
declare namespace SimulationOutput {
    enum error {
        UNMATCHED_DELTAS = "unmatched_deltas"
    }
}

type StateInit = {
    code: ({
        hash: string;
    } | {
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        account_id: string;
    });
    data: Record<string, string>;
    version: StateInit.version;
};
declare namespace StateInit {
    enum version {
        V1 = "v1"
    }
}

type StateInitV1 = {
    code: ({
        hash: string;
    } | {
        /**
         * NEAR Account Identifier.
         *
         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
         *
         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
         *
         * Also see [Error kind precedence](AccountId#error-kind-precedence).
         *
         * ## Examples
         *
         * ``` use near_account_id::AccountId;
         *
         * let alice: AccountId = "alice.near".parse().unwrap();
         *
         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
         */
        account_id: string;
    });
    data: Record<string, string>;
    version: StateInitV1.version;
};
declare namespace StateInitV1 {
    enum version {
        V1 = "v1"
    }
}

type StateOutput = {
    /**
     * Encoding: hex
     */
    current_salt: string;
    /**
     * 1 pip == 1/100th of bip == 0.0001%
     */
    fee: number;
};

/**
 * Make [NEP-145](https://nomicon.io/Standards/StorageManagement#nep-145) `storage_deposit` for an `account_id` on `contract_id`. The `amount` will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in any case.
 *
 * WARNING: use this intent only if paying storage_deposit is not a prerequisite for other intents to succeed. If some intent (e.g. ft_withdraw) requires storage_deposit, then use storage_deposit field of corresponding intent instead of adding a separate `StorageDeposit` intent. This is due to the fact that intents that fire `Promise`s are not guaranteed to be executed sequentially, in the order of the provided intents in `DefuseIntents`.
 */
type StorageDeposit = {
    amount: string;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    contract_id: string;
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    deposit_for_account_id: string;
};

type String = string;

type SubmitDepositTxRequest = {
    /**
     * Transaction hash of your deposit
     */
    txHash: string;
    /**
     * Deposit address for the quote
     */
    depositAddress: string;
    /**
     * Sender account (used only for NEAR blockchain)
     */
    nearSenderAccount?: string;
    /**
     * Memo (use if deposit was submitted with one)
     */
    memo?: string;
};

type SubmitDepositTxResponse = {
    /**
     * Unique identifier for request tracing and debugging
     */
    correlationId: string;
    /**
     * Quote response from the original request
     */
    quoteResponse: QuoteResponse;
    status: SubmitDepositTxResponse.status;
    /**
     * Last time the state was updated
     */
    updatedAt: string;
    /**
     * Details of actual swaps and withdrawals
     */
    swapDetails: SwapDetails;
};
declare namespace SubmitDepositTxResponse {
    enum status {
        KNOWN_DEPOSIT_TX = "KNOWN_DEPOSIT_TX",
        PENDING_DEPOSIT = "PENDING_DEPOSIT",
        INCOMPLETE_DEPOSIT = "INCOMPLETE_DEPOSIT",
        PROCESSING = "PROCESSING",
        SUCCESS = "SUCCESS",
        REFUNDED = "REFUNDED",
        FAILED = "FAILED"
    }
}

type SubmitIntentResponse = {
    /**
     * The hash of the submitted intent
     */
    intentHash: string;
    /**
     * Unique identifier for tracing this request
     */
    correlationId: string;
};

type SubmitSwapTransferIntentRequest = {
    /**
     * The type of intent action
     */
    type: SubmitSwapTransferIntentRequest.type;
    signedData: MultiPayload;
};
declare namespace SubmitSwapTransferIntentRequest {
    /**
     * The type of intent action
     */
    enum type {
        SWAP_TRANSFER = "swap_transfer"
    }
}

type Token = {
    /**
     * NEAR Account Identifier.
     *
     * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
     *
     * [See the crate-level docs for information about validation.](index.html#account-id-rules)
     *
     * Also see [Error kind precedence](AccountId#error-kind-precedence).
     *
     * ## Examples
     *
     * ``` use near_account_id::AccountId;
     *
     * let alice: AccountId = "alice.near".parse().unwrap();
     *
     * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
     */
    owner_id?: string | null;
    token_id: string;
};

type TokenResponse = {
    /**
     * Unique asset identifier
     */
    assetId: string;
    /**
     * Number of decimals for the token
     */
    decimals: number;
    /**
     * Blockchain associated with the token
     */
    blockchain: TokenResponse.blockchain;
    /**
     * Token symbol (e.g. BTC, ETH)
     */
    symbol: string;
    /**
     * Current price of the token in USD
     */
    price: number;
    /**
     * Date when the token price was last updated
     */
    priceUpdatedAt: string;
    /**
     * Contract address of the token
     */
    contractAddress?: string;
    /**
     * CoinGecko coin id, when known. Use it to fetch price history from CoinGecko.
     */
    coingeckoId?: string;
};
declare namespace TokenResponse {
    /**
     * Blockchain associated with the token
     */
    enum blockchain {
        NEAR = "near",
        ETH = "eth",
        BASE = "base",
        ARB = "arb",
        BTC = "btc",
        SOL = "sol",
        TON = "ton",
        DASH = "dash",
        DOGE = "doge",
        XRP = "xrp",
        ZEC = "zec",
        GNOSIS = "gnosis",
        BERA = "bera",
        BSC = "bsc",
        POL = "pol",
        TRON = "tron",
        SUI = "sui",
        MOVEMENT = "movement",
        OP = "op",
        AVAX = "avax",
        STELLAR = "stellar",
        APTOS = "aptos",
        CARDANO = "cardano",
        LTC = "ltc",
        XLAYER = "xlayer",
        MONAD = "monad",
        BCH = "bch",
        ADI = "adi",
        PLASMA = "plasma",
        SCROLL = "scroll",
        STARKNET = "starknet",
        ALEO = "aleo",
        HYPERCORE = "hypercore"
    }
}

type TonConnectPayloadSchema__Parsed = {
    text: {
        original: string;
        parsed: {
            deadline: string;
            /**
             * Sequence of intents to execute in given order. Empty list is also a valid sequence, i.e. it doesn't do anything, but still invalidates the `nonce` for the signer WARNING: Promises created by different intents are executed concurrently and does not rely on the order of the intents in this structure
             */
            intents?: Array<({
                intent: 'add_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'remove_public_key';
                /**
                 * Encoding: base58
                 */
                public_key: string;
            } | {
                intent: 'transfer';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                tokens: Record<string, string>;
            } | {
                amount: string;
                intent: 'ft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `ft_transfer`:      minimum: 15TGas, default: 15TGas * `ft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `ft_transfer_call`. Otherwise, `ft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
            } | {
                intent: 'nft_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed: * `nft_transfer`:      minimum: 15TGas, default: 15TGas * `nft_transfer_call`: minimum: 30TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `nft_transfer_call`. Otherwise, `nft_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_id: string;
            } | {
                amounts: Array<string>;
                intent: 'mt_withdraw';
                memo?: string | null;
                /**
                 * Optional minimum required Near gas for created Promise to succeed per token: * `mt_batch_transfer`:      minimum: 20TGas, default: 20TGas * `mt_batch_transfer_call`: minimum: 35TGas, default: 50TGas
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_batch_transfer_call`. Otherwise, `mt_batch_transfer` will be used. NOTE: No refund will be made in case of insufficient `storage_deposit` on `token` for `receiver_id`
                 */
                msg?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
                /**
                 * Optionally make `storage_deposit` for `receiver_id` on `token`. The amount will be subtracted from user's NEP-141 `wNEAR` balance. NOTE: the `wNEAR` will not be refunded in case of fail
                 */
                storage_deposit?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                token: string;
                token_ids: Array<string>;
            } | {
                amount: string;
                intent: 'native_withdraw';
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                receiver_id: string;
            } | {
                amount: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                contract_id: string;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                deposit_for_account_id: string;
                intent: 'storage_deposit';
            } | {
                diff: Record<string, string>;
                intent: 'token_diff';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                referral?: string | null;
            } | {
                enabled: boolean;
                intent: 'set_auth_by_predecessor_id';
            } | {
                /**
                 * Optionally, attach deposit to [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth) call. The amount will be subtracted from user's NEP-141 `wNEAR` balance.
                 *
                 * NOTE: the `wNEAR` will not be refunded in case of fail.
                 */
                attached_deposit?: string;
                /**
                 * Callee for [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                contract_id: string;
                intent: 'auth_call';
                /**
                 * Optional minimum gas required for created promise to succeed. By default, only [`MIN_GAS_DEFAULT`](AuthCall::MIN_GAS_DEFAULT) is required.
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * `msg` to pass in [`.on_auth`](::defuse_auth_call::AuthCallee::on_auth)
                 */
                msg: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling [`.on_auth()`](::defuse_auth_call::AuthCallee::on_auth) (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
            } | {
                intent: 'imt_mint';
                memo?: string | null;
                /**
                 * Minimum gas for `mt_on_transfer()`
                 *
                 * Remaining gas will be distributed evenly across all Function Call Promises created during execution of current receipt.
                 */
                min_gas?: string | null;
                /**
                 * Message to pass to `mt_on_transfer`
                 */
                msg?: string;
                /**
                 * Receiver of the minted tokens
                 */
                receiver_id: string;
                /**
                 * Optionally initialize the receiver's contract (Deterministic AccountId) via [`state_init`](https://github.com/near/NEPs/blob/master/neps/nep-0616.md#stateinit-action) right before calling `mt_on_transfer()` (in the same receipt).
                 */
                state_init?: {
                    code: ({
                        hash: string;
                    } | {
                        /**
                         * NEAR Account Identifier.
                         *
                         * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                         *
                         * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                         *
                         * Also see [Error kind precedence](AccountId#error-kind-precedence).
                         *
                         * ## Examples
                         *
                         * ``` use near_account_id::AccountId;
                         *
                         * let alice: AccountId = "alice.near".parse().unwrap();
                         *
                         * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                         */
                        account_id: string;
                    });
                    data: Record<string, string>;
                    version: 'v1';
                } | null;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority (i.e. signer of this intent). The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            } | {
                intent: 'imt_burn';
                memo?: string | null;
                /**
                 * NEAR Account Identifier.
                 *
                 * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
                 *
                 * [See the crate-level docs for information about validation.](index.html#account-id-rules)
                 *
                 * Also see [Error kind precedence](AccountId#error-kind-precedence).
                 *
                 * ## Examples
                 *
                 * ``` use near_account_id::AccountId;
                 *
                 * let alice: AccountId = "alice.near".parse().unwrap();
                 *
                 * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
                 */
                minter_id: string;
                /**
                 * The token_ids will be wrapped to bind the token ID to the minter authority. The final string representation of the token will be as follows: `imt:<minter_id>:<token_id>`
                 */
                tokens: Record<string, string>;
            })>;
            /**
             * Encoding: base64
             */
            nonce: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            signer_id: string;
            /**
             * NEAR Account Identifier.
             *
             * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
             *
             * [See the crate-level docs for information about validation.](index.html#account-id-rules)
             *
             * Also see [Error kind precedence](AccountId#error-kind-precedence).
             *
             * ## Examples
             *
             * ``` use near_account_id::AccountId;
             *
             * let alice: AccountId = "alice.near".parse().unwrap();
             *
             * assert!("ƒelicia.near".parse::<AccountId>().is_err()); // (ƒ is not f) ```
             */
            verifying_contract: string;
        };
    };
    type: TonConnectPayloadSchema__Parsed.type;
};
declare namespace TonConnectPayloadSchema__Parsed {
    enum type {
        TEXT = "text"
    }
}

type TonConnectPayloadSchemaText = {
    text: string;
    type: TonConnectPayloadSchemaText.type;
};
declare namespace TonConnectPayloadSchemaText {
    enum type {
        TEXT = "text"
    }
}

declare class AccountService {
    /**
     * Get user token balances
     * Returns token balances for the authenticated user from private balance sources
     * @param tokenIds Comma-separated list of token IDs to query. If empty, returns all non-zero balances.
     * @returns GetBalancesResponse
     * @throws ApiError
     */
    static getBalances(tokenIds?: Array<string>): CancelablePromise<GetBalancesResponse>;
    /**
     * Get transaction history
     * Returns paginated public and confidential transaction history. For the initial request, omit both nextCursor and prevCursor to retrieve the latest history. For subsequent requests, pass either nextCursor or prevCursor from the previous response.
     * @param prevCursor Pass the prevCursor value from a previous response to fetch older items. Omit both cursors for the initial request. Do not pass together with nextCursor.
     * @param nextCursor Pass the nextCursor value from a previous response to poll for newer items. Omit both cursors for the initial request. Do not pass together with prevCursor.
     * @param status Filter by statuses
     * @param limit Maximum number of items to return per page
     * @param depositAddress Filter by deposit address
     * @param depositMemo Filter by deposit memo. Only has effect when depositAddress is also provided.
     * @param search Search by deposit address, recipient, sender, or tx hash
     * @param depositType Correlated deposit type filter. Index-aligned with recipientType and refundType. Use "null" as a wildcard for that position. Multiple values form OR conditions.
     * @param recipientType Correlated recipient type filter. Index-aligned with depositType and refundType. Use "null" as a wildcard for that position.
     * @param refundType Correlated refund type filter. Index-aligned with depositType and recipientType. Use "null" as a wildcard for that position.
     * @returns HistoryResponse
     * @throws ApiError
     */
    static getHistory(prevCursor?: string, nextCursor?: string, status?: Array<'PENDING_DEPOSIT' | 'INCOMPLETE_DEPOSIT' | 'PROCESSING' | 'SUCCESS' | 'REFUNDED' | 'FAILED'>, limit?: number, depositAddress?: string, depositMemo?: string, search?: string, depositType?: Array<'ORIGIN_CHAIN' | 'INTENTS' | 'CONFIDENTIAL_INTENTS' | 'null'>, recipientType?: Array<'DESTINATION_CHAIN' | 'INTENTS' | 'CONFIDENTIAL_INTENTS' | 'null'>, refundType?: Array<'ORIGIN_CHAIN' | 'INTENTS' | 'CONFIDENTIAL_INTENTS' | 'null'>): CancelablePromise<HistoryResponse>;
}

declare class OneClickService {
    /**
     * Get supported tokens
     * Retrieves a list of tokens currently supported by the 1Click API for asset swaps.
     *
     * Each token entry includes its blockchain, contract address (if available), price in USD, and other metadata such as symbol and decimals.
     * @returns TokenResponse
     * @throws ApiError
     */
    static getTokens(): CancelablePromise<Array<TokenResponse>>;
    /**
     * Request a swap quote
     * Generates a swap quote based on input parameters such as the assets, amount, slippage tolerance, and recipient/refund information.
     *
     * Returns pricing details, estimated time, and a unique **deposit address** to which tokens must be transferred to initiate the swap.
     *
     * You can set the `dry` parameter to `true` to simulate the quote request **without generating a deposit address** or initiating the swap process. This is useful for previewing swap parameters or validating input data without committing to an actual swap.
     *
     * This endpoint is the first required step in the swap process.
     * @param requestBody
     * @returns QuoteResponse
     * @throws ApiError
     */
    static getQuote(requestBody: QuoteRequest): CancelablePromise<QuoteResponse>;
    /**
     * Check swap execution status
     * Retrieves the current status of a swap using the unique deposit address from the quote, if quote response included deposit memo, it is required as well.
     *
     * The response includes the state of the swap (e.g., pending, processing, success, refunded) and any associated swap and transaction details.
     * @param depositAddress
     * @param depositMemo
     * @returns GetExecutionStatusResponse
     * @throws ApiError
     */
    static getExecutionStatus(depositAddress: string, depositMemo?: string): CancelablePromise<GetExecutionStatusResponse>;
    /**
     * Get ANY_INPUT withdrawals
     * Retrieves all withdrawals by ANY_INPUT quote with filtering, pagination and sorting
     * @param depositAddress
     * @param depositMemo
     * @param timestampFrom Filter withdrawals from this timestamp (ISO string)
     * @param page Page number for pagination (default: 1)
     * @param limit Number of withdrawals per page (max: 50, default: 50)
     * @param sortOrder Sort order
     * @returns GetAnyInputQuoteWithdrawals
     * @throws ApiError
     */
    static getAnyInputQuoteWithdrawals(depositAddress: string, depositMemo?: string, timestampFrom?: string, page?: number, limit?: number, sortOrder?: 'asc' | 'desc'): CancelablePromise<GetAnyInputQuoteWithdrawals>;
    /**
     * Submit deposit transaction hash
     * Optionally notifies the 1Click service that a deposit has been sent to the specified address, using the blockchain transaction hash.
     *
     * This step can speed up swap processing by allowing the system to preemptively verify the deposit.
     * @param requestBody
     * @returns SubmitDepositTxResponse
     * @throws ApiError
     */
    static submitDepositTx(requestBody: SubmitDepositTxRequest): CancelablePromise<SubmitDepositTxResponse>;
    /**
     * Generate an intent for signing
     * Generates an unsigned intent payload that needs to be signed by the user.
     *
     * This endpoint takes a quote's deposit address and other parameters, validates the quote state, and returns an intent payload formatted according to the specified signing standard (e.g., NEP413, ERC191).
     *
     * The generated intent must be signed by the user's wallet and then submitted via the `/submit-intent` endpoint to complete the action (e.g. swap).
     *
     * **Request Type Variants:**
     * - `swap_transfer`: Generate an intent for a swap operation (requires depositAddress, signerId, standard)
     * @param requestBody
     * @returns GenerateIntentResponse Successfully generated intent payload
     * @throws ApiError
     */
    static generateIntent(requestBody: GenerateSwapTransferIntentRequest): CancelablePromise<GenerateIntentResponse>;
    /**
     * Submit a signed intent
     * Submits a signed intent to execute.
     *
     * After generating an intent via `/generate-intent` and having the user sign it with their wallet, submit the signed intent through this endpoint.
     *
     * The system validates the signature, processes the intent, and returns the intent hash upon successful submission.
     *
     * **Request Type Variants:**
     * - `swap_transfer`: Submit a signed swap intent (requires signedData object)
     * @param requestBody
     * @returns SubmitIntentResponse Successfully submitted intent
     * @throws ApiError
     */
    static submitIntent(requestBody: SubmitSwapTransferIntentRequest): CancelablePromise<SubmitIntentResponse>;
}

declare class UserAuthService {
    /**
     * Authenticate user with signed data
     * Verifies wallet signature and issues session tokens
     * @param requestBody
     * @returns AuthenticateResponseDto
     * @throws ApiError
     */
    static authenticate(requestBody: AuthenticateRequestDto): CancelablePromise<AuthenticateResponseDto>;
    /**
     * Refresh access token
     * Exchange refresh token for a new access token
     * @param requestBody
     * @returns RefreshResponseDto
     * @throws ApiError
     */
    static refresh(requestBody: RefreshRequestDto): CancelablePromise<RefreshResponseDto>;
}

type OneClickQuoteRequest = QuoteRequest;
type OneClickQuote = Quote;
type OneClickQuoteResponse = QuoteResponse;
type OneClickSignedQuoteRequest = {
    dry: QuoteRequest['dry'];
    swapType: QuoteRequest['swapType'];
    slippageTolerance: QuoteRequest['slippageTolerance'];
    originAsset: QuoteRequest['originAsset'];
    depositType: QuoteRequest['depositType'];
    destinationAsset: QuoteRequest['destinationAsset'];
    amount: QuoteRequest['amount'];
    refundTo: QuoteRequest['refundTo'];
    refundType: QuoteRequest['refundType'];
    recipient: QuoteRequest['recipient'];
    recipientType: QuoteRequest['recipientType'];
    deadline: QuoteRequest['deadline'];
    quoteWaitingTimeMs?: QuoteRequest['quoteWaitingTimeMs'];
    referral?: QuoteRequest['referral'];
    virtualChainRecipient?: QuoteRequest['virtualChainRecipient'];
    virtualChainRefundRecipient?: QuoteRequest['virtualChainRefundRecipient'];
    customRecipientMsg?: QuoteRequest['customRecipientMsg'];
    sessionId?: undefined;
    connectedWallets?: undefined;
    correlationId?: undefined;
    appFees?: undefined;
    partnerId?: undefined;
    userAccountId?: undefined;
    depositMode?: undefined;
};
type OneClickDrySignedQuote = {
    amountIn: Quote['amountIn'];
    amountInFormatted: Quote['amountInFormatted'];
    amountInUsd: Quote['amountInUsd'];
    minAmountIn: Quote['minAmountIn'];
    amountOut: Quote['amountOut'];
    amountOutFormatted: Quote['amountOutFormatted'];
    amountOutUsd: Quote['amountOutUsd'];
    minAmountOut: Quote['minAmountOut'];
};
type OneClickFullSignedQuote = OneClickDrySignedQuote & {
    depositAddress?: Quote['depositAddress'];
    depositMemo?: Quote['depositMemo'];
    deadline?: Quote['deadline'];
    timeWhenInactive?: Quote['timeWhenInactive'];
    timeEstimate?: Quote['timeEstimate'];
    virtualChainRecipient?: Quote['virtualChainRecipient'];
    virtualChainRefundRecipient?: Quote['virtualChainRefundRecipient'];
    customRecipientMsg?: Quote['customRecipientMsg'];
    refundFee?: Quote['refundFee'];
    withdrawFee?: Quote['withdrawFee'];
};
declare function hashQuote(request: OneClickSignedQuoteRequest, quote: OneClickDrySignedQuote | OneClickFullSignedQuote, timestamp: string): string;
declare function quoteHash(response: OneClickQuoteResponse): string;
declare function verifyQuoteSignature(response: OneClickQuoteResponse, managerPublicKey?: string): boolean;

export { AccountService, AnyInputQuoteWithdrawal, ApiError, type AppFee, AuthCall, type AuthenticateRequestDto, type AuthenticateResponseDto, type BadRequestResponse, BalanceEntry, CancelError, CancelablePromise, ChainDepositAddress, type Deadline, type DefuseConfig, type DefusePayload_for_DefuseIntents, type Erc191Payload, type FeesConfig, type FtWithdraw, type GenerateIntentResponse, GenerateSwapTransferIntentRequest, type GetAnyInputQuoteWithdrawals, type GetBalancesResponse, GetExecutionStatusResponse, type GlobalContractId, HistoryItem, type HistoryResponse, Intent, IntentAddPublicKey, IntentAuthCall, type IntentEvent_for_AccountEvent_for_NonceEvent, IntentFtWithdraw, IntentImtBurn, IntentImtMint, IntentMtWithdraw, IntentNativeWithdraw, IntentNftWithdraw, IntentRemovePublicKey, IntentSetAuthByPredecessorId, IntentStandardEnum, IntentStorageDeposit, IntentTokenDiff, IntentTransfer, InvariantViolated, InvariantViolatedOverflow, InvariantViolatedUnmatchedDeltas, type MtWithdraw, MultiPayload, MultiPayloadErc191, type MultiPayloadErc191Narrowed, MultiPayloadErc191__Parsed, type MultiPayloadNarrowed, MultiPayloadNarrowed__Parsed, MultiPayloadNep413, type MultiPayloadNep413Narrowed, MultiPayloadNep413__Parsed, MultiPayloadRawEd25519, type MultiPayloadRawEd25519Narrowed, MultiPayloadRawEd25519__Parsed, MultiPayloadSep53, type MultiPayloadSep53Narrowed, MultiPayloadSep53__Parsed, MultiPayloadTip191, type MultiPayloadTip191Narrowed, MultiPayloadTip191__Parsed, MultiPayloadTonConnect, type MultiPayloadTonConnectNarrowed, MultiPayloadTonConnect__Parsed, MultiPayloadWebauthnEd25519, MultiPayloadWebauthnEd25519__Parsed, type MultiPayloadWebauthnNarrowed, MultiPayloadWebauthnP256, MultiPayloadWebauthnP256__Parsed, MultiPayload__Parsed, type NativeWithdraw, type Nep413DefuseMessage_for_DefuseIntents, type Nep413DefusePayload, type Nep413Payload, type Nep413Payload__Parsed, type NftWithdraw, type OneClickDrySignedQuote, type OneClickFullSignedQuote, type OneClickQuote, type OneClickQuoteRequest, type OneClickQuoteResponse, OneClickService, type OneClickSignedQuoteRequest, OpenAPI, type OpenAPIConfig, type PermissionedAccounts, type PermissionedAccountsPerRole, type PickFirst_DateTimeint64_, type Pips, type Quote, QuoteRequest, type QuoteResponse, type Rebate, type RefreshRequestDto, type RefreshResponseDto, type RolesConfig, SimulationOutput, StateInit, StateInitV1, type StateOutput, type StorageDeposit, type String, type SubmitDepositTxRequest, SubmitDepositTxResponse, type SubmitIntentResponse, SubmitSwapTransferIntentRequest, type SwapDetails, type Tip191Payload, type Token, TokenResponse, TonConnectPayloadSchema, TonConnectPayloadSchemaText, TonConnectPayloadSchema__Parsed, type TransactionDetails, UserAuthService, hashQuote, quoteHash, verifyQuoteSignature };