import { APIResource } from "../../core/resource.mjs";
import * as WalletsAPI from "./wallets.mjs";
import * as AppsAPI from "../apps.mjs";
import * as SharedAPI from "../shared.mjs";
import * as WalletAutomationsAPI from "../wallet-automations.mjs";
import * as ActionsAPI from "./actions.mjs";
import { AaveVaultDetails, Actions, CustodianTransactionWalletActionStep, CustodianTransactionWalletActionStepStatus, EarnAsset, EarnDepositActionResponse, EarnDepositRequestBody, EarnFeeCollectActionResponse, EarnFeeCollectRequestBody, EarnIncentiveClaimActionResponse, EarnIncentiveClaimRequestBody, EarnIncentiveRewardEntry, EarnIncentiveRewardsQuery, EarnIncentiveRewardsResponse, EarnIncetiveClaimRewardEntry, EarnWithdrawActionResponse, EarnWithdrawRequestBody, EthereumEarnPositionQuery, EthereumEarnPositionResponse, EthereumEarnProvider, EthereumEarnVaultDetailsResponse, EvmTransactionWalletActionStep, EvmUserOperationEntrypointVersion, EvmUserOperationWalletActionStep, EvmWalletActionStepStatus, ExternalTransactionWalletActionStep, ExternalTransactionWalletActionStepStatus, FailureReason, ListWalletActionsQuery, ListWalletActionsResponse, MorphoVaultDetails, PayoutResponse, SvmTransactionWalletActionStep, SvmWalletActionStepStatus, SwapActionResponse, TempoVaultDetails, TransferActionResponse, TvmTransactionWalletActionStep, TvmWalletActionStepStatus, VedaVaultDetails, WalletActionInclude, WalletActionResponse, WalletActionStatus, WalletActionStep, WalletActionStepType, WalletActionType } from "./actions.mjs";
import * as BalanceAPI from "./balance.mjs";
import { Balance, BalanceGetParams, BalanceGetResponse } from "./balance.mjs";
import * as TransactionsAPI from "./transactions.mjs";
import { TransactionGetParams, TransactionGetResponse, Transactions } from "./transactions.mjs";
import { APIPromise } from "../../core/api-promise.mjs";
import { Cursor, type CursorParams, PagePromise } from "../../core/pagination.mjs";
import { RequestOptions } from "../../internal/request-options.mjs";
/**
 * Operations related to wallets
 */
export declare class Wallets extends APIResource {
    balance: BalanceAPI.Balance;
    transactions: TransactionsAPI.Transactions;
    actions: ActionsAPI.Actions;
    /**
     * Creates a new wallet on the requested chain and for the requested owner.
     *
     * @example
     * ```ts
     * const wallet = await client.wallets.create({
     *   chain_type: 'ethereum',
     * });
     * ```
     */
    create(params: WalletCreateParams, options?: RequestOptions): APIPromise<Wallet>;
    /**
     * Update a wallet's policies or authorization key configuration.
     *
     * @example
     * ```ts
     * const wallet = await client.wallets.update('wallet_id', {
     *   policy_ids: ['tb54eps4z44ed0jepousxi4n'],
     * });
     * ```
     */
    update(walletID: string, params: WalletUpdateParams, options?: RequestOptions): APIPromise<Wallet>;
    /**
     * Get all wallets in your app.
     *
     * @example
     * ```ts
     * // Automatically fetches more pages as needed.
     * for await (const wallet of client.wallets.list()) {
     *   // ...
     * }
     * ```
     */
    list(query?: WalletListParams | null | undefined, options?: RequestOptions): PagePromise<WalletsCursor, Wallet>;
    /**
     * Archives a wallet, preventing it from being used in any write or signing
     * operations. Archived wallets are hidden from list endpoints by default. Returns
     * 404 if the wallet does not exist or is already archived.
     *
     * @example
     * ```ts
     * const wallet = await client.wallets.archive('wallet_id');
     * ```
     */
    archive(walletID: string, options?: RequestOptions): APIPromise<Wallet>;
    /**
     * Export a wallet's private key
     *
     * @example
     * ```ts
     * const walletExportResponseBody =
     *   await client.wallets.export('wallet_id', {
     *     encryption_type: 'HPKE',
     *     recipient_public_key:
     *       'BDAZLOIdTaPycEYkgG0MvCzbIKJLli/yWkAV5yCa9yOsZ4JsrLweA5MnP8YIiY4k/RRzC+APhhO+P+Hoz/rt7Go=',
     *   });
     * ```
     */
    export(walletID: string, params: WalletExportParams, options?: RequestOptions): APIPromise<WalletExportResponseBody>;
    /**
     * Get a wallet by wallet ID.
     *
     * @example
     * ```ts
     * const wallet = await client.wallets.get('wallet_id');
     * ```
     */
    get(walletID: string, query?: WalletGetParams | null | undefined, options?: RequestOptions): APIPromise<Wallet>;
    /**
     * Sign a message with a wallet by wallet ID.
     *
     * @example
     * ```ts
     * const rawSignResponse = await client.wallets.rawSign(
     *   'wallet_id',
     *   {
     *     params: {
     *       bytes:
     *         '0a0234ea220809701d7a17a77e04408093e981a6335a66080112620a2d747970652e676f6f676c65617069732e636f6d2f70726f746f636f6c2e5472616e73666572436f6e747261637412310a15417009bf59e27d2031a23a61e1590289fc3d21b3cd121541132b98ed6fb80a2d45f177cdef091ae2d9dc115418e80770a0bee581a633',
     *       encoding: 'hex',
     *       hash_function: 'sha256',
     *     },
     *   },
     * );
     * ```
     */
    rawSign(walletID: string, params: WalletRawSignParams, options?: RequestOptions): APIPromise<RawSignResponse>;
    /**
     * Sign a message or transaction with a wallet by wallet ID.
     *
     * @example
     * ```ts
     * const walletRpcResponse = await client.wallets.rpc(
     *   'wallet_id',
     *   {
     *     method: 'eth_sendTransaction',
     *     params: {
     *       transaction: {
     *         to: '0x0000000000000000000000000000000000000000',
     *         value: 1,
     *       },
     *     },
     *     chain_type: 'ethereum',
     *   },
     * );
     * ```
     */
    rpc(walletID: string, params: WalletRpcParams, options?: RequestOptions): APIPromise<WalletRpcResponse>;
}
export type WalletsCursor = Cursor<Wallet>;
/**
 * An entry in an EIP-2930 access list, specifying an address and its storage keys.
 */
export interface AccessListEntry {
    address: string;
    storage_keys: Array<Hex>;
}
/**
 * Additional signers for the wallet.
 */
export type AdditionalSignerInput = Array<AdditionalSignerItemInput>;
/**
 * A single additional signer for a wallet, with an optional policy override.
 */
export interface AdditionalSignerItemInput {
    /**
     * A unique identifier for a key quorum.
     */
    signer_id: SharedAPI.KeyQuorumID;
    /**
     * An optional list of up to one policy ID to enforce on the wallet.
     */
    override_policy_ids?: PolicyInput;
}
/**
 * A blockchain wallet address. Ethereum addresses are normalized to EIP-55
 * checksum format. Solana addresses are validated as base58. All other chain
 * addresses (Stellar, Tron, Sui, Aptos, etc.) are accepted as-is.
 */
export type Address = string;
/**
 * Platform fee collected on a swap.
 */
export interface AdvancedSwapPlatformFee {
    /**
     * Token the fee was taken from (output token in v1).
     */
    token: string;
    /**
     * Fee amount in the smallest unit of the fee token.
     */
    amount: string;
    /**
     * Fee in basis points.
     */
    bps: number;
}
/**
 * Request body for initiating a synchronous Solana token swap through an embedded
 * wallet.
 */
export interface AdvancedSwapRequestBody {
    /**
     * Amount in the smallest unit of the input token (e.g. lamports for SOL).
     */
    amount: string;
    /**
     * Input token address (base58 mint address).
     */
    input_token: string;
    /**
     * Output token address (base58 mint address).
     */
    output_token: string;
    /**
     * CAIP-2 chain identifier. Defaults to Solana mainnet.
     */
    caip2?: string;
    /**
     * When true, skip transaction submission (quote + sign only). The signed
     * transaction is still returned.
     */
    dry_run?: boolean;
    /**
     * Token account (base58) to receive the platform fee. Must exist on-chain for the
     * output token.
     */
    fee_recipient?: string;
    /**
     * Platform fee in basis points, taken from the output token. Requires
     * fee_recipient when > 0.
     */
    platform_fee_bps?: number;
    /**
     * Max slippage tolerance in basis points (0-10000), or "auto" for
     * provider-determined. Defaults to "auto".
     */
    slippage_bps?: number | 'auto';
}
/**
 * Response from the synchronous Solana swap endpoint.
 */
export interface AdvancedSwapResponse {
    /**
     * Input amount consumed (smallest unit).
     */
    in_amount: string;
    /**
     * Input token address (base58).
     */
    input_token: string;
    /**
     * Minimum output amount guaranteed by slippage tolerance (smallest unit).
     */
    min_out_amount: string;
    /**
     * Expected output amount before slippage (smallest unit).
     */
    out_amount: string;
    /**
     * Output token address (base58).
     */
    output_token: string;
    /**
     * Which aggregator fulfilled the swap (e.g. "dflow").
     */
    provider: string;
    /**
     * Fully signed transaction (base64). Callers can re-submit to any Solana RPC for
     * redundancy.
     */
    signed_transaction: string;
    /**
     * Slippage applied in basis points. Reflects the resolved value if "auto" was
     * requested.
     */
    slippage_bps: number;
    /**
     * "accepted" if the network has acknowledged the transaction, "rejected" if the
     * network refused it, "skipped" if dry_run was set. Not an onchain confirmation.
     */
    submission_status: SwapSubmissionStatus;
    /**
     * Solana transaction signature (base58).
     */
    transaction_hash: string;
    /**
     * Platform fee collected on a swap.
     */
    platform_fee?: AdvancedSwapPlatformFee;
}
/**
 * Whether the amount refers to the input token or output token.
 */
export type AmountType = 'exact_input' | 'exact_output';
/**
 * A non-empty, 0x-prefixed, even-length BCS hex string.
 */
export type AptosBcsHex = string;
/**
 * Executes the Aptos `aptos_signTransaction` RPC to sign a legacy single-signer
 * Ed25519 RawTransaction. The caller is responsible for broadcasting.
 */
export interface AptosRpcInput {
    method: 'aptos_signTransaction';
    /**
     * Parameters for the Aptos `aptos_signTransaction` RPC.
     */
    params: AptosSignTransactionRpcInputParams;
}
/**
 * Response to the Aptos `aptos_signTransaction` RPC.
 */
export interface AptosRpcResponse {
    /**
     * Data returned by the Aptos `aptos_signTransaction` RPC.
     */
    data: AptosSignTransactionRpcResponseData;
    method: 'aptos_signTransaction';
}
/**
 * Executes the Aptos `aptos_signTransaction` RPC to sign a legacy single-signer
 * Ed25519 RawTransaction. The caller is responsible for broadcasting.
 */
export interface AptosSignTransactionRpcInput {
    method: 'aptos_signTransaction';
    /**
     * Parameters for the Aptos `aptos_signTransaction` RPC.
     */
    params: AptosSignTransactionRpcInputParams;
}
/**
 * Parameters for the Aptos `aptos_signTransaction` RPC.
 */
export interface AptosSignTransactionRpcInputParams {
    /**
     * A non-empty, 0x-prefixed, even-length BCS hex string.
     */
    transaction: AptosBcsHex;
}
/**
 * Response to the Aptos `aptos_signTransaction` RPC.
 */
export interface AptosSignTransactionRpcResponse {
    /**
     * Data returned by the Aptos `aptos_signTransaction` RPC.
     */
    data: AptosSignTransactionRpcResponseData;
    method: 'aptos_signTransaction';
}
/**
 * Data returned by the Aptos `aptos_signTransaction` RPC.
 */
export interface AptosSignTransactionRpcResponseData {
    encoding: 'hex';
    /**
     * A non-empty, 0x-prefixed, even-length BCS legacy Ed25519 SignedTransaction.
     */
    signed_transaction: AptosSignedTransactionBcsHex;
}
/**
 * A non-empty, 0x-prefixed, even-length BCS legacy Ed25519 SignedTransaction.
 */
export type AptosSignedTransactionBcsHex = string;
/**
 * Request body for attaching automations to a wallet (wallet ID comes from the
 * URL).
 */
export interface AttachWalletAutomationRequestBody {
    automation_ids: Array<string>;
    /**
     * Per-attachment parameters for swap automations.
     */
    params?: WalletAutomationsAPI.SwapAttachmentParams;
}
/**
 * Dashboard response for a wallet authorization key (includes role, which is an
 * internal-only concept).
 */
export interface AuthorizationKeyDashboardResponse {
    id: string;
    created_at: number;
    display_name: string | null;
    public_key: string;
    /**
     * The role of an authorization key, controlling what actions it can authorize on a
     * wallet.
     */
    role: AuthorizationKeyRole | null;
}
/**
 * Public-facing response for a wallet authorization key.
 */
export interface AuthorizationKeyResponse {
    id: string;
    created_at: number;
    display_name: string | null;
    public_key: string;
}
/**
 * The role of an authorization key, controlling what actions it can authorize on a
 * wallet.
 */
export type AuthorizationKeyRole = 'root' | 'manager' | 'delegated-actions' | null;
/**
 * Request body for creating a crypto deposit account.
 */
export type CreateCryptoDepositAccountRequestBody = CreateCryptoDepositAccountWithConfigRequestBody | CreateCryptoDepositAccountWithRouteRequestBody;
/**
 * Response returned after creating a crypto deposit account.
 */
export interface CreateCryptoDepositAccountResponse {
    deposit_accounts: Array<CryptoDepositAddressRoute>;
}
/**
 * Creates a crypto deposit account from an existing deposit configuration.
 */
export interface CreateCryptoDepositAccountWithConfigRequestBody {
    deposit_config_id: string;
    type: 'deposit_config';
}
/**
 * Creates a crypto deposit account from an inline source and destination.
 */
export interface CreateCryptoDepositAccountWithRouteRequestBody {
    /**
     * An asset on a chain. Uses a human-readable alias (usdc, base) when one is on
     * file, otherwise the raw asset address and CAIP-2.
     */
    destination: CryptoDepositAsset;
    /**
     * Which assets a deposit address accepts. Asset and chain use human-readable
     * aliases when known.
     */
    source: CryptoDepositAssetFilter;
    type: 'inline_route';
}
/**
 * One deposit address and the source/destination route it accepts.
 */
export interface CryptoDepositAddressRoute {
    deposit_address: string;
    /**
     * An asset on a chain. Uses a human-readable alias (usdc, base) when one is on
     * file, otherwise the raw asset address and CAIP-2.
     */
    destination: CryptoDepositAsset;
    /**
     * Which assets a deposit address accepts. Asset and chain use human-readable
     * aliases when known.
     */
    source: CryptoDepositAssetFilter;
    wallet_id: string;
}
/**
 * An asset on a chain. Uses a human-readable alias (usdc, base) when one is on
 * file, otherwise the raw asset address and CAIP-2.
 */
export interface CryptoDepositAsset {
    /**
     * Known alias (usdc) or raw asset address.
     */
    asset: string;
    /**
     * Known alias (base) or CAIP-2. Omit on a source value to match every supported
     * chain for that asset.
     */
    chain?: string;
}
/**
 * Which assets a deposit address accepts. Asset and chain use human-readable
 * aliases when known.
 */
export type CryptoDepositAssetFilter = CryptoDepositAssetFilterAll | CryptoDepositAssetFilterInclude | CryptoDepositAssetFilterExclude;
/**
 * Match all assets.
 */
export interface CryptoDepositAssetFilterAll {
    mode: 'all';
}
/**
 * Match all assets except the specified ones, using human-readable aliases when
 * known.
 */
export interface CryptoDepositAssetFilterExclude {
    mode: 'exclude';
    values: Array<CryptoDepositAsset>;
}
/**
 * Match only the specified assets, using human-readable aliases when known.
 */
export interface CryptoDepositAssetFilterInclude {
    mode: 'include';
    values: Array<CryptoDepositAsset>;
}
/**
 * The wallet chain types that support curve-based signing.
 */
export type CurveSigningChainType = 'cosmos' | 'stellar' | 'sui' | 'aptos' | 'movement' | 'tron' | 'bitcoin-segwit' | 'bitcoin-taproot' | 'pearl' | 'near' | 'ton' | 'starknet' | 'xrpl';
/**
 * The cryptographic curve type used by the wallet.
 */
export type CurveType = 'secp256k1' | 'ed25519' | 'starknet';
/**
 * Information about a custodial wallet.
 */
export interface CustodialWallet {
    id: string;
    address: string;
    /**
     * The chain type of the custodial wallet.
     */
    chain_type: CustodialWalletChainType;
    /**
     * Information about the custodian managing this wallet.
     */
    custody: WalletCustodian;
    /**
     * A unique identifier for a key quorum.
     */
    owner_id: SharedAPI.KeyQuorumID | null;
    /**
     * Additional signers for the wallet.
     */
    additional_signers?: WalletAdditionalSigner;
    policy_ids?: Array<string>;
}
/**
 * The chain type of the custodial wallet.
 */
export type CustodialWalletChainType = 'ethereum' | 'solana';
/**
 * The input for creating a custodial wallet.
 */
export interface CustodialWalletCreateInput {
    /**
     * The chain type of the custodial wallet.
     */
    chain_type: CustodialWalletChainType;
    /**
     * The provider of the custodial wallet.
     */
    provider: CustodialWalletProvider;
    /**
     * The resource ID of the beneficiary of the custodial wallet, given by the
     * licensing provider.
     */
    provider_user_id: string;
    /**
     * Additional signers for the wallet.
     */
    additional_signers?: AdditionalSignerInput;
    /**
     * The owner of the resource, specified as a Privy user ID, a P-256 public key, or
     * null to remove the current owner.
     */
    owner?: SharedAPI.OwnerInput | null;
    /**
     * An optional list of up to one policy ID to enforce on the wallet.
     */
    policy_ids?: PolicyInput;
}
/**
 * The provider of the custodial wallet.
 */
export type CustodialWalletProvider = 'bridge';
/**
 * Source for a transfer identified by a token contract address (EVM) or mint
 * address (Solana). Use this variant for tokens that are not first-class assets.
 */
export interface CustomTokenTransferSource {
    /**
     * The token contract address (EVM) or mint address (Solana) of the asset to
     * transfer.
     */
    asset_address: string;
    /**
     * The blockchain network on which to perform the transfer. Supported chains
     * include: 'tempo', 'ethereum', 'base', 'arbitrum', 'polygon', 'solana', and their
     * respective testnets.
     */
    chain: string;
    /**
     * @deprecated Amount as a decimal string in the token's standard unit (e.g. "1.5"
     * for 1.5 USDC, "0.01" for 0.01 ETH). For exact_input, specifies the amount to
     * send. Not in the smallest on-chain unit (wei, lamports, etc.). Maximum 100
     * characters. Deprecated: use the top-level `amount` field instead.
     */
    amount?: string;
}
/**
 * Request body for detaching automations from a wallet (wallet ID comes from the
 * URL).
 */
export interface DetachWalletAutomationRequestBody {
    automation_ids: Array<string>;
}
/**
 * Estimated fee paid to the developer.
 */
export interface DeveloperFee {
    /**
     * Amount in USD (in decimals).
     */
    amount: string;
    type: 'developer';
    recipient?: string;
}
/**
 * HPKE-encrypted authorization key with encapsulated key and ciphertext.
 */
export interface EncryptedAuthorizationKey {
    /**
     * The encrypted authorization key corresponding to the user's current
     * authentication session.
     */
    ciphertext: string;
    /**
     * Base64-encoded ephemeral public key used in the HPKE encryption process.
     * Required for decryption.
     */
    encapsulated_key: string;
    /**
     * The encryption type used. Currently only supports HPKE.
     */
    encryption_type: 'HPKE';
}
/**
 * Encrypted response from bound wallet authentication, with bindings.
 */
export interface EncryptedBoundAuthenticateResponse {
    bindings: Array<UserSigningKeyBinding>;
    /**
     * HPKE-encrypted authorization key with encapsulated key and ciphertext.
     */
    encrypted_authorization_key: EncryptedAuthorizationKey;
    expires_at: number;
    wallets: Array<Wallet>;
}
/**
 * The response from authenticating a wallet with HPKE encryption, containing an
 * encrypted authorization key and wallet data.
 */
export interface EncryptedWalletAuthenticateResponse {
    /**
     * HPKE-encrypted authorization key with encapsulated key and ciphertext.
     */
    encrypted_authorization_key: EncryptedAuthorizationKey;
    /**
     * The expiration time of the authorization key in milliseconds since the epoch.
     */
    expires_at: number;
    wallets: Array<Wallet>;
}
/**
 * A Privy entity ID.
 */
export type EntityID = string;
/**
 * Executes the EVM `personal_sign` RPC (EIP-191) to sign a message.
 */
export interface EthereumPersonalSignRpcInput {
    method: 'personal_sign';
    /**
     * Parameters for the EVM `personal_sign` RPC.
     */
    params: EthereumPersonalSignRpcInputParams;
    address?: string;
    /**
     * A valid CAIP-2 chain ID (e.g. 'eip155:4217' for Tempo, 'eip155:1' for Ethereum).
     */
    caip2?: AppsAPI.Caip2;
    chain_type?: 'ethereum';
    /**
     * Options controlling signature production for personal_sign and
     * eth_signTypedData_v4.
     */
    signature_options?: SignatureOptions;
    wallet_id?: string;
}
/**
 * Parameters for the EVM `personal_sign` RPC.
 */
export interface EthereumPersonalSignRpcInputParams {
    encoding: 'utf-8' | 'hex';
    message: string;
}
/**
 * Response to the EVM `personal_sign` RPC.
 */
export interface EthereumPersonalSignRpcResponse {
    /**
     * Data returned by the EVM `personal_sign` RPC.
     */
    data: EthereumPersonalSignRpcResponseData;
    method: 'personal_sign';
}
/**
 * Data returned by the EVM `personal_sign` RPC.
 */
export interface EthereumPersonalSignRpcResponseData {
    encoding: 'hex';
    signature: string;
}
/**
 * Request body for Ethereum wallet RPC operations, discriminated by method.
 */
export type EthereumRpcInput = EthereumSignTransactionRpcInput | EthereumSendTransactionRpcInput | EthereumPersonalSignRpcInput | EthereumSignTypedDataRpcInput | EthereumSecp256k1SignRpcInput | EthereumSign7702AuthorizationRpcInput | EthereumSignUserOperationRpcInput | EthereumSendCallsRpcInput;
/**
 * Response body for Ethereum wallet RPC operations, discriminated by method.
 */
export type EthereumRpcResponse = EthereumPersonalSignRpcResponse | EthereumSignTypedDataRpcResponse | EthereumSignTransactionRpcResponse | EthereumSendTransactionRpcResponse | EthereumSignUserOperationRpcResponse | EthereumSign7702AuthorizationRpcResponse | EthereumSecp256k1SignRpcResponse | EthereumSendCallsRpcResponse;
/**
 * Signs a raw hash on the secp256k1 curve.
 */
export interface EthereumSecp256k1SignRpcInput {
    method: 'secp256k1_sign';
    /**
     * Parameters for the EVM `secp256k1_sign` RPC.
     */
    params: EthereumSecp256k1SignRpcInputParams;
    address?: string;
    chain_type?: 'ethereum';
    wallet_id?: string;
}
/**
 * Parameters for the EVM `secp256k1_sign` RPC.
 */
export interface EthereumSecp256k1SignRpcInputParams {
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    hash: Hex;
}
/**
 * Response to the EVM `secp256k1_sign` RPC.
 */
export interface EthereumSecp256k1SignRpcResponse {
    /**
     * Data returned by the EVM `secp256k1_sign` RPC.
     */
    data: EthereumSecp256k1SignRpcResponseData;
    method: 'secp256k1_sign';
}
/**
 * Data returned by the EVM `secp256k1_sign` RPC.
 */
export interface EthereumSecp256k1SignRpcResponseData {
    encoding: 'hex';
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    signature: Hex;
}
/**
 * A single call within a batched wallet_sendCalls request.
 */
export interface EthereumSendCallsCall {
    to: string;
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    data?: Hex;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    value?: Quantity;
}
/**
 * Executes the `wallet_sendCalls` RPC (EIP-5792) to batch multiple calls into a
 * single atomic transaction.
 */
export interface EthereumSendCallsRpcInput {
    /**
     * A valid CAIP-2 chain ID (e.g. 'eip155:4217' for Tempo, 'eip155:1' for Ethereum).
     */
    caip2: AppsAPI.Caip2;
    method: 'wallet_sendCalls';
    /**
     * Parameters for the `wallet_sendCalls` RPC.
     */
    params: EthereumSendCallsRpcInputParams;
    address?: string;
    chain_type?: 'ethereum';
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    experimental_data_suffix?: Hex;
    sponsor?: boolean;
    /**
     * Options for user-pays gas sponsorship on the RPC endpoint. When provided
     * alongside `sponsor: true`, controls which token asset the user pays gas with.
     */
    sponsor_options?: RpcSponsorOptions;
    wallet_id?: string;
}
/**
 * Parameters for the `wallet_sendCalls` RPC.
 */
export interface EthereumSendCallsRpcInputParams {
    calls: Array<EthereumSendCallsCall>;
}
/**
 * Response to the `wallet_sendCalls` RPC.
 */
export interface EthereumSendCallsRpcResponse {
    /**
     * Data returned by the `wallet_sendCalls` RPC.
     */
    data: EthereumSendCallsRpcResponseData;
    method: 'wallet_sendCalls';
}
/**
 * Data returned by the `wallet_sendCalls` RPC.
 */
export interface EthereumSendCallsRpcResponseData {
    /**
     * A valid CAIP-2 chain ID (e.g. 'eip155:4217' for Tempo, 'eip155:1' for Ethereum).
     */
    caip2: AppsAPI.Caip2;
    transaction_id: string;
}
/**
 * Executes the EVM `eth_sendTransaction` RPC to sign and broadcast a transaction.
 */
export interface EthereumSendTransactionRpcInput {
    /**
     * A valid CAIP-2 chain ID (e.g. 'eip155:4217' for Tempo, 'eip155:1' for Ethereum).
     */
    caip2: AppsAPI.Caip2;
    method: 'eth_sendTransaction';
    /**
     * Parameters for the EVM `eth_sendTransaction` RPC.
     */
    params: EthereumSendTransactionRpcInputParams;
    address?: string;
    chain_type?: 'ethereum';
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    experimental_data_suffix?: Hex;
    /**
     * Developer-provided identifier for this request. Must be unique per app.
     */
    reference_id?: string;
    sponsor?: boolean;
    /**
     * Options for user-pays gas sponsorship on the RPC endpoint. When provided
     * alongside `sponsor: true`, controls which token asset the user pays gas with.
     */
    sponsor_options?: RpcSponsorOptions;
    wallet_id?: string;
}
/**
 * Parameters for the EVM `eth_sendTransaction` RPC.
 */
export interface EthereumSendTransactionRpcInputParams {
    /**
     * An unsigned Ethereum transaction object. Supports standard EVM transaction types
     * (0, 1, 2, 4) and Tempo transactions (type 118).
     */
    transaction: UnsignedEthereumTransaction;
}
/**
 * Response to the EVM `eth_sendTransaction` RPC.
 */
export interface EthereumSendTransactionRpcResponse {
    /**
     * Data returned by the EVM `eth_sendTransaction` RPC.
     */
    data: EthereumSendTransactionRpcResponseData;
    method: 'eth_sendTransaction';
}
/**
 * Data returned by the EVM `eth_sendTransaction` RPC.
 */
export interface EthereumSendTransactionRpcResponseData {
    /**
     * A valid CAIP-2 chain ID (e.g. 'eip155:4217' for Tempo, 'eip155:1' for Ethereum).
     */
    caip2: AppsAPI.Caip2;
    hash: string;
    /**
     * Developer-provided reference ID, if one was included in the request.
     */
    reference_id?: string | null;
    transaction_id?: string;
    /**
     * An unsigned Ethereum transaction object. Supports standard EVM transaction types
     * (0, 1, 2, 4) and Tempo transactions (type 118).
     */
    transaction_request?: UnsignedEthereumTransaction;
    user_operation_hash?: string;
}
/**
 * A signed EIP-7702 authorization that delegates code execution to a contract
 * address.
 */
export interface EthereumSign7702Authorization {
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    chain_id: Quantity;
    contract: string;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    nonce: Quantity;
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    r: Hex;
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    s: Hex;
    y_parity: number;
}
/**
 * Signs an EIP-7702 authorization.
 */
export interface EthereumSign7702AuthorizationRpcInput {
    method: 'eth_sign7702Authorization';
    /**
     * Parameters for the EVM `eth_sign7702Authorization` RPC.
     */
    params: EthereumSign7702AuthorizationRpcInputParams;
    address?: string;
    chain_type?: 'ethereum';
    wallet_id?: string;
}
/**
 * Parameters for the EVM `eth_sign7702Authorization` RPC.
 */
export interface EthereumSign7702AuthorizationRpcInputParams {
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    chain_id: Quantity;
    contract: string;
    executor?: 'self';
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    nonce?: Quantity;
}
/**
 * Response to the EVM `eth_sign7702Authorization` RPC.
 */
export interface EthereumSign7702AuthorizationRpcResponse {
    /**
     * Data returned by the EVM `eth_sign7702Authorization` RPC.
     */
    data: EthereumSign7702AuthorizationRpcResponseData;
    method: 'eth_sign7702Authorization';
}
/**
 * Data returned by the EVM `eth_sign7702Authorization` RPC.
 */
export interface EthereumSign7702AuthorizationRpcResponseData {
    /**
     * A signed EIP-7702 authorization that delegates code execution to a contract
     * address.
     */
    authorization: EthereumSign7702Authorization;
}
/**
 * Executes the EVM `eth_signTransaction` RPC to sign a transaction.
 */
export interface EthereumSignTransactionRpcInput {
    method: 'eth_signTransaction';
    /**
     * Parameters for the EVM `eth_signTransaction` RPC.
     */
    params: EthereumSignTransactionRpcInputParams;
    address?: string;
    chain_type?: 'ethereum';
    wallet_id?: string;
}
/**
 * Parameters for the EVM `eth_signTransaction` RPC.
 */
export interface EthereumSignTransactionRpcInputParams {
    /**
     * An unsigned Ethereum transaction object. Supports standard EVM transaction types
     * (0, 1, 2, 4) and Tempo transactions (type 118).
     */
    transaction: UnsignedEthereumTransaction;
}
/**
 * Response to the EVM `eth_signTransaction` RPC.
 */
export interface EthereumSignTransactionRpcResponse {
    /**
     * Data returned by the EVM `eth_signTransaction` RPC.
     */
    data: EthereumSignTransactionRpcResponseData;
    method: 'eth_signTransaction';
}
/**
 * Data returned by the EVM `eth_signTransaction` RPC.
 */
export interface EthereumSignTransactionRpcResponseData {
    encoding: 'rlp';
    signed_transaction: string;
}
/**
 * Executes the EVM `eth_signTypedData_v4` RPC (EIP-712) to sign a typed data
 * object.
 */
export interface EthereumSignTypedDataRpcInput {
    method: 'eth_signTypedData_v4';
    /**
     * Parameters for the EVM `eth_signTypedData_v4` RPC.
     */
    params: EthereumSignTypedDataRpcInputParams;
    address?: string;
    /**
     * A valid CAIP-2 chain ID (e.g. 'eip155:4217' for Tempo, 'eip155:1' for Ethereum).
     */
    caip2?: AppsAPI.Caip2;
    chain_type?: 'ethereum';
    /**
     * Options controlling signature production for personal_sign and
     * eth_signTypedData_v4.
     */
    signature_options?: SignatureOptions;
    wallet_id?: string;
}
/**
 * Parameters for the EVM `eth_signTypedData_v4` RPC.
 */
export interface EthereumSignTypedDataRpcInputParams {
    /**
     * EIP-712 typed data object.
     */
    typed_data: EthereumTypedDataInput;
}
/**
 * Response to the EVM `eth_signTypedData_v4` RPC.
 */
export interface EthereumSignTypedDataRpcResponse {
    /**
     * Data returned by the EVM `eth_signTypedData_v4` RPC.
     */
    data: EthereumSignTypedDataRpcResponseData;
    method: 'eth_signTypedData_v4';
}
/**
 * Data returned by the EVM `eth_signTypedData_v4` RPC.
 */
export interface EthereumSignTypedDataRpcResponseData {
    encoding: 'hex';
    signature: string;
}
/**
 * Executes an RPC method to hash and sign a UserOperation.
 */
export interface EthereumSignUserOperationRpcInput {
    method: 'eth_signUserOperation';
    /**
     * Parameters for the EVM `eth_signUserOperation` RPC.
     */
    params: EthereumSignUserOperationRpcInputParams;
    address?: string;
    chain_type?: 'ethereum';
    wallet_id?: string;
}
/**
 * Parameters for the EVM `eth_signUserOperation` RPC.
 */
export interface EthereumSignUserOperationRpcInputParams {
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    chain_id: Quantity;
    contract: string;
    /**
     * An ERC-4337 user operation.
     */
    user_operation: UserOperationInput;
}
/**
 * Response to the EVM `eth_signUserOperation` RPC.
 */
export interface EthereumSignUserOperationRpcResponse {
    /**
     * Data returned by the EVM `eth_signUserOperation` RPC.
     */
    data: EthereumSignUserOperationRpcResponseData;
    method: 'eth_signUserOperation';
}
/**
 * Data returned by the EVM `eth_signUserOperation` RPC.
 */
export interface EthereumSignUserOperationRpcResponseData {
    encoding: 'hex';
    signature: string;
}
/**
 * EIP-712 typed data object.
 */
export interface EthereumTypedDataInput {
    /**
     * The domain parameters for EIP-712 typed data signing.
     */
    domain: TypedDataDomainInputParams;
    message: {
        [key: string]: unknown;
    };
    primary_type: string;
    /**
     * The type definitions for EIP-712 typed data signing.
     */
    types: TypedDataTypesInputParams;
}
/**
 * Exports the private key of the wallet.
 */
export interface ExportPrivateKeyRpcInput {
    address: string;
    method: 'exportPrivateKey';
    /**
     * Input for exporting a wallet (private key or seed phrase) with HPKE encryption.
     */
    params: PrivateKeyExportInput;
}
/**
 * Response to the `exportPrivateKey` RPC.
 */
export interface ExportPrivateKeyRpcResponse {
    /**
     * Input for exporting a wallet (private key or seed phrase) with HPKE encryption.
     */
    data: PrivateKeyExportInput;
    method: 'exportPrivateKey';
}
/**
 * Exports the seed phrase of the wallet.
 */
export interface ExportSeedPhraseRpcInput {
    address: string;
    method: 'exportSeedPhrase';
    /**
     * Input for exporting a wallet (private key or seed phrase) with HPKE encryption.
     */
    params: SeedPhraseExportInput;
}
/**
 * Response to the `exportSeedPhrase` RPC.
 */
export interface ExportSeedPhraseRpcResponse {
    /**
     * Response containing HPKE-encrypted wallet data (private key or seed phrase).
     */
    data: SeedPhraseExportResponse;
    method: 'exportSeedPhrase';
}
/**
 * The export type. 'display' is for showing the key to the user in the UI,
 * 'client' is for exporting to the client application.
 */
export type ExportType = 'display' | 'client';
/**
 * The wallet chain types that are not first class chains.
 */
export type ExtendedChainType = 'cosmos' | 'stellar' | 'sui' | 'aptos' | 'movement' | 'tron' | 'bitcoin-segwit' | 'bitcoin-taproot' | 'pearl' | 'near' | 'ton' | 'starknet' | 'xrpl' | 'spark';
/**
 * Total fees assessed on a transfer, in BPS
 */
export interface FeeConfiguration {
    /**
     * Discriminator: total fee specified in BPS.
     */
    type: 'total_fee_bps';
    /**
     * Total fee in basis points (1 bps = 0.01%).
     */
    value: number;
}
/**
 * An individual fee assessed on a transfer.
 */
export type FeeLineItem = RelayerFee | PrivyFee | DeveloperFee;
/**
 * The wallet chain types that offer first class support.
 */
export type FirstClassChainType = 'ethereum' | 'solana';
/**
 * Gas cost for a blockchain action. Includes both raw base-unit amount and a
 * human-readable decimal string, plus the gas token symbol.
 */
export interface Gas {
    /**
     * Gas cost in the gas token as a human-readable decimal string (e.g. "0.0001").
     */
    amount: string;
    /**
     * Gas cost in the gas token's base units (e.g. wei).
     */
    base_amount: string;
    /**
     * Gas token symbol (e.g. "ETH", "USDC").
     */
    gas_asset: string;
}
/**
 * Request body for looking up a wallet by its blockchain address.
 */
export interface GetByWalletAddressRequestBody {
    /**
     * A blockchain wallet address. Ethereum addresses are normalized to EIP-55
     * checksum format. Solana addresses are validated as base58. All other chain
     * addresses (Stellar, Tron, Sui, Aptos, etc.) are accepted as-is.
     */
    address: Address;
    /**
     * Include archived wallets in lookup. Defaults to false (archived wallets return
     * 404).
     */
    include_archived?: boolean;
}
/**
 * The input for HD wallets.
 */
export interface HDInitInput {
    /**
     * The address of the wallet to import.
     */
    address: string;
    /**
     * The chain type of the wallet to import. Supports `ethereum`, `solana`,
     * `stellar`, `tron`, `sui`, `aptos`, and `xrpl`.
     */
    chain_type: WalletImportSupportedChains;
    /**
     * The encryption type of the wallet to import. Currently only supports `HPKE`.
     */
    encryption_type: HpkeEncryption;
    /**
     * The entropy type of the wallet to import.
     */
    entropy_type: 'hd';
    /**
     * The index of the wallet to import.
     */
    index: number;
}
/**
 * A BIP-32 hierarchical deterministic wallet derivation path.
 */
export type HDPath = string;
/**
 * The submission input for importing an HD wallet.
 */
export interface HDSubmitInput {
    /**
     * The address of the wallet to import.
     */
    address: string;
    /**
     * The chain type of the wallet to import. Supports `ethereum`, `solana`,
     * `stellar`, `tron`, `sui`, `aptos`, and `xrpl`.
     */
    chain_type: WalletImportSupportedChains;
    /**
     * The encrypted entropy of the wallet to import.
     */
    ciphertext: string;
    /**
     * The base64-encoded encapsulated key that was generated during encryption, for
     * use during decryption inside the TEE.
     */
    encapsulated_key: string;
    /**
     * The encryption type of the wallet to import. Currently only supports `HPKE`.
     */
    encryption_type: HpkeEncryption;
    /**
     * The entropy type of the wallet to import.
     */
    entropy_type: 'hd';
    /**
     * The index of the wallet to import.
     */
    index: number;
    /**
     * Optional HPKE configuration for wallet import decryption. These parameters allow
     * importing wallets encrypted by external providers that use different HPKE
     * configurations.
     */
    hpke_config?: HpkeImportConfig;
}
/**
 * The AEAD algorithm used for HPKE encryption.
 */
export type HpkeAeadAlgorithm = 'CHACHA20_POLY1305' | 'AES_GCM256';
/**
 * The encryption type of the wallet to import. Currently only supports `HPKE`.
 */
export type HpkeEncryption = 'HPKE';
/**
 * Optional HPKE configuration for wallet import decryption. These parameters allow
 * importing wallets encrypted by external providers that use different HPKE
 * configurations.
 */
export interface HpkeImportConfig {
    /**
     * Additional Authenticated Data (AAD) used during encryption. Should be
     * base64-encoded bytes.
     */
    aad?: string;
    /**
     * The AEAD algorithm used for HPKE encryption.
     */
    aead_algorithm?: HpkeAeadAlgorithm;
    /**
     * Application-specific context information (INFO) used during HPKE encryption.
     * Should be base64-encoded bytes.
     */
    info?: string;
}
/**
 * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
 * bytes).
 */
export type Hex = string;
/**
 * A binding that scopes a user signing key to a specific intent.
 */
export interface IntentBinding {
    intentId: string;
    type: 'intent';
}
/**
 * Source for a transfer identified by a named asset (e.g. "usdc", "eth"). Use this
 * variant for first-class assets maintained by Privy.
 */
export interface NamedTokenTransferSource {
    /**
     * The asset to transfer. Supported: 'usdc', 'usdb', 'usdt', 'eurc', 'ousd',
     * 'pathusd' (stablecoins), 'eth' (native Ethereum), 'sol' (native Solana).
     */
    asset: string;
    /**
     * The blockchain network on which to perform the transfer. Supported chains
     * include: 'tempo', 'ethereum', 'base', 'arbitrum', 'polygon', 'solana', and their
     * respective testnets.
     */
    chain: string;
    /**
     * @deprecated Amount as a decimal string in the token's standard unit (e.g. "1.5"
     * for 1.5 USDC, "0.01" for 0.01 ETH). For exact_input, specifies the amount to
     * send. Not in the smallest on-chain unit (wei, lamports, etc.). Maximum 100
     * characters. Deprecated: use the top-level `amount` field instead.
     */
    amount?: string;
}
/**
 * Executes the NEAR `near_signTransaction` RPC to sign a transaction. The caller
 * is responsible for broadcasting.
 */
export interface NearRpcRequestBody {
    method: 'near_signTransaction';
    /**
     * Parameters for the NEAR `near_signTransaction` RPC.
     */
    params: NearSignTransactionRpcRequestBodyParams;
}
/**
 * Response to the NEAR `near_signTransaction` RPC.
 */
export interface NearRpcResponse {
    /**
     * Data returned by the NEAR `near_signTransaction` RPC.
     */
    data: NearSignTransactionRpcResponseData;
    method: 'near_signTransaction';
}
/**
 * Executes the NEAR `near_signTransaction` RPC to sign a transaction. The caller
 * is responsible for broadcasting.
 */
export interface NearSignTransactionRpcRequestBody {
    method: 'near_signTransaction';
    /**
     * Parameters for the NEAR `near_signTransaction` RPC.
     */
    params: NearSignTransactionRpcRequestBodyParams;
}
/**
 * Parameters for the NEAR `near_signTransaction` RPC.
 */
export interface NearSignTransactionRpcRequestBodyParams {
    /**
     * A non-empty, base64-encoded Borsh NEAR Transaction.
     */
    transaction: NearUnsignedTransactionBorshBase64;
}
/**
 * Response to the NEAR `near_signTransaction` RPC.
 */
export interface NearSignTransactionRpcResponse {
    /**
     * Data returned by the NEAR `near_signTransaction` RPC.
     */
    data: NearSignTransactionRpcResponseData;
    method: 'near_signTransaction';
}
/**
 * Data returned by the NEAR `near_signTransaction` RPC.
 */
export interface NearSignTransactionRpcResponseData {
    encoding: 'base64';
    /**
     * A non-empty, base64-encoded NEAR Ed25519 SignedTransaction.
     */
    signed_transaction: NearSignedTransactionBorshBase64;
}
/**
 * A non-empty, base64-encoded NEAR Ed25519 SignedTransaction.
 */
export type NearSignedTransactionBorshBase64 = string;
/**
 * A non-empty, base64-encoded Borsh NEAR Transaction.
 */
export type NearUnsignedTransactionBorshBase64 = string;
/**
 * A Spark token output with its previous transaction data.
 */
export interface OutputWithPreviousTransactionData {
    previous_transaction_hash: string;
    previous_transaction_vout: number;
    /**
     * A Spark token output.
     */
    output?: TokenOutput;
}
/**
 * An optional list of up to one policy ID to enforce on the wallet.
 */
export type PolicyInput = Array<string>;
/**
 * Input for exporting a wallet (private key or seed phrase) with HPKE encryption.
 */
export interface PrivateKeyExportInput {
    /**
     * The encryption type of the wallet to import. Currently only supports `HPKE`.
     */
    encryption_type: HpkeEncryption;
    /**
     * The recipient public key for HPKE encryption, in PEM or DER (base64-encoded)
     * format.
     */
    recipient_public_key: RecipientPublicKey;
    export_seed_phrase?: boolean;
    /**
     * The export type. 'display' is for showing the key to the user in the UI,
     * 'client' is for exporting to the client application.
     */
    export_type?: ExportType;
}
/**
 * Response containing HPKE-encrypted wallet data (private key or seed phrase).
 */
export interface PrivateKeyExportResponse {
    ciphertext: string;
    encapsulated_key: string;
    /**
     * The encryption type of the wallet to import. Currently only supports `HPKE`.
     */
    encryption_type: HpkeEncryption;
}
/**
 * The input for private key wallets.
 */
export interface PrivateKeyInitInput {
    /**
     * The address of the wallet to import.
     */
    address: string;
    /**
     * The chain type of the wallet to import. Supports `ethereum`, `solana`,
     * `stellar`, `tron`, `sui`, `aptos`, and `xrpl`.
     */
    chain_type: WalletImportSupportedChains;
    /**
     * The encryption type of the wallet to import. Currently only supports `HPKE`.
     */
    encryption_type: HpkeEncryption;
    entropy_type: 'private-key';
}
/**
 * The submission input for importing a private key wallet.
 */
export interface PrivateKeySubmitInput {
    /**
     * The address of the wallet to import.
     */
    address: string;
    /**
     * The chain type of the wallet to import. Supports `ethereum`, `solana`,
     * `stellar`, `tron`, `sui`, `aptos`, and `xrpl`.
     */
    chain_type: WalletImportSupportedChains;
    /**
     * The encrypted entropy of the wallet to import.
     */
    ciphertext: string;
    /**
     * The base64-encoded encapsulated key that was generated during encryption, for
     * use during decryption inside the TEE.
     */
    encapsulated_key: string;
    /**
     * The encryption type of the wallet to import. Currently only supports `HPKE`.
     */
    encryption_type: HpkeEncryption;
    entropy_type: 'private-key';
    /**
     * Optional HPKE configuration for wallet import decryption. These parameters allow
     * importing wallets encrypted by external providers that use different HPKE
     * configurations.
     */
    hpke_config?: HpkeImportConfig;
}
/**
 * Estimated fee paid to Privy.
 */
export interface PrivyFee {
    /**
     * Amount in USD (in decimals).
     */
    amount: string;
    type: 'privy';
    recipient?: string;
}
/**
 * A quantity value that can be either a hex string starting with '0x' or a
 * non-negative integer.
 */
export type Quantity = Hex | number;
/**
 * Unencrypted response from bound wallet authentication, with bindings.
 */
export interface RawBoundAuthenticateResponse {
    authorization_key: string;
    bindings: Array<UserSigningKeyBinding>;
    expires_at: number;
    wallets: Array<Wallet>;
}
/**
 * Encoding scheme for bytes in the `raw_sign` RPC.
 */
export type RawSignBytesEncoding = 'utf-8' | 'hex' | 'base64';
/**
 * Hash function for bytes in the `raw_sign` RPC.
 */
export type RawSignBytesHashFunction = 'keccak256' | 'sha256' | 'blake2b256';
/**
 * Parameters for hashing and signing bytes with the `raw_sign` RPC.
 */
export interface RawSignBytesParams {
    /**
     * The bytes to hash and sign.
     */
    bytes: string;
    /**
     * Encoding scheme for bytes in the `raw_sign` RPC.
     */
    encoding: RawSignBytesEncoding;
    /**
     * Hash function for bytes in the `raw_sign` RPC.
     */
    hash_function: RawSignBytesHashFunction;
}
/**
 * Parameters for signing a pre-computed hash with the `raw_sign` RPC.
 */
export interface RawSignHashParams {
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    hash: Hex;
}
/**
 * Provide either `hash` (to sign a pre-computed hash) OR `bytes`, `encoding`, and
 * `hash_function` (to hash and then sign). These options are mutually exclusive.
 */
export interface RawSignInput {
    /**
     * Parameters for the `raw_sign` RPC.
     */
    params: RawSignInputParams;
}
/**
 * Parameters for the `raw_sign` RPC.
 */
export type RawSignInputParams = RawSignHashParams | RawSignBytesParams;
/**
 * Response to the `raw_sign` RPC.
 */
export interface RawSignResponse {
    /**
     * Data returned by the `raw_sign` RPC.
     */
    data: RawSignResponseData;
    method: 'raw_sign';
}
/**
 * Data returned by the `raw_sign` RPC.
 */
export interface RawSignResponseData {
    encoding: 'hex';
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    signature: Hex;
}
/**
 * The response from authenticating a wallet without encryption, containing a raw
 * authorization key and wallet data.
 */
export interface RawWalletAuthenticateResponse {
    /**
     * The raw authorization key data.
     */
    authorization_key: string;
    /**
     * The expiration time of the authorization key in milliseconds since the epoch.
     */
    expires_at: number;
    wallets: Array<Wallet>;
}
/**
 * The recipient public key for HPKE encryption, in PEM or DER (base64-encoded)
 * format.
 */
export type RecipientPublicKey = string;
/**
 * Estimated fee paid to the relayer.
 */
export interface RelayerFee {
    /**
     * Amount in USD (in decimals).
     */
    amount: string;
    type: 'relayer';
    recipient?: string;
}
/**
 * Token asset identifier for user-pays gas sponsorship. Common values: 'usdc',
 * 'usdt', 'eurc', 'usdg', 'usdc_e'. Available tokens vary by chain.
 */
export type RpcSponsorAsset = string;
/**
 * Options for user-pays gas sponsorship on the RPC endpoint. When provided
 * alongside `sponsor: true`, controls which token asset the user pays gas with.
 */
export interface RpcSponsorOptions {
    /**
     * Token asset identifier for user-pays gas sponsorship. Common values: 'usdc',
     * 'usdt', 'eurc', 'usdg', 'usdc_e'. Available tokens vary by chain.
     */
    asset: RpcSponsorAsset;
}
/**
 * Input for exporting a wallet (private key or seed phrase) with HPKE encryption.
 */
export interface SeedPhraseExportInput {
    /**
     * The encryption type of the wallet to import. Currently only supports `HPKE`.
     */
    encryption_type: HpkeEncryption;
    /**
     * The recipient public key for HPKE encryption, in PEM or DER (base64-encoded)
     * format.
     */
    recipient_public_key: RecipientPublicKey;
    export_seed_phrase?: boolean;
    /**
     * The export type. 'display' is for showing the key to the user in the UI,
     * 'client' is for exporting to the client application.
     */
    export_type?: ExportType;
}
/**
 * Response containing HPKE-encrypted wallet data (private key or seed phrase).
 */
export interface SeedPhraseExportResponse {
    ciphertext: string;
    encapsulated_key: string;
    /**
     * The encryption type of the wallet to import. Currently only supports `HPKE`.
     */
    encryption_type: HpkeEncryption;
}
/**
 * Options controlling signature production for personal_sign and
 * eth_signTypedData_v4.
 */
export interface SignatureOptions {
    /**
     * The type of cryptographic signature to produce. Use "ecdsa" for standard ECDSA
     * signatures, or "erc1271" for ERC-1271 compliant signatures for smart account
     * wallets.
     */
    type: SignatureType;
}
/**
 * The type of cryptographic signature to produce. Use "ecdsa" for standard ECDSA
 * signatures, or "erc1271" for ERC-1271 compliant signatures for smart account
 * wallets.
 */
export type SignatureType = 'ecdsa' | 'erc1271';
/**
 * The signing algorithm used by the wallet.
 */
export type SigningAlgorithm = 'ECDSA' | 'EdDSA' | 'Schnorr';
/**
 * Request body for Solana wallet RPC operations, discriminated by method.
 */
export type SolanaRpcInput = SolanaSignTransactionRpcInput | SolanaSignAndSendTransactionRpcInput | SolanaSignMessageRpcInput;
/**
 * Response body for Solana wallet RPC operations, discriminated by method.
 */
export type SolanaRpcResponse = SolanaSignMessageRpcResponse | SolanaSignTransactionRpcResponse | SolanaSignAndSendTransactionRpcResponse;
/**
 * Executes the SVM `signAndSendTransaction` RPC to sign and broadcast a
 * transaction.
 */
export interface SolanaSignAndSendTransactionRpcInput {
    /**
     * A valid CAIP-2 chain ID (e.g. 'eip155:4217' for Tempo, 'eip155:1' for Ethereum).
     */
    caip2: AppsAPI.Caip2;
    method: 'signAndSendTransaction';
    /**
     * Parameters for the SVM `signAndSendTransaction` RPC.
     */
    params: SolanaSignAndSendTransactionRpcInputParams;
    address?: string;
    chain_type?: 'solana';
    optimistic_broadcast?: boolean;
    /**
     * Developer-provided identifier for this request. Must be unique per app.
     */
    reference_id?: string;
    sponsor?: boolean;
    /**
     * Options for user-pays gas sponsorship on the RPC endpoint. When provided
     * alongside `sponsor: true`, controls which token asset the user pays gas with.
     */
    sponsor_options?: RpcSponsorOptions;
    wallet_id?: string;
}
/**
 * Parameters for the SVM `signAndSendTransaction` RPC.
 */
export interface SolanaSignAndSendTransactionRpcInputParams {
    encoding: 'base64';
    transaction: string;
}
/**
 * Response to the SVM `signAndSendTransaction` RPC.
 */
export interface SolanaSignAndSendTransactionRpcResponse {
    /**
     * Data returned by the SVM `signAndSendTransaction` RPC.
     */
    data: SolanaSignAndSendTransactionRpcResponseData;
    method: 'signAndSendTransaction';
}
/**
 * Data returned by the SVM `signAndSendTransaction` RPC.
 */
export interface SolanaSignAndSendTransactionRpcResponseData {
    /**
     * A valid CAIP-2 chain ID (e.g. 'eip155:4217' for Tempo, 'eip155:1' for Ethereum).
     */
    caip2: AppsAPI.Caip2;
    hash: string;
    /**
     * Developer-provided reference ID, if one was included in the request.
     */
    reference_id?: string | null;
    signed_transaction?: string;
    transaction_id?: string;
}
/**
 * Executes the SVM `signMessage` RPC to sign a message.
 */
export interface SolanaSignMessageRpcInput {
    method: 'signMessage';
    /**
     * Parameters for the SVM `signMessage` RPC.
     */
    params: SolanaSignMessageRpcInputParams;
    address?: string;
    chain_type?: 'solana';
    wallet_id?: string;
}
/**
 * Parameters for the SVM `signMessage` RPC.
 */
export interface SolanaSignMessageRpcInputParams {
    encoding: 'base64';
    message: string;
}
/**
 * Response to the SVM `signMessage` RPC.
 */
export interface SolanaSignMessageRpcResponse {
    /**
     * Data returned by the SVM `signMessage` RPC.
     */
    data: SolanaSignMessageRpcResponseData;
    method: 'signMessage';
}
/**
 * Data returned by the SVM `signMessage` RPC.
 */
export interface SolanaSignMessageRpcResponseData {
    encoding: 'base64';
    signature: string;
}
/**
 * Executes the SVM `signTransaction` RPC to sign a transaction.
 */
export interface SolanaSignTransactionRpcInput {
    method: 'signTransaction';
    /**
     * Parameters for the SVM `signTransaction` RPC.
     */
    params: SolanaSignTransactionRpcInputParams;
    address?: string;
    chain_type?: 'solana';
    wallet_id?: string;
}
/**
 * Parameters for the SVM `signTransaction` RPC.
 */
export interface SolanaSignTransactionRpcInputParams {
    encoding: 'base64';
    transaction: string;
}
/**
 * Response to the SVM `signTransaction` RPC.
 */
export interface SolanaSignTransactionRpcResponse {
    /**
     * Data returned by the SVM `signTransaction` RPC.
     */
    data: SolanaSignTransactionRpcResponseData;
    method: 'signTransaction';
}
/**
 * Data returned by the SVM `signTransaction` RPC.
 */
export interface SolanaSignTransactionRpcResponseData {
    encoding: 'base64';
    signed_transaction: string;
}
/**
 * The derivation strategy used for Solana wallets.
 */
export type SolanaWalletDerivationStrategy = 'ENTROPY_TO_SEED' | 'ENTROPY_TO_MNEMONIC_TO_SEED';
/**
 * The balance of a Spark wallet.
 */
export interface SparkBalance {
    balance: string;
    token_balances: {
        [key: string]: SparkTokenBalance;
    };
}
/**
 * Claims a static deposit into the Spark wallet.
 */
export interface SparkClaimStaticDepositRpcInput {
    method: 'claimStaticDeposit';
    /**
     * Parameters for the Spark `claimStaticDeposit` RPC.
     */
    params: SparkClaimStaticDepositRpcInputParams;
    /**
     * The Spark network.
     */
    network?: SparkNetwork;
}
/**
 * Parameters for the Spark `claimStaticDeposit` RPC.
 */
export interface SparkClaimStaticDepositRpcInputParams {
    credit_amount_sats: number;
    signature: string;
    transaction_id: string;
    output_index?: number;
}
/**
 * Response to the Spark `claimStaticDeposit` RPC.
 */
export interface SparkClaimStaticDepositRpcResponse {
    method: 'claimStaticDeposit';
    /**
     * Data returned by the Spark `claimStaticDeposit` RPC.
     */
    data?: SparkClaimStaticDepositRpcResponseData;
}
/**
 * Data returned by the Spark `claimStaticDeposit` RPC.
 */
export interface SparkClaimStaticDepositRpcResponseData {
    transfer_id: string;
}
/**
 * A fee quote for a cooperative exit from Spark to Bitcoin L1.
 */
export interface SparkCoopExitFeeQuote {
    id: string;
    created_at: string;
    expires_at: string;
    /**
     * A currency amount with its original value and unit.
     */
    l1_broadcast_fee_fast: SparkCurrencyAmount;
    /**
     * A currency amount with its original value and unit.
     */
    l1_broadcast_fee_medium: SparkCurrencyAmount;
    /**
     * A currency amount with its original value and unit.
     */
    l1_broadcast_fee_slow: SparkCurrencyAmount;
    network: string;
    /**
     * A currency amount with its original value and unit.
     */
    total_amount: SparkCurrencyAmount;
    updated_at: string;
    /**
     * A currency amount with its original value and unit.
     */
    user_fee_fast: SparkCurrencyAmount;
    /**
     * A currency amount with its original value and unit.
     */
    user_fee_medium: SparkCurrencyAmount;
    /**
     * A currency amount with its original value and unit.
     */
    user_fee_slow: SparkCurrencyAmount;
}
/**
 * A cooperative exit request from Spark to Bitcoin L1.
 */
export interface SparkCoopExitRequest {
    id: string;
    coop_exit_txid: string;
    created_at: string;
    expires_at: string;
    /**
     * A currency amount with its original value and unit.
     */
    fee: SparkCurrencyAmount;
    /**
     * A currency amount with its original value and unit.
     */
    l1_broadcast_fee: SparkCurrencyAmount;
    network: string;
    status: string;
    updated_at: string;
    /**
     * The exit speed for a cooperative withdrawal from Spark to L1.
     */
    exit_speed?: SparkExitSpeed;
    fee_quote_id?: string;
}
/**
 * Creates a Lightning invoice for the Spark wallet.
 */
export interface SparkCreateLightningInvoiceRpcInput {
    method: 'createLightningInvoice';
    /**
     * Parameters for the Spark `createLightningInvoice` RPC.
     */
    params: SparkCreateLightningInvoiceRpcInputParams;
    /**
     * The Spark network.
     */
    network?: SparkNetwork;
}
/**
 * Parameters for the Spark `createLightningInvoice` RPC.
 */
export interface SparkCreateLightningInvoiceRpcInputParams {
    amount_sats: number;
    description_hash?: string;
    expiry_seconds?: number;
    include_spark_address?: boolean;
    memo?: string;
    receiver_identity_pubkey?: string;
}
/**
 * Response to the Spark `createLightningInvoice` RPC.
 */
export interface SparkCreateLightningInvoiceRpcResponse {
    method: 'createLightningInvoice';
    /**
     * A Spark Lightning receive request.
     */
    data?: SparkLightningReceiveRequest;
}
/**
 * A currency amount with its original value and unit.
 */
export interface SparkCurrencyAmount {
    original_unit: string;
    original_value: number;
}
/**
 * The exit speed for a cooperative withdrawal from Spark to L1.
 */
export type SparkExitSpeed = 'FAST' | 'MEDIUM' | 'SLOW';
/**
 * Gets the balance of the Spark wallet.
 */
export interface SparkGetBalanceRpcInput {
    method: 'getBalance';
    /**
     * The Spark network.
     */
    network?: SparkNetwork;
}
/**
 * Response to the Spark `getBalance` RPC.
 */
export interface SparkGetBalanceRpcResponse {
    method: 'getBalance';
    /**
     * The balance of a Spark wallet.
     */
    data?: SparkBalance;
}
/**
 * Gets a quote for claiming a static deposit.
 */
export interface SparkGetClaimStaticDepositQuoteRpcInput {
    method: 'getClaimStaticDepositQuote';
    /**
     * Parameters for the Spark `getClaimStaticDepositQuote` RPC.
     */
    params: SparkGetClaimStaticDepositQuoteRpcInputParams;
    /**
     * The Spark network.
     */
    network?: SparkNetwork;
}
/**
 * Parameters for the Spark `getClaimStaticDepositQuote` RPC.
 */
export interface SparkGetClaimStaticDepositQuoteRpcInputParams {
    transaction_id: string;
    output_index?: number;
}
/**
 * Response to the Spark `getClaimStaticDepositQuote` RPC.
 */
export interface SparkGetClaimStaticDepositQuoteRpcResponse {
    method: 'getClaimStaticDepositQuote';
    /**
     * Data returned by the Spark `getClaimStaticDepositQuote` RPC.
     */
    data?: SparkGetClaimStaticDepositQuoteRpcResponseData;
}
/**
 * Data returned by the Spark `getClaimStaticDepositQuote` RPC.
 */
export interface SparkGetClaimStaticDepositQuoteRpcResponseData {
    credit_amount_sats: number;
    network: string;
    output_index: number;
    signature: string;
    transaction_id: string;
}
/**
 * Gets a static deposit address for the Spark wallet.
 */
export interface SparkGetStaticDepositAddressRpcInput {
    method: 'getStaticDepositAddress';
    /**
     * The Spark network.
     */
    network?: SparkNetwork;
}
/**
 * Response to the Spark `getStaticDepositAddress` RPC.
 */
export interface SparkGetStaticDepositAddressRpcResponse {
    method: 'getStaticDepositAddress';
    /**
     * Data returned by the Spark `getStaticDepositAddress` RPC.
     */
    data?: SparkGetStaticDepositAddressRpcResponseData;
}
/**
 * Data returned by the Spark `getStaticDepositAddress` RPC.
 */
export interface SparkGetStaticDepositAddressRpcResponseData {
    address: string;
}
/**
 * Gets a fee quote for withdrawing from Spark to a Bitcoin L1 address.
 */
export interface SparkGetWithdrawalFeeQuoteRpcInput {
    method: 'getWithdrawalFeeQuote';
    /**
     * Parameters for the Spark `getWithdrawalFeeQuote` RPC.
     */
    params: SparkGetWithdrawalFeeQuoteRpcInputParams;
    /**
     * The Spark network.
     */
    network?: SparkNetwork;
}
/**
 * Parameters for the Spark `getWithdrawalFeeQuote` RPC.
 */
export interface SparkGetWithdrawalFeeQuoteRpcInputParams {
    amount_sats: number;
    onchain_address: string;
}
/**
 * Response to the Spark `getWithdrawalFeeQuote` RPC.
 */
export interface SparkGetWithdrawalFeeQuoteRpcResponse {
    method: 'getWithdrawalFeeQuote';
    /**
     * A fee quote for a cooperative exit from Spark to Bitcoin L1.
     */
    data?: SparkCoopExitFeeQuote;
}
/**
 * The fee for a Spark Lightning payment.
 */
export interface SparkLightningFee {
    original_unit: string;
    original_value: number;
}
/**
 * A Spark Lightning receive request.
 */
export interface SparkLightningReceiveRequest {
    id: string;
    created_at: string;
    network: string;
    status: string;
    typename: string;
    updated_at: string;
    invoice?: unknown;
    payment_preimage?: string;
    receiver_identity_public_key?: string;
    transfer?: unknown;
}
/**
 * A Spark Lightning send request.
 */
export interface SparkLightningSendRequest {
    id: string;
    created_at: string;
    encoded_invoice: string;
    /**
     * The fee for a Spark Lightning payment.
     */
    fee: SparkLightningFee;
    idempotency_key: string;
    network: string;
    status: string;
    typename: string;
    updated_at: string;
    payment_preimage?: string;
    transfer?: unknown;
}
/**
 * The Spark network.
 */
export type SparkNetwork = 'MAINNET' | 'REGTEST';
/**
 * Strategy for selecting outputs in a Spark token transfer.
 */
export type SparkOutputSelectionStrategy = 'SMALL_FIRST' | 'LARGE_FIRST';
/**
 * Pays a Lightning invoice from the Spark wallet.
 */
export interface SparkPayLightningInvoiceRpcInput {
    method: 'payLightningInvoice';
    /**
     * Parameters for the Spark `payLightningInvoice` RPC.
     */
    params: SparkPayLightningInvoiceRpcInputParams;
    /**
     * The Spark network.
     */
    network?: SparkNetwork;
}
/**
 * Parameters for the Spark `payLightningInvoice` RPC.
 */
export interface SparkPayLightningInvoiceRpcInputParams {
    invoice: string;
    max_fee_sats: number;
    amount_sats_to_send?: number;
    prefer_spark?: boolean;
}
/**
 * Response to the Spark `payLightningInvoice` RPC.
 */
export interface SparkPayLightningInvoiceRpcResponse {
    method: 'payLightningInvoice';
    /**
     * A Spark transfer.
     */
    data?: SparkTransfer | SparkLightningSendRequest;
}
/**
 * Request body for Spark wallet RPC operations, discriminated by method.
 */
export type SparkRpcInput = SparkTransferRpcInput | SparkGetBalanceRpcInput | SparkTransferTokensRpcInput | SparkGetStaticDepositAddressRpcInput | SparkGetClaimStaticDepositQuoteRpcInput | SparkClaimStaticDepositRpcInput | SparkCreateLightningInvoiceRpcInput | SparkPayLightningInvoiceRpcInput | SparkSignMessageWithIdentityKeyRpcInput | SparkWithdrawRpcInput | SparkGetWithdrawalFeeQuoteRpcInput;
/**
 * Response body for Spark wallet RPC operations, discriminated by method.
 */
export type SparkRpcResponse = SparkTransferRpcResponse | SparkGetBalanceRpcResponse | SparkTransferTokensRpcResponse | SparkGetStaticDepositAddressRpcResponse | SparkGetClaimStaticDepositQuoteRpcResponse | SparkClaimStaticDepositRpcResponse | SparkCreateLightningInvoiceRpcResponse | SparkPayLightningInvoiceRpcResponse | SparkSignMessageWithIdentityKeyRpcResponse | SparkWithdrawRpcResponse | SparkGetWithdrawalFeeQuoteRpcResponse;
/**
 * Signs a message with the Spark identity key.
 */
export interface SparkSignMessageWithIdentityKeyRpcInput {
    method: 'signMessageWithIdentityKey';
    /**
     * Parameters for the Spark `signMessageWithIdentityKey` RPC.
     */
    params: SparkSignMessageWithIdentityKeyRpcInputParams;
    /**
     * The Spark network.
     */
    network?: SparkNetwork;
}
/**
 * Parameters for the Spark `signMessageWithIdentityKey` RPC.
 */
export interface SparkSignMessageWithIdentityKeyRpcInputParams {
    message: string;
    compact?: boolean;
}
/**
 * Response to the Spark `signMessageWithIdentityKey` RPC.
 */
export interface SparkSignMessageWithIdentityKeyRpcResponse {
    method: 'signMessageWithIdentityKey';
    /**
     * Data returned by the Spark `signMessageWithIdentityKey` RPC.
     */
    data?: SparkSignMessageWithIdentityKeyRpcResponseData;
}
/**
 * Data returned by the Spark `signMessageWithIdentityKey` RPC.
 */
export interface SparkSignMessageWithIdentityKeyRpcResponseData {
    signature: string;
}
/**
 * A Spark signing keyshare.
 */
export interface SparkSigningKeyshare {
    owner_identifiers: Array<string>;
    public_key: string;
    public_shares: {
        [key: string]: string;
    };
    threshold: number;
    updated_time: string;
}
/**
 * Balance of a Spark token.
 */
export interface SparkTokenBalance {
    balance: string;
    /**
     * Metadata for a Spark user token.
     */
    token_metadata: SparkUserTokenMetadata;
}
/**
 * A Spark transfer.
 */
export interface SparkTransfer {
    id: string;
    leaves: Array<SparkTransferLeaf>;
    receiver_identity_public_key: string;
    sender_identity_public_key: string;
    status: string;
    total_value: number;
    transfer_direction: string;
    type: string;
    created_time?: string;
    expiry_time?: string;
    updated_time?: string;
}
/**
 * A Spark transfer leaf.
 */
export interface SparkTransferLeaf {
    intermediate_refund_tx: string;
    secret_cipher: string;
    signature: string;
    /**
     * A Spark wallet leaf node.
     */
    leaf?: SparkWalletLeaf;
}
/**
 * Transfers satoshis to a Spark address.
 */
export interface SparkTransferRpcInput {
    method: 'transfer';
    /**
     * Parameters for the Spark `transfer` RPC.
     */
    params: SparkTransferRpcInputParams;
    /**
     * The Spark network.
     */
    network?: SparkNetwork;
}
/**
 * Parameters for the Spark `transfer` RPC.
 */
export interface SparkTransferRpcInputParams {
    amount_sats: number;
    receiver_spark_address: string;
}
/**
 * Response to the Spark `transfer` RPC.
 */
export interface SparkTransferRpcResponse {
    method: 'transfer';
    /**
     * A Spark transfer.
     */
    data?: SparkTransfer;
}
/**
 * Transfers tokens to a Spark address.
 */
export interface SparkTransferTokensRpcInput {
    method: 'transferTokens';
    /**
     * Parameters for the Spark `transferTokens` RPC.
     */
    params: SparkTransferTokensRpcInputParams;
    /**
     * The Spark network.
     */
    network?: SparkNetwork;
}
/**
 * Parameters for the Spark `transferTokens` RPC.
 */
export interface SparkTransferTokensRpcInputParams {
    receiver_spark_address: string;
    token_amount: number;
    token_identifier: string;
    /**
     * Strategy for selecting outputs in a Spark token transfer.
     */
    output_selection_strategy?: SparkOutputSelectionStrategy;
    selected_outputs?: Array<OutputWithPreviousTransactionData>;
}
/**
 * Response to the Spark `transferTokens` RPC.
 */
export interface SparkTransferTokensRpcResponse {
    method: 'transferTokens';
    /**
     * Data returned by the Spark `transferTokens` RPC.
     */
    data?: SparkTransferTokensRpcResponseData;
}
/**
 * Data returned by the Spark `transferTokens` RPC.
 */
export interface SparkTransferTokensRpcResponseData {
    id: string;
}
/**
 * Metadata for a Spark user token.
 */
export interface SparkUserTokenMetadata {
    decimals: number;
    max_supply: string;
    raw_token_identifier: string;
    token_name: string;
    token_public_key: string;
    token_ticker: string;
}
/**
 * A Spark wallet leaf node.
 */
export interface SparkWalletLeaf {
    id: string;
    /**
     * The Spark network.
     */
    network: SparkNetwork;
    node_tx: string;
    owner_identity_public_key: string;
    refund_tx: string;
    status: string;
    tree_id: string;
    value: number;
    verifying_public_key: string;
    vout: number;
    parent_node_id?: string;
    /**
     * A Spark signing keyshare.
     */
    signing_keyshare?: SparkSigningKeyshare;
}
/**
 * Withdraws from Spark to a Bitcoin L1 address (cooperative exit).
 */
export interface SparkWithdrawRpcInput {
    method: 'withdraw';
    /**
     * Parameters for the Spark `withdraw` RPC.
     */
    params: SparkWithdrawRpcInputParams;
    /**
     * The Spark network.
     */
    network?: SparkNetwork;
}
/**
 * Parameters for the Spark `withdraw` RPC.
 */
export interface SparkWithdrawRpcInputParams {
    /**
     * The exit speed for a cooperative withdrawal from Spark to L1.
     */
    exit_speed: SparkExitSpeed;
    onchain_address: string;
    amount_sats?: number;
    deduct_fee_from_withdrawal_amount?: boolean;
    fee_amount_sats?: number;
    fee_quote_id?: string;
}
/**
 * Response to the Spark `withdraw` RPC.
 */
export interface SparkWithdrawRpcResponse {
    method: 'withdraw';
    /**
     * A cooperative exit request from Spark to Bitcoin L1.
     */
    data?: SparkCoopExitRequest;
}
/**
 * SUI transaction commands allowlist for raw_sign endpoint policy evaluation
 */
export type SuiCommandName = 'TransferObjects' | 'SplitCoins' | 'MergeCoins';
/**
 * "accepted" if the network has acknowledged the transaction, "rejected" if the
 * network refused it, "skipped" if dry_run was set. Not an onchain confirmation.
 */
export type SwapSubmissionStatus = 'accepted' | 'rejected' | 'skipped';
/**
 * An AA authorization for Tempo transactions with P256/WebAuthn signatures.
 */
export interface TempoAaAuthorization {
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    chain_id: Quantity;
    contract: string;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    nonce: Quantity;
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    signature: Hex;
}
/**
 * A single call within a Tempo batched transaction.
 */
export interface TempoCall {
    to: string;
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    data?: Hex;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    value?: Quantity;
}
/**
 * A fee payer signature for sponsored Tempo transactions (secp256k1 only).
 */
export interface TempoFeePayerSignature {
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    r: Hex;
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    s: Hex;
    y_parity: 0 | 1;
}
/**
 * A Spark token output.
 */
export interface TokenOutput {
    owner_public_key: string;
    token_amount: string;
    id?: string;
    revocation_commitment?: string;
    token_identifier?: string;
    token_public_key?: string;
    withdraw_bond_sats?: number;
    withdraw_relative_block_locktime?: number;
}
/**
 * The destination address for a token transfer. Optionally specify a different
 * asset or chain for cross-asset or cross-chain transfers.
 */
export interface TokenTransferDestination {
    /**
     * Recipient address (hex for EVM, base58 for Solana, base58check for Tron)
     */
    address: string;
    /**
     * The destination asset. Required for cross-asset transfers (e.g., source 'usdt'
     * to destination 'usdc').
     */
    asset?: string;
    /**
     * The destination blockchain network. Required for cross-chain transfers (e.g.,
     * source 'tempo' to destination 'base').
     */
    chain?: string;
}
/**
 * The source asset, amount, and chain for a token transfer. Specify either `asset`
 * (named) or `asset_address` (custom), not both.
 */
export type TokenTransferSource = NamedTokenTransferSource | CustomTokenTransferSource;
/**
 * Total fees assessed on a transfer, in BPS
 */
export interface TotalFeeConfigurationBps {
    /**
     * Discriminator: total fee specified in BPS.
     */
    type: 'total_fee_bps';
    /**
     * Total fee in basis points (1 bps = 0.01%).
     */
    value: number;
}
/**
 * Chains supported for transaction history queries.
 */
export type TransactionChainNameInput = 'ethereum' | 'arbitrum' | 'avalanche' | 'base' | 'base_sepolia' | 'bsc' | 'tempo' | 'linea' | 'optimism' | 'polygon' | 'solana' | 'sepolia' | (string & {});
/**
 * Details of a wallet transaction, varying by transaction type.
 */
export type TransactionDetail = TransferSentTransactionDetail | TransferReceivedTransactionDetail;
/**
 * Token contract address (EVM: 0x-prefixed hex) or mint address (Solana: base58),
 * used to filter wallet transactions.
 */
export type TransactionTokenAddressInput = string;
/**
 * Request body for requesting a quote for a cross-asset or cross-chain (DADC)
 * transfer.
 */
export interface TransferQuoteRequestBody {
    /**
     * The destination address for a token transfer. Optionally specify a different
     * asset or chain for cross-asset or cross-chain transfers.
     */
    destination: TokenTransferDestination;
    /**
     * The source asset, amount, and chain for a token transfer. Specify either `asset`
     * (named) or `asset_address` (custom), not both.
     */
    source: TokenTransferSource;
    /**
     * Amount as a decimal string in the token's standard unit (e.g. "1.5" for 1.5
     * USDC). For exact_input, the amount to send. For exact_output, the exact amount
     * to receive. Takes precedence over source.amount when both are provided.
     */
    amount?: string;
    /**
     * Whether the amount refers to the input token or output token.
     */
    amount_type?: AmountType;
    /**
     * Total fees assessed on a transfer, in BPS
     */
    fee_configuration?: FeeConfiguration;
    /**
     * Maximum allowed slippage in basis points (1 bps = 0.01%). Only applicable for
     * cross-chain or cross-asset transfers; omit to use the provider default.
     */
    slippage_bps?: number;
}
/**
 * Response containing a quote for a cross-asset or cross-chain (DADC) transfer.
 */
export interface TransferQuoteResponse {
    /**
     * The destination address for a token transfer. Optionally specify a different
     * asset or chain for cross-asset or cross-chain transfers.
     */
    destination: TokenTransferDestination;
    /**
     * Estimated fees in USD for the transfer. Only present for cross-chain transfers.
     */
    estimated_fees: Array<FeeLineItem>;
    /**
     * Estimated input amount in decimals. For exact_input, this equals source.amount.
     * For exact_output, this is the estimated amount the sender needs to provide.
     */
    estimated_input_amount: string;
    /**
     * Estimated output amount in decimals. For exact_input, this is an estimate
     * subject to slippage. For exact_output, this is the guaranteed exact amount to be
     * received.
     */
    estimated_output_amount: string;
    /**
     * Quote expiry as Unix timestamp (seconds).
     */
    expires_at: number;
    /**
     * The source asset, amount, and chain for a token transfer. Specify either `asset`
     * (named) or `asset_address` (custom), not both.
     */
    source: TokenTransferSource;
    /**
     * Whether the amount refers to the input token or output token.
     */
    amount_type?: AmountType;
    /**
     * Gas cost for a blockchain action. Includes both raw base-unit amount and a
     * human-readable decimal string, plus the gas token symbol.
     */
    estimated_gas?: Gas;
}
/**
 * Details for a received transfer transaction.
 */
export interface TransferReceivedTransactionDetail {
    asset: 'usdc' | 'usdc.e' | 'eth' | 'avax' | 'pol' | 'bnb' | 'usdt' | 'eurc' | 'usdb' | 'ousd' | 'pathusd' | 'sol' | 'trx' | (string & {});
    /**
     * Supported blockchain network names for wallet balance and transaction queries.
     */
    chain: WalletAssetChainNameInput;
    display_values: {
        [key: string]: string;
    };
    raw_value: string;
    raw_value_decimals: number;
    recipient: string;
    recipient_privy_user_id: string | null;
    sender: string;
    sender_privy_user_id: string | null;
    type: 'transfer_received';
}
/**
 * Request body for initiating a sponsored token transfer from an embedded wallet.
 */
export interface TransferRequestBody {
    /**
     * The destination address for a token transfer. Optionally specify a different
     * asset or chain for cross-asset or cross-chain transfers.
     */
    destination: TokenTransferDestination;
    /**
     * The source asset, amount, and chain for a token transfer. Specify either `asset`
     * (named) or `asset_address` (custom), not both.
     */
    source: TokenTransferSource;
    /**
     * Amount as a decimal string in the token's standard unit (e.g. "1.5" for 1.5
     * USDC). For exact_input, the amount to send. For exact_output, the exact amount
     * to receive. Takes precedence over source.amount when both are provided.
     */
    amount?: string;
    /**
     * Whether the amount refers to the input token or output token.
     */
    amount_type?: AmountType;
    /**
     * Total fees assessed on a transfer, in BPS
     */
    fee_configuration?: FeeConfiguration;
    /**
     * Unique caller-generated nonce used to prevent replaying a signed wallet action
     * request. Must be at least 24 characters (e.g. a cuid2 or UUID).
     */
    nonce?: WalletActionNonce;
    /**
     * Developer-provided identifier for this request. Must be unique per app.
     */
    reference_id?: string;
    /**
     * Maximum allowed slippage in basis points (1 bps = 0.01%). Only applicable for
     * cross-chain or cross-asset transfers; omit to use the provider default.
     */
    slippage_bps?: number;
}
/**
 * Details for a sent transfer transaction.
 */
export interface TransferSentTransactionDetail {
    asset: 'usdc' | 'usdc.e' | 'eth' | 'avax' | 'pol' | 'bnb' | 'usdt' | 'eurc' | 'usdb' | 'ousd' | 'pathusd' | 'sol' | 'trx' | (string & {});
    /**
     * Supported blockchain network names for wallet balance and transaction queries.
     */
    chain: WalletAssetChainNameInput;
    display_values: {
        [key: string]: string;
    };
    raw_value: string;
    raw_value_decimals: number;
    recipient: string;
    recipient_privy_user_id: string | null;
    sender: string;
    sender_privy_user_id: string | null;
    type: 'transfer_sent';
}
/**
 * A Tron contract, discriminated by type. Supported types: TransferContract,
 * TriggerSmartContract.
 */
export type TronContract = TronTransferContract | TronTriggerSmartContract;
/**
 * Tron raw_data for tron_sendTransaction. Block reference fields are optional;
 * Privy fetches fresh values if omitted.
 */
export interface TronRawDataForSend {
    contract: Array<TronContract>;
    data?: string;
    expiration?: number;
    fee_limit?: number;
    ref_block_bytes?: string;
    ref_block_hash?: string;
    timestamp?: number;
}
/**
 * Tron raw_data for tron_signTransaction. Block reference fields are required;
 * caller is responsible for fetching them.
 */
export interface TronRawDataForSign {
    contract: Array<TronContract>;
    expiration: number;
    ref_block_bytes: string;
    ref_block_hash: string;
    data?: string;
    fee_limit?: number;
    timestamp?: number;
}
/**
 * Request body for Tron wallet RPC operations, discriminated by method.
 */
export type TronRpcInput = TronSignTransactionRpcInput | TronSendTransactionRpcInput;
/**
 * Response body for Tron wallet RPC operations, discriminated by method.
 */
export type TronRpcResponse = TronSignTransactionRpcResponse | TronSendTransactionRpcResponse;
/**
 * Executes the Tron `tron_sendTransaction` RPC to sign and broadcast a
 * transaction.
 */
export interface TronSendTransactionRpcInput {
    method: 'tron_sendTransaction';
    /**
     * Parameters for the Tron `tron_sendTransaction` RPC.
     */
    params: TronSendTransactionRpcInputParams;
    /**
     * A valid CAIP-2 chain ID (e.g. 'eip155:4217' for Tempo, 'eip155:1' for Ethereum).
     */
    caip2?: AppsAPI.Caip2;
}
/**
 * Parameters for the Tron `tron_sendTransaction` RPC.
 */
export interface TronSendTransactionRpcInputParams {
    /**
     * Tron raw_data for tron_sendTransaction. Block reference fields are optional;
     * Privy fetches fresh values if omitted.
     */
    raw_data: TronRawDataForSend;
    reference_id?: string;
}
/**
 * Response to the Tron `tron_sendTransaction` RPC.
 */
export interface TronSendTransactionRpcResponse {
    /**
     * Data returned by the Tron `tron_sendTransaction` RPC.
     */
    data: TronSendTransactionRpcResponseData;
    method: 'tron_sendTransaction';
}
/**
 * Data returned by the Tron `tron_sendTransaction` RPC.
 */
export interface TronSendTransactionRpcResponseData {
    /**
     * A valid CAIP-2 chain ID (e.g. 'eip155:4217' for Tempo, 'eip155:1' for Ethereum).
     */
    caip2: AppsAPI.Caip2;
    hash: string;
    transaction_id: string;
    reference_id?: string;
}
/**
 * Executes the Tron `tron_signTransaction` RPC to sign a transaction. The caller
 * is responsible for broadcasting.
 */
export interface TronSignTransactionRpcInput {
    method: 'tron_signTransaction';
    /**
     * Parameters for the Tron `tron_signTransaction` RPC.
     */
    params: TronSignTransactionRpcInputParams;
}
/**
 * Parameters for the Tron `tron_signTransaction` RPC.
 */
export interface TronSignTransactionRpcInputParams {
    /**
     * Tron raw_data for tron_signTransaction. Block reference fields are required;
     * caller is responsible for fetching them.
     */
    raw_data: TronRawDataForSign;
}
/**
 * Response to the Tron `tron_signTransaction` RPC.
 */
export interface TronSignTransactionRpcResponse {
    /**
     * Data returned by the Tron `tron_signTransaction` RPC.
     */
    data: TronSignTransactionRpcResponseData;
    method: 'tron_signTransaction';
}
/**
 * Data returned by the Tron `tron_signTransaction` RPC.
 */
export interface TronSignTransactionRpcResponseData {
    encoding: 'hex';
    signed_transaction: string;
}
/**
 * Tron native TRX transfer contract.
 */
export interface TronTransferContract {
    amount: number;
    /**
     * Tron address in hex format: 41-prefixed, 42 hex characters (21 bytes), no 0x
     * prefix.
     */
    owner_address: SharedAPI.TronHexAddress;
    /**
     * Tron address in hex format: 41-prefixed, 42 hex characters (21 bytes), no 0x
     * prefix.
     */
    to_address: SharedAPI.TronHexAddress;
    type: 'TransferContract';
}
/**
 * Tron smart contract call (TRC-20 transfers and general contract interactions).
 */
export interface TronTriggerSmartContract {
    /**
     * Tron address in hex format: 41-prefixed, 42 hex characters (21 bytes), no 0x
     * prefix.
     */
    contract_address: SharedAPI.TronHexAddress;
    /**
     * Tron address in hex format: 41-prefixed, 42 hex characters (21 bytes), no 0x
     * prefix.
     */
    owner_address: SharedAPI.TronHexAddress;
    type: 'TriggerSmartContract';
    call_token_value?: number;
    call_value?: number;
    data?: string;
    token_id?: number;
}
/**
 * The domain parameters for EIP-712 typed data signing.
 */
export type TypedDataDomainInputParams = {
    [key: string]: unknown;
};
/**
 * A single field definition in an EIP-712 typed data type.
 */
export interface TypedDataTypeFieldInput {
    name: string;
    type: string;
}
/**
 * The type definitions for EIP-712 typed data signing.
 */
export type TypedDataTypesInputParams = {
    [key: string]: Array<TypedDataTypeFieldInput>;
};
/**
 * An unsigned Ethereum transaction object. Supports standard EVM transaction types
 * (0, 1, 2, 4) and Tempo transactions (type 118).
 */
export type UnsignedEthereumTransaction = UnsignedStandardEthereumTransaction | UnsignedTempoTransaction;
/**
 * An unsigned standard Ethereum transaction object. Supports EVM transaction types
 * 0, 1, 2, and 4.
 */
export interface UnsignedStandardEthereumTransaction {
    authorization_list?: Array<EthereumSign7702Authorization>;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    chain_id?: Quantity;
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    data?: Hex;
    from?: string;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    gas_limit?: Quantity;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    gas_price?: Quantity;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    max_fee_per_gas?: Quantity;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    max_priority_fee_per_gas?: Quantity;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    nonce?: Quantity;
    to?: string;
    type?: 0 | 1 | 2 | 4;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    value?: Quantity;
}
/**
 * An unsigned Tempo transaction (type 118) with batched calls.
 */
export interface UnsignedTempoTransaction {
    calls: Array<TempoCall>;
    type: 118;
    aa_authorization_list?: Array<TempoAaAuthorization>;
    access_list?: Array<AccessListEntry>;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    chain_id?: Quantity;
    /**
     * A fee payer signature for sponsored Tempo transactions (secp256k1 only).
     */
    fee_payer_signature?: TempoFeePayerSignature;
    fee_token?: string;
    from?: string;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    gas_limit?: Quantity;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    max_fee_per_gas?: Quantity;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    max_priority_fee_per_gas?: Quantity;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    nonce?: Quantity;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    nonce_key?: Quantity;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    valid_after?: Quantity;
    /**
     * A quantity value that can be either a hex string starting with '0x' or a
     * non-negative integer.
     */
    valid_before?: Quantity;
}
/**
 * An ERC-4337 user operation.
 */
export interface UserOperationInput {
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    call_data: Hex;
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    call_gas_limit: Hex;
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    max_fee_per_gas: Hex;
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    max_priority_fee_per_gas: Hex;
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    nonce: Hex;
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    pre_verification_gas: Hex;
    sender: string;
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    verification_gas_limit: Hex;
    factory?: string;
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    factory_data?: Hex;
    paymaster?: string;
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    paymaster_data?: Hex;
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    paymaster_post_op_gas_limit?: Hex;
    /**
     * A hex-encoded string prefixed with '0x', capped at 300002 characters (150,000
     * bytes).
     */
    paymaster_verification_gas_limit?: Hex;
}
/**
 * A binding that scopes a user signing key to a specific intent.
 */
export interface UserSigningKeyBinding {
    intentId: string;
    type: 'intent';
}
/**
 * A wallet managed by Privy's wallet infrastructure.
 */
export interface Wallet {
    /**
     * Unique ID of the wallet. This will be the primary identifier when using the
     * wallet in the future.
     */
    id: string;
    /**
     * Additional signers for the wallet.
     */
    additional_signers: WalletAdditionalSigner;
    /**
     * Address of the wallet.
     */
    address: string;
    /**
     * The wallet chain types.
     */
    chain_type: WalletChainType;
    /**
     * Unix timestamp of when the wallet was created in milliseconds.
     */
    created_at: number;
    /**
     * Unix timestamp of when the wallet was exported in milliseconds, if the wallet
     * was exported.
     */
    exported_at: number | null;
    /**
     * Unix timestamp of when the wallet was imported in milliseconds, if the wallet
     * was imported.
     */
    imported_at: number | null;
    /**
     * The key quorum ID of the owner of the wallet.
     */
    owner_id: string | null;
    /**
     * List of policy IDs for policies that are enforced on the wallet.
     */
    policy_ids: Array<string>;
    /**
     * Unix timestamp of when the wallet was archived in milliseconds, or null if the
     * wallet is active.
     */
    archived_at?: number | null;
    /**
     * The number of keys that must sign for an action to be valid.
     */
    authorization_threshold?: number;
    /**
     * Information about the custodian managing this wallet.
     */
    custody?: WalletCustodian;
    /**
     * A human-readable label for the wallet.
     */
    display_name?: string;
    /**
     * The entity a wallet is attributed to.
     */
    entity?: WalletEntity | null;
    /**
     * A customer-provided identifier for mapping to external systems. URL-safe
     * characters only ([a-zA-Z0-9_-]), max 64 chars. Write-once: cannot be changed
     * once set.
     */
    external_id?: string;
    /**
     * The compressed, raw public key for the wallet along the chain cryptographic
     * curve.
     */
    public_key?: string;
}
/**
 * Unique caller-generated nonce used to prevent replaying a signed wallet action
 * request. Must be at least 24 characters (e.g. a cuid2 or UUID).
 */
export type WalletActionNonce = string;
/**
 * Additional signers for the wallet.
 */
export type WalletAdditionalSigner = Array<WalletAdditionalSignerItem>;
/**
 * A single additional signer on a wallet, with an optional policy override.
 */
export interface WalletAdditionalSignerItem {
    /**
     * A unique identifier for a key quorum.
     */
    signer_id: SharedAPI.KeyQuorumID;
    /**
     * An optional list of up to one policy ID to enforce on the wallet.
     */
    override_policy_ids?: PolicyInput;
}
/**
 * Input for registering or updating an application public signing key for
 * API-based wallet actions.
 */
export interface WalletAPIRegisterAuthorizationKeyInput {
    public_key: string;
    display_name?: string;
    /**
     * The role of an authorization key, controlling what actions it can authorize on a
     * wallet.
     */
    role?: AuthorizationKeyRole | null;
}
/**
 * Input for revoking an application authorization key.
 */
export interface WalletAPIRevokeAuthorizationKeyInput {
    id: string;
}
/**
 * A named asset supported across all chains.
 */
export type WalletAsset = 'usdc' | 'usdc.e' | 'eth' | 'avax' | 'pol' | 'bnb' | 'usdt' | 'eurc' | 'usdb' | 'ousd' | 'pathusd' | 'sol' | 'trx';
/**
 * Supported blockchain network names for wallet balance and transaction queries.
 */
export type WalletAssetChainNameInput = 'ethereum' | 'arbitrum' | 'avalanche' | 'base' | 'tempo' | 'linea' | 'optimism' | 'polygon' | 'bsc' | 'solana' | 'tron' | 'zksync_era' | 'robinhood' | 'tempo_testnet' | 'hoodi' | 'sepolia' | 'arbitrum_sepolia' | 'avalanche_fuji' | 'base_sepolia' | 'linea_testnet' | 'optimism_sepolia' | 'polygon_amoy' | 'bsc_testnet' | 'solana_devnet' | 'solana_testnet' | 'tron_nile' | 'robinhood_testnet' | (string & {});
/**
 * Request body for creating an encrypted, bound user signing key.
 */
export interface WalletAuthenticateBoundEncryptedRequestBody {
    /**
     * Bindings that scope the USK. The key can only authorize the bound values.
     */
    bindings: Array<UserSigningKeyBinding>;
    encryption_type: 'HPKE';
    recipient_public_key: string;
    user_jwt: string;
}
/**
 * Request body for creating a user signing key scoped to specific bindings. The
 * returned USK can only authorize the bound values and cannot sign other RPC
 * requests.
 */
export type WalletAuthenticateBoundRequestBody = WalletAuthenticateBoundEncryptedRequestBody | WalletAuthenticateBoundUnencryptedRequestBody;
/**
 * Request body for creating an unencrypted, bound user signing key.
 */
export interface WalletAuthenticateBoundUnencryptedRequestBody {
    /**
     * Bindings that scope the USK. The key can only authorize the bound values.
     */
    bindings: Array<UserSigningKeyBinding>;
    user_jwt: string;
}
/**
 * The response from authenticating a wallet with intent bindings, containing an
 * authorization key, wallet data, and the bindings the key is scoped to.
 */
export type WalletAuthenticateIntentsResponse = EncryptedBoundAuthenticateResponse | RawBoundAuthenticateResponse;
/**
 * Request body for wallet authentication with HPKE-encrypted response.
 */
export interface WalletAuthenticateRequestBody {
    /**
     * The encryption type for the authentication response. Currently only supports
     * HPKE.
     */
    encryption_type: 'HPKE';
    /**
     * The public key of your ECDH keypair, in base64-encoded, SPKI-format, whose
     * private key will be able to decrypt the session key.
     */
    recipient_public_key: string;
    /**
     * The user's JWT, to be used to authenticate the user.
     */
    user_jwt: string;
}
/**
 * The response from authenticating a wallet, containing an authorization key and
 * wallet data.
 */
export type WalletAuthenticateWithJwtResponse = EncryptedWalletAuthenticateResponse | RawWalletAuthenticateResponse;
/**
 * Headers required to authorize wallet operations.
 */
export interface WalletAuthorizationHeaders {
    /**
     * ID of your Privy app.
     */
    'privy-app-id': string;
    /**
     * Request authorization signature. If multiple signatures are required, they
     * should be comma separated.
     */
    'privy-authorization-signature'?: string;
    /**
     * Request expiry. Value is a Unix timestamp in milliseconds representing the
     * deadline by which the request must be processed.
     */
    'privy-request-expiry'?: string;
}
/**
 * List of wallet automation attachments.
 */
export interface WalletAutomationAttachmentListResponse {
    data: Array<WalletAutomationAttachmentResponse>;
}
/**
 * A wallet automation attachment linking an automation to a specific wallet.
 */
export interface WalletAutomationAttachmentResponse {
    id: string;
    automation_id: string;
    created_at: string;
    /**
     * Per-attachment parameters for swap automations.
     */
    params: WalletAutomationsAPI.SwapAttachmentParams | null;
    /**
     * Automation lifecycle state: 'enabled' = running, 'disabled' = not running.
     */
    status: WalletAutomationsAPI.WalletAutomationStatus;
    updated_at: string;
    wallet_id: string;
}
/**
 * Request body for batch wallet creation.
 */
export interface WalletBatchCreateInput {
    /**
     * Array of wallet creation requests. Minimum 1, maximum 100.
     */
    wallets: Array<WalletBatchItemInput>;
}
/**
 * Response for a batch wallet creation request.
 */
export interface WalletBatchCreateResponse {
    /**
     * Array of results for each wallet creation request, in the same order as input.
     */
    results: Array<WalletBatchCreateResult>;
}
/**
 * A single result from a batch wallet creation operation.
 */
export type WalletBatchCreateResult = WalletBatchCreateResult.WalletBatchCreateSuccess | WalletBatchCreateResult.WalletBatchCreateFailure;
export declare namespace WalletBatchCreateResult {
    /**
     * A successful wallet creation result within a batch operation.
     */
    interface WalletBatchCreateSuccess {
        /**
         * The index of the wallet in the original request array.
         */
        index: number;
        success: true;
        /**
         * A wallet managed by Privy's wallet infrastructure.
         */
        wallet: WalletsAPI.Wallet;
    }
    /**
     * A failed wallet creation result within a batch operation.
     */
    interface WalletBatchCreateFailure {
        /**
         * A PrivyErrorCode string identifying the error type (e.g., "invalid_data",
         * "resource_conflict").
         */
        code: string;
        /**
         * A human-readable error message with details about what went wrong.
         */
        error: string;
        /**
         * The index of the wallet in the original request array.
         */
        index: number;
        success: false;
    }
}
/**
 * Input for a single wallet in a batch creation request.
 */
export interface WalletBatchItemInput {
    /**
     * The wallet chain types.
     */
    chain_type: WalletChainType;
    /**
     * Additional signers for the wallet.
     */
    additional_signers?: AdditionalSignerInput;
    /**
     * A human-readable label for the wallet.
     */
    display_name?: string;
    /**
     * Request body for assigning an entity to a wallet.
     */
    entity?: WalletEntityAssignmentRequestBody;
    /**
     * A customer-provided identifier for mapping to external systems. URL-safe
     * characters only ([a-zA-Z0-9_-]), max 64 chars. Write-once: cannot be changed
     * after creation.
     */
    external_id?: string;
    /**
     * The owner of the resource, specified as a Privy user ID, a P-256 public key, or
     * null to remove the current owner.
     */
    owner?: SharedAPI.OwnerInput | null;
    /**
     * The key quorum ID to set as the owner of the resource. If you provide this, do
     * not specify an owner.
     */
    owner_id?: SharedAPI.OwnerIDInput | null;
    /**
     * List of policy IDs for policies that should be enforced on the wallet.
     * Currently, only one policy is supported per wallet.
     */
    policy_ids?: Array<string>;
}
/**
 * The wallet chain types.
 */
export type WalletChainType = 'ethereum' | 'solana' | 'cosmos' | 'stellar' | 'sui' | 'aptos' | 'movement' | 'tron' | 'bitcoin-segwit' | 'bitcoin-taproot' | 'pearl' | 'near' | 'ton' | 'starknet' | 'xrpl' | 'spark';
/**
 * The response from creating wallets with an associated recovery user.
 */
export interface WalletCreateWalletsWithRecoveryResponse {
    /**
     * The ID of the created user.
     */
    recovery_user_id: string;
    /**
     * The wallets that were created.
     */
    wallets: Array<Wallet>;
}
/**
 * Information about the custodian managing this wallet.
 */
export interface WalletCustodian {
    /**
     * The custodian responsible for the wallet.
     */
    provider: string;
    /**
     * The resource ID of the beneficiary of the custodial wallet.
     */
    provider_user_id: string;
}
/**
 * The entity a wallet is attributed to.
 */
export interface WalletEntity {
    /**
     * A Privy entity ID.
     */
    id: EntityID;
    /**
     * The type of entity a wallet is attributed to.
     */
    type: WalletEntityType;
}
/**
 * Request body for assigning an entity to a wallet.
 */
export interface WalletEntityAssignmentRequestBody {
    /**
     * A Privy entity ID.
     */
    id: EntityID;
    /**
     * The type of entity a wallet is attributed to.
     */
    type: WalletEntityType;
}
/**
 * The entity assignment for a wallet.
 */
export interface WalletEntityAssignmentResponse {
    /**
     * Unique wallet entity assignment identifier.
     */
    id: string;
    /**
     * Unix timestamp when the assignment was created.
     */
    created_at: number;
    /**
     * The entity a wallet is attributed to.
     */
    entity: WalletEntity;
    /**
     * Unix timestamp when the assignment was last updated.
     */
    updated_at: number;
    /**
     * ID of the assigned wallet.
     */
    wallet_id: string;
}
/**
 * The type of entity a wallet is attributed to.
 */
export type WalletEntityType = 'user' | 'organization';
/**
 * The entropy type of the wallet.
 */
export type WalletEntropyType = 'hd' | 'private-key';
/**
 * A named asset on Ethereum-compatible chains.
 */
export type WalletEthereumAsset = 'usdc' | 'usdc.e' | 'eth' | 'avax' | 'pol' | 'bnb' | 'usdt' | 'eurc' | 'usdb' | 'ousd' | 'pathusd';
/**
 * Request body for exporting a wallet private key.
 */
export interface WalletExportRequestBody {
    /**
     * The encryption type of the wallet to import. Currently only supports `HPKE`.
     */
    encryption_type: HpkeEncryption;
    /**
     * The base64-encoded encryption public key to encrypt the wallet private key with.
     */
    recipient_public_key: string;
    export_seed_phrase?: boolean;
}
/**
 * Response body containing the encrypted wallet private key.
 */
export interface WalletExportResponseBody {
    /**
     * The encrypted private key.
     */
    ciphertext: string;
    /**
     * The base64-encoded encapsulated key that was generated during encryption, for
     * use during decryption.
     */
    encapsulated_key: string;
    /**
     * The encryption type of the wallet to import. Currently only supports `HPKE`.
     */
    encryption_type: HpkeEncryption;
}
/**
 * Response from initializing a wallet import, containing the encryption public
 * key.
 */
export interface WalletImportInitResponse {
    encryption_public_key: string;
    /**
     * The encryption type of the wallet to import. Currently only supports `HPKE`.
     */
    encryption_type: HpkeEncryption;
    import_id?: string;
}
/**
 * The chain type of the wallet to import. Supports `ethereum`, `solana`,
 * `stellar`, `tron`, `sui`, `aptos`, and `xrpl`.
 */
export type WalletImportSupportedChains = 'ethereum' | 'solana' | 'stellar' | 'tron' | 'sui' | 'aptos' | 'xrpl';
/**
 * The entropy type of the wallet to import. Supports `private-key` for raw private
 * keys and `hd` for HD wallet seed phrases.
 */
export type WalletImportSupportedEntropyTypes = 'private-key' | 'hd';
/**
 * The response body from revoking a wallet delegation.
 */
export interface WalletRevokeResponse {
    message: string;
}
/**
 * Request body for wallet RPC operations, discriminated by method.
 */
export type WalletRpcRequestBody = EthereumSignTransactionRpcInput | EthereumSendTransactionRpcInput | EthereumPersonalSignRpcInput | EthereumSignTypedDataRpcInput | EthereumSecp256k1SignRpcInput | EthereumSign7702AuthorizationRpcInput | EthereumSignUserOperationRpcInput | EthereumSendCallsRpcInput | AptosSignTransactionRpcInput | SolanaSignTransactionRpcInput | SolanaSignAndSendTransactionRpcInput | SolanaSignMessageRpcInput | SparkTransferRpcInput | SparkGetBalanceRpcInput | SparkTransferTokensRpcInput | SparkGetStaticDepositAddressRpcInput | SparkGetClaimStaticDepositQuoteRpcInput | SparkClaimStaticDepositRpcInput | SparkCreateLightningInvoiceRpcInput | SparkPayLightningInvoiceRpcInput | SparkSignMessageWithIdentityKeyRpcInput | SparkWithdrawRpcInput | SparkGetWithdrawalFeeQuoteRpcInput | TronSignTransactionRpcInput | TronSendTransactionRpcInput | XrplSignTransactionRpcInput | NearSignTransactionRpcRequestBody | ExportPrivateKeyRpcInput | ExportSeedPhraseRpcInput;
/**
 * Response body for wallet RPC operations, discriminated by method.
 */
export type WalletRpcResponse = EthereumPersonalSignRpcResponse | EthereumSignTypedDataRpcResponse | EthereumSignTransactionRpcResponse | EthereumSendTransactionRpcResponse | EthereumSignUserOperationRpcResponse | EthereumSign7702AuthorizationRpcResponse | EthereumSecp256k1SignRpcResponse | EthereumSendCallsRpcResponse | AptosSignTransactionRpcResponse | SolanaSignMessageRpcResponse | SolanaSignTransactionRpcResponse | SolanaSignAndSendTransactionRpcResponse | SparkTransferRpcResponse | SparkGetBalanceRpcResponse | SparkTransferTokensRpcResponse | SparkGetStaticDepositAddressRpcResponse | SparkGetClaimStaticDepositQuoteRpcResponse | SparkClaimStaticDepositRpcResponse | SparkCreateLightningInvoiceRpcResponse | SparkPayLightningInvoiceRpcResponse | SparkSignMessageWithIdentityKeyRpcResponse | SparkWithdrawRpcResponse | SparkGetWithdrawalFeeQuoteRpcResponse | TronSignTransactionRpcResponse | TronSendTransactionRpcResponse | XrplSignTransactionRpcResponse | NearSignTransactionRpcResponse | ExportPrivateKeyRpcResponse | ExportSeedPhraseRpcResponse;
/**
 * A named asset on Solana.
 */
export type WalletSolanaAsset = 'sol' | 'usdc' | 'eurc' | 'usdb' | 'ousd';
/**
 * A named asset on Tron.
 */
export type WalletTronAsset = 'trx' | 'usdt' | 'usdc';
/**
 * Request body for updating a wallet. `owner` and `owner_id` are mutually
 * exclusive.
 */
export interface WalletUpdateRequestBody {
    /**
     * Additional signers for the wallet.
     */
    additional_signers?: AdditionalSignerInput;
    /**
     * A human-readable label for the wallet. Set to null to clear.
     */
    display_name?: string | null;
    /**
     * A customer-provided identifier for mapping to external systems. URL-safe
     * characters only ([a-zA-Z0-9_-]), max 64 chars. Write-once: cannot be changed
     * once set.
     */
    external_id?: string;
    /**
     * The owner of the resource, specified as a Privy user ID, a P-256 public key, or
     * null to remove the current owner.
     */
    owner?: SharedAPI.OwnerInput | null;
    /**
     * The key quorum ID to set as the owner of the resource. If you provide this, do
     * not specify an owner.
     */
    owner_id?: SharedAPI.OwnerIDInput | null;
    /**
     * New policy IDs to enforce on the wallet. Currently, only one policy is supported
     * per wallet.
     */
    policy_ids?: Array<string>;
}
/**
 * Executes the XRPL `xrpl_signTransaction` RPC to sign a transaction. The caller
 * is responsible for broadcasting.
 */
export interface XrplRpcInput {
    method: 'xrpl_signTransaction';
    /**
     * Parameters for the XRPL `xrpl_signTransaction` RPC.
     */
    params: XrplSignTransactionRpcInputParams;
}
/**
 * Response to the XRPL `xrpl_signTransaction` RPC.
 */
export interface XrplRpcResponse {
    /**
     * Data returned by the XRPL `xrpl_signTransaction` RPC.
     */
    data: XrplSignTransactionRpcResponseData;
    method: 'xrpl_signTransaction';
}
/**
 * Executes the XRPL `xrpl_signTransaction` RPC to sign a transaction. The caller
 * is responsible for broadcasting.
 */
export interface XrplSignTransactionRpcInput {
    method: 'xrpl_signTransaction';
    /**
     * Parameters for the XRPL `xrpl_signTransaction` RPC.
     */
    params: XrplSignTransactionRpcInputParams;
}
/**
 * Parameters for the XRPL `xrpl_signTransaction` RPC.
 */
export interface XrplSignTransactionRpcInputParams {
    encoding: 'hex';
    transaction: string;
}
/**
 * Response to the XRPL `xrpl_signTransaction` RPC.
 */
export interface XrplSignTransactionRpcResponse {
    /**
     * Data returned by the XRPL `xrpl_signTransaction` RPC.
     */
    data: XrplSignTransactionRpcResponseData;
    method: 'xrpl_signTransaction';
}
/**
 * Data returned by the XRPL `xrpl_signTransaction` RPC.
 */
export interface XrplSignTransactionRpcResponseData {
    encoding: 'hex';
    signed_transaction: string;
    txn_signature: string;
}
export interface WalletCreateParams {
    /**
     * Body param: The wallet chain types.
     */
    chain_type: WalletChainType;
    /**
     * Body param: Additional signers for the wallet.
     */
    additional_signers?: AdditionalSignerInput;
    /**
     * Body param: A human-readable label for the wallet.
     */
    display_name?: string;
    /**
     * Body param: Request body for assigning an entity to a wallet.
     */
    entity?: WalletEntityAssignmentRequestBody;
    /**
     * Body param: A customer-provided identifier for mapping to external systems.
     * URL-safe characters only ([a-zA-Z0-9_-]), max 64 chars. Write-once: cannot be
     * changed after creation.
     */
    external_id?: string;
    /**
     * Body param: The owner of the resource, specified as a Privy user ID, a P-256
     * public key, or null to remove the current owner.
     */
    owner?: SharedAPI.OwnerInput | null;
    /**
     * Body param: The key quorum ID to set as the owner of the resource. If you
     * provide this, do not specify an owner.
     */
    owner_id?: SharedAPI.OwnerIDInput | null;
    /**
     * Body param: An optional list of up to one policy ID to enforce on the wallet.
     */
    policy_ids?: PolicyInput;
    /**
     * Header param: Idempotency keys ensure API requests are executed only once within
     * a 24-hour window.
     */
    'privy-idempotency-key'?: string;
}
export interface WalletUpdateParams {
    /**
     * Body param: Additional signers for the wallet.
     */
    additional_signers?: AdditionalSignerInput;
    /**
     * Body param: A human-readable label for the wallet. Set to null to clear.
     */
    display_name?: string | null;
    /**
     * Body param: A customer-provided identifier for mapping to external systems.
     * URL-safe characters only ([a-zA-Z0-9_-]), max 64 chars. Write-once: cannot be
     * changed once set.
     */
    external_id?: string;
    /**
     * Body param: The owner of the resource, specified as a Privy user ID, a P-256
     * public key, or null to remove the current owner.
     */
    owner?: SharedAPI.OwnerInput | null;
    /**
     * Body param: The key quorum ID to set as the owner of the resource. If you
     * provide this, do not specify an owner.
     */
    owner_id?: SharedAPI.OwnerIDInput | null;
    /**
     * Body param: New policy IDs to enforce on the wallet. Currently, only one policy
     * is supported per wallet.
     */
    policy_ids?: Array<string>;
    /**
     * Header param: Request authorization signature. If multiple signatures are
     * required, they should be comma separated.
     */
    'privy-authorization-signature'?: string;
    /**
     * Header param: Request expiry. Value is a Unix timestamp in milliseconds
     * representing the deadline by which the request must be processed.
     */
    'privy-request-expiry'?: string;
}
export interface WalletListParams extends CursorParams {
    /**
     * A blockchain wallet address. Ethereum addresses are normalized to EIP-55
     * checksum format. Solana addresses are validated as base58. All other chain
     * addresses (Stellar, Tron, Sui, Aptos, etc.) are accepted as-is.
     */
    address?: Address;
    /**
     * Filter wallets by authorization public key. Returns wallets owned by key quorums
     * that include the specified P-256 public key (base64-encoded DER format). Cannot
     * be used together with user_id.
     */
    authorization_key?: string;
    /**
     * The wallet chain types.
     */
    chain_type?: WalletChainType;
    /**
     * Filter wallets by the entity ID the wallet is attributed to.
     */
    entity_id?: string;
    /**
     * Filter wallets by external ID.
     */
    external_id?: string;
    /**
     * Include archived wallets in lookup. Defaults to false.
     */
    include_archived?: boolean;
    /**
     * Filter wallets by user ID. Cannot be used together with authorization_key.
     */
    user_id?: string;
}
export interface WalletExportParams {
    /**
     * Body param: The encryption type of the wallet to import. Currently only supports
     * `HPKE`.
     */
    encryption_type: HpkeEncryption;
    /**
     * Body param: The base64-encoded encryption public key to encrypt the wallet
     * private key with.
     */
    recipient_public_key: string;
    /**
     * Body param
     */
    export_seed_phrase?: boolean;
    /**
     * Header param: Request authorization signature. If multiple signatures are
     * required, they should be comma separated.
     */
    'privy-authorization-signature'?: string;
    /**
     * Header param: Request expiry. Value is a Unix timestamp in milliseconds
     * representing the deadline by which the request must be processed.
     */
    'privy-request-expiry'?: string;
}
export interface WalletGetParams {
    /**
     * Include archived wallets in lookup. Defaults to false.
     */
    include_archived?: boolean;
}
export interface WalletRawSignParams {
    /**
     * Body param: Parameters for the `raw_sign` RPC.
     */
    params: RawSignInputParams;
    /**
     * Header param: Request authorization signature. If multiple signatures are
     * required, they should be comma separated.
     */
    'privy-authorization-signature'?: string;
    /**
     * Header param: Idempotency keys ensure API requests are executed only once within
     * a 24-hour window.
     */
    'privy-idempotency-key'?: string;
    /**
     * Header param: Request expiry. Value is a Unix timestamp in milliseconds
     * representing the deadline by which the request must be processed.
     */
    'privy-request-expiry'?: string;
}
export type WalletRpcParams = WalletRpcParams.EthereumSignTransactionRpcInput | WalletRpcParams.EthereumSendTransactionRpcInput | WalletRpcParams.EthereumPersonalSignRpcInput | WalletRpcParams.EthereumSignTypedDataRpcInput | WalletRpcParams.EthereumSecp256k1SignRpcInput | WalletRpcParams.EthereumSign7702AuthorizationRpcInput | WalletRpcParams.EthereumSignUserOperationRpcInput | WalletRpcParams.EthereumSendCallsRpcInput | WalletRpcParams.AptosSignTransactionRpcInput | WalletRpcParams.SolanaSignTransactionRpcInput | WalletRpcParams.SolanaSignAndSendTransactionRpcInput | WalletRpcParams.SolanaSignMessageRpcInput | WalletRpcParams.SparkTransferRpcInput | WalletRpcParams.SparkGetBalanceRpcInput | WalletRpcParams.SparkTransferTokensRpcInput | WalletRpcParams.SparkGetStaticDepositAddressRpcInput | WalletRpcParams.SparkGetClaimStaticDepositQuoteRpcInput | WalletRpcParams.SparkClaimStaticDepositRpcInput | WalletRpcParams.SparkCreateLightningInvoiceRpcInput | WalletRpcParams.SparkPayLightningInvoiceRpcInput | WalletRpcParams.SparkSignMessageWithIdentityKeyRpcInput | WalletRpcParams.SparkWithdrawRpcInput | WalletRpcParams.SparkGetWithdrawalFeeQuoteRpcInput | WalletRpcParams.TronSignTransactionRpcInput | WalletRpcParams.TronSendTransactionRpcInput | WalletRpcParams.XrplSignTransactionRpcInput | WalletRpcParams.NearSignTransactionRpcRequestBody | WalletRpcParams.ExportPrivateKeyRpcInput | WalletRpcParams.ExportSeedPhraseRpcInput;
export declare namespace WalletRpcParams {
    interface EthereumSignTransactionRpcInput {
        /**
         * Body param
         */
        method: 'eth_signTransaction';
        /**
         * Body param: Parameters for the EVM `eth_signTransaction` RPC.
         */
        params: EthereumSignTransactionRpcInputParams;
        /**
         * Body param
         */
        address?: string;
        /**
         * Body param
         */
        chain_type?: 'ethereum';
        /**
         * Body param
         */
        wallet_id?: string;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface EthereumSendTransactionRpcInput {
        /**
         * Body param: A valid CAIP-2 chain ID (e.g. 'eip155:4217' for Tempo, 'eip155:1'
         * for Ethereum).
         */
        caip2: AppsAPI.Caip2;
        /**
         * Body param
         */
        method: 'eth_sendTransaction';
        /**
         * Body param: Parameters for the EVM `eth_sendTransaction` RPC.
         */
        params: EthereumSendTransactionRpcInputParams;
        /**
         * Body param
         */
        address?: string;
        /**
         * Body param
         */
        chain_type?: 'ethereum';
        /**
         * Body param: A hex-encoded string prefixed with '0x', capped at 300002 characters
         * (150,000 bytes).
         */
        experimental_data_suffix?: Hex;
        /**
         * Body param: Developer-provided identifier for this request. Must be unique per
         * app.
         */
        reference_id?: string;
        /**
         * Body param
         */
        sponsor?: boolean;
        /**
         * Body param: Options for user-pays gas sponsorship on the RPC endpoint. When
         * provided alongside `sponsor: true`, controls which token asset the user pays gas
         * with.
         */
        sponsor_options?: RpcSponsorOptions;
        /**
         * Body param
         */
        wallet_id?: string;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface EthereumPersonalSignRpcInput {
        /**
         * Body param
         */
        method: 'personal_sign';
        /**
         * Body param: Parameters for the EVM `personal_sign` RPC.
         */
        params: EthereumPersonalSignRpcInputParams;
        /**
         * Body param
         */
        address?: string;
        /**
         * Body param: A valid CAIP-2 chain ID (e.g. 'eip155:4217' for Tempo, 'eip155:1'
         * for Ethereum).
         */
        caip2?: AppsAPI.Caip2;
        /**
         * Body param
         */
        chain_type?: 'ethereum';
        /**
         * Body param: Options controlling signature production for personal_sign and
         * eth_signTypedData_v4.
         */
        signature_options?: SignatureOptions;
        /**
         * Body param
         */
        wallet_id?: string;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface EthereumSignTypedDataRpcInput {
        /**
         * Body param
         */
        method: 'eth_signTypedData_v4';
        /**
         * Body param: Parameters for the EVM `eth_signTypedData_v4` RPC.
         */
        params: EthereumSignTypedDataRpcInputParams;
        /**
         * Body param
         */
        address?: string;
        /**
         * Body param: A valid CAIP-2 chain ID (e.g. 'eip155:4217' for Tempo, 'eip155:1'
         * for Ethereum).
         */
        caip2?: AppsAPI.Caip2;
        /**
         * Body param
         */
        chain_type?: 'ethereum';
        /**
         * Body param: Options controlling signature production for personal_sign and
         * eth_signTypedData_v4.
         */
        signature_options?: SignatureOptions;
        /**
         * Body param
         */
        wallet_id?: string;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface EthereumSecp256k1SignRpcInput {
        /**
         * Body param
         */
        method: 'secp256k1_sign';
        /**
         * Body param: Parameters for the EVM `secp256k1_sign` RPC.
         */
        params: EthereumSecp256k1SignRpcInputParams;
        /**
         * Body param
         */
        address?: string;
        /**
         * Body param
         */
        chain_type?: 'ethereum';
        /**
         * Body param
         */
        wallet_id?: string;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface EthereumSign7702AuthorizationRpcInput {
        /**
         * Body param
         */
        method: 'eth_sign7702Authorization';
        /**
         * Body param: Parameters for the EVM `eth_sign7702Authorization` RPC.
         */
        params: EthereumSign7702AuthorizationRpcInputParams;
        /**
         * Body param
         */
        address?: string;
        /**
         * Body param
         */
        chain_type?: 'ethereum';
        /**
         * Body param
         */
        wallet_id?: string;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface EthereumSignUserOperationRpcInput {
        /**
         * Body param
         */
        method: 'eth_signUserOperation';
        /**
         * Body param: Parameters for the EVM `eth_signUserOperation` RPC.
         */
        params: EthereumSignUserOperationRpcInputParams;
        /**
         * Body param
         */
        address?: string;
        /**
         * Body param
         */
        chain_type?: 'ethereum';
        /**
         * Body param
         */
        wallet_id?: string;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface EthereumSendCallsRpcInput {
        /**
         * Body param: A valid CAIP-2 chain ID (e.g. 'eip155:4217' for Tempo, 'eip155:1'
         * for Ethereum).
         */
        caip2: AppsAPI.Caip2;
        /**
         * Body param
         */
        method: 'wallet_sendCalls';
        /**
         * Body param: Parameters for the `wallet_sendCalls` RPC.
         */
        params: EthereumSendCallsRpcInputParams;
        /**
         * Body param
         */
        address?: string;
        /**
         * Body param
         */
        chain_type?: 'ethereum';
        /**
         * Body param: A hex-encoded string prefixed with '0x', capped at 300002 characters
         * (150,000 bytes).
         */
        experimental_data_suffix?: Hex;
        /**
         * Body param
         */
        sponsor?: boolean;
        /**
         * Body param: Options for user-pays gas sponsorship on the RPC endpoint. When
         * provided alongside `sponsor: true`, controls which token asset the user pays gas
         * with.
         */
        sponsor_options?: RpcSponsorOptions;
        /**
         * Body param
         */
        wallet_id?: string;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface AptosSignTransactionRpcInput {
        /**
         * Body param
         */
        method: 'aptos_signTransaction';
        /**
         * Body param: Parameters for the Aptos `aptos_signTransaction` RPC.
         */
        params: AptosSignTransactionRpcInputParams;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface SolanaSignTransactionRpcInput {
        /**
         * Body param
         */
        method: 'signTransaction';
        /**
         * Body param: Parameters for the SVM `signTransaction` RPC.
         */
        params: SolanaSignTransactionRpcInputParams;
        /**
         * Body param
         */
        address?: string;
        /**
         * Body param
         */
        chain_type?: 'solana';
        /**
         * Body param
         */
        wallet_id?: string;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface SolanaSignAndSendTransactionRpcInput {
        /**
         * Body param: A valid CAIP-2 chain ID (e.g. 'eip155:4217' for Tempo, 'eip155:1'
         * for Ethereum).
         */
        caip2: AppsAPI.Caip2;
        /**
         * Body param
         */
        method: 'signAndSendTransaction';
        /**
         * Body param: Parameters for the SVM `signAndSendTransaction` RPC.
         */
        params: SolanaSignAndSendTransactionRpcInputParams;
        /**
         * Body param
         */
        address?: string;
        /**
         * Body param
         */
        chain_type?: 'solana';
        /**
         * Body param
         */
        optimistic_broadcast?: boolean;
        /**
         * Body param: Developer-provided identifier for this request. Must be unique per
         * app.
         */
        reference_id?: string;
        /**
         * Body param
         */
        sponsor?: boolean;
        /**
         * Body param: Options for user-pays gas sponsorship on the RPC endpoint. When
         * provided alongside `sponsor: true`, controls which token asset the user pays gas
         * with.
         */
        sponsor_options?: RpcSponsorOptions;
        /**
         * Body param
         */
        wallet_id?: string;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface SolanaSignMessageRpcInput {
        /**
         * Body param
         */
        method: 'signMessage';
        /**
         * Body param: Parameters for the SVM `signMessage` RPC.
         */
        params: SolanaSignMessageRpcInputParams;
        /**
         * Body param
         */
        address?: string;
        /**
         * Body param
         */
        chain_type?: 'solana';
        /**
         * Body param
         */
        wallet_id?: string;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface SparkTransferRpcInput {
        /**
         * Body param
         */
        method: 'transfer';
        /**
         * Body param: Parameters for the Spark `transfer` RPC.
         */
        params: SparkTransferRpcInputParams;
        /**
         * Body param: The Spark network.
         */
        network?: SparkNetwork;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface SparkGetBalanceRpcInput {
        /**
         * Body param
         */
        method: 'getBalance';
        /**
         * Body param: The Spark network.
         */
        network?: SparkNetwork;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface SparkTransferTokensRpcInput {
        /**
         * Body param
         */
        method: 'transferTokens';
        /**
         * Body param: Parameters for the Spark `transferTokens` RPC.
         */
        params: SparkTransferTokensRpcInputParams;
        /**
         * Body param: The Spark network.
         */
        network?: SparkNetwork;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface SparkGetStaticDepositAddressRpcInput {
        /**
         * Body param
         */
        method: 'getStaticDepositAddress';
        /**
         * Body param: The Spark network.
         */
        network?: SparkNetwork;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface SparkGetClaimStaticDepositQuoteRpcInput {
        /**
         * Body param
         */
        method: 'getClaimStaticDepositQuote';
        /**
         * Body param: Parameters for the Spark `getClaimStaticDepositQuote` RPC.
         */
        params: SparkGetClaimStaticDepositQuoteRpcInputParams;
        /**
         * Body param: The Spark network.
         */
        network?: SparkNetwork;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface SparkClaimStaticDepositRpcInput {
        /**
         * Body param
         */
        method: 'claimStaticDeposit';
        /**
         * Body param: Parameters for the Spark `claimStaticDeposit` RPC.
         */
        params: SparkClaimStaticDepositRpcInputParams;
        /**
         * Body param: The Spark network.
         */
        network?: SparkNetwork;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface SparkCreateLightningInvoiceRpcInput {
        /**
         * Body param
         */
        method: 'createLightningInvoice';
        /**
         * Body param: Parameters for the Spark `createLightningInvoice` RPC.
         */
        params: SparkCreateLightningInvoiceRpcInputParams;
        /**
         * Body param: The Spark network.
         */
        network?: SparkNetwork;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface SparkPayLightningInvoiceRpcInput {
        /**
         * Body param
         */
        method: 'payLightningInvoice';
        /**
         * Body param: Parameters for the Spark `payLightningInvoice` RPC.
         */
        params: SparkPayLightningInvoiceRpcInputParams;
        /**
         * Body param: The Spark network.
         */
        network?: SparkNetwork;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface SparkSignMessageWithIdentityKeyRpcInput {
        /**
         * Body param
         */
        method: 'signMessageWithIdentityKey';
        /**
         * Body param: Parameters for the Spark `signMessageWithIdentityKey` RPC.
         */
        params: SparkSignMessageWithIdentityKeyRpcInputParams;
        /**
         * Body param: The Spark network.
         */
        network?: SparkNetwork;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface SparkWithdrawRpcInput {
        /**
         * Body param
         */
        method: 'withdraw';
        /**
         * Body param: Parameters for the Spark `withdraw` RPC.
         */
        params: SparkWithdrawRpcInputParams;
        /**
         * Body param: The Spark network.
         */
        network?: SparkNetwork;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface SparkGetWithdrawalFeeQuoteRpcInput {
        /**
         * Body param
         */
        method: 'getWithdrawalFeeQuote';
        /**
         * Body param: Parameters for the Spark `getWithdrawalFeeQuote` RPC.
         */
        params: SparkGetWithdrawalFeeQuoteRpcInputParams;
        /**
         * Body param: The Spark network.
         */
        network?: SparkNetwork;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface TronSignTransactionRpcInput {
        /**
         * Body param
         */
        method: 'tron_signTransaction';
        /**
         * Body param: Parameters for the Tron `tron_signTransaction` RPC.
         */
        params: TronSignTransactionRpcInputParams;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface TronSendTransactionRpcInput {
        /**
         * Body param
         */
        method: 'tron_sendTransaction';
        /**
         * Body param: Parameters for the Tron `tron_sendTransaction` RPC.
         */
        params: TronSendTransactionRpcInputParams;
        /**
         * Body param: A valid CAIP-2 chain ID (e.g. 'eip155:4217' for Tempo, 'eip155:1'
         * for Ethereum).
         */
        caip2?: AppsAPI.Caip2;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface XrplSignTransactionRpcInput {
        /**
         * Body param
         */
        method: 'xrpl_signTransaction';
        /**
         * Body param: Parameters for the XRPL `xrpl_signTransaction` RPC.
         */
        params: XrplSignTransactionRpcInputParams;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface NearSignTransactionRpcRequestBody {
        /**
         * Body param
         */
        method: 'near_signTransaction';
        /**
         * Body param: Parameters for the NEAR `near_signTransaction` RPC.
         */
        params: NearSignTransactionRpcRequestBodyParams;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface ExportPrivateKeyRpcInput {
        /**
         * Body param
         */
        address: string;
        /**
         * Body param
         */
        method: 'exportPrivateKey';
        /**
         * Body param: Input for exporting a wallet (private key or seed phrase) with HPKE
         * encryption.
         */
        params: PrivateKeyExportInput;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
    interface ExportSeedPhraseRpcInput {
        /**
         * Body param
         */
        address: string;
        /**
         * Body param
         */
        method: 'exportSeedPhrase';
        /**
         * Body param: Input for exporting a wallet (private key or seed phrase) with HPKE
         * encryption.
         */
        params: SeedPhraseExportInput;
        /**
         * Header param: Request authorization signature. If multiple signatures are
         * required, they should be comma separated.
         */
        'privy-authorization-signature'?: string;
        /**
         * Header param: Idempotency keys ensure API requests are executed only once within
         * a 24-hour window.
         */
        'privy-idempotency-key'?: string;
        /**
         * Header param: Request expiry. Value is a Unix timestamp in milliseconds
         * representing the deadline by which the request must be processed.
         */
        'privy-request-expiry'?: string;
    }
}
export declare namespace Wallets {
    export { type AccessListEntry as AccessListEntry, type AdditionalSignerInput as AdditionalSignerInput, type AdditionalSignerItemInput as AdditionalSignerItemInput, type Address as Address, type AdvancedSwapPlatformFee as AdvancedSwapPlatformFee, type AdvancedSwapRequestBody as AdvancedSwapRequestBody, type AdvancedSwapResponse as AdvancedSwapResponse, type AmountType as AmountType, type AptosBcsHex as AptosBcsHex, type AptosRpcInput as AptosRpcInput, type AptosRpcResponse as AptosRpcResponse, type AptosSignTransactionRpcInput as AptosSignTransactionRpcInput, type AptosSignTransactionRpcInputParams as AptosSignTransactionRpcInputParams, type AptosSignTransactionRpcResponse as AptosSignTransactionRpcResponse, type AptosSignTransactionRpcResponseData as AptosSignTransactionRpcResponseData, type AptosSignedTransactionBcsHex as AptosSignedTransactionBcsHex, type AttachWalletAutomationRequestBody as AttachWalletAutomationRequestBody, type AuthorizationKeyDashboardResponse as AuthorizationKeyDashboardResponse, type AuthorizationKeyResponse as AuthorizationKeyResponse, type AuthorizationKeyRole as AuthorizationKeyRole, type CreateCryptoDepositAccountRequestBody as CreateCryptoDepositAccountRequestBody, type CreateCryptoDepositAccountResponse as CreateCryptoDepositAccountResponse, type CreateCryptoDepositAccountWithConfigRequestBody as CreateCryptoDepositAccountWithConfigRequestBody, type CreateCryptoDepositAccountWithRouteRequestBody as CreateCryptoDepositAccountWithRouteRequestBody, type CryptoDepositAddressRoute as CryptoDepositAddressRoute, type CryptoDepositAsset as CryptoDepositAsset, type CryptoDepositAssetFilter as CryptoDepositAssetFilter, type CryptoDepositAssetFilterAll as CryptoDepositAssetFilterAll, type CryptoDepositAssetFilterExclude as CryptoDepositAssetFilterExclude, type CryptoDepositAssetFilterInclude as CryptoDepositAssetFilterInclude, type CurveSigningChainType as CurveSigningChainType, type CurveType as CurveType, type CustodialWallet as CustodialWallet, type CustodialWalletChainType as CustodialWalletChainType, type CustodialWalletCreateInput as CustodialWalletCreateInput, type CustodialWalletProvider as CustodialWalletProvider, type CustomTokenTransferSource as CustomTokenTransferSource, type DetachWalletAutomationRequestBody as DetachWalletAutomationRequestBody, type DeveloperFee as DeveloperFee, type EncryptedAuthorizationKey as EncryptedAuthorizationKey, type EncryptedBoundAuthenticateResponse as EncryptedBoundAuthenticateResponse, type EncryptedWalletAuthenticateResponse as EncryptedWalletAuthenticateResponse, type EntityID as EntityID, type EthereumPersonalSignRpcInput as EthereumPersonalSignRpcInput, type EthereumPersonalSignRpcInputParams as EthereumPersonalSignRpcInputParams, type EthereumPersonalSignRpcResponse as EthereumPersonalSignRpcResponse, type EthereumPersonalSignRpcResponseData as EthereumPersonalSignRpcResponseData, type EthereumRpcInput as EthereumRpcInput, type EthereumRpcResponse as EthereumRpcResponse, type EthereumSecp256k1SignRpcInput as EthereumSecp256k1SignRpcInput, type EthereumSecp256k1SignRpcInputParams as EthereumSecp256k1SignRpcInputParams, type EthereumSecp256k1SignRpcResponse as EthereumSecp256k1SignRpcResponse, type EthereumSecp256k1SignRpcResponseData as EthereumSecp256k1SignRpcResponseData, type EthereumSendCallsCall as EthereumSendCallsCall, type EthereumSendCallsRpcInput as EthereumSendCallsRpcInput, type EthereumSendCallsRpcInputParams as EthereumSendCallsRpcInputParams, type EthereumSendCallsRpcResponse as EthereumSendCallsRpcResponse, type EthereumSendCallsRpcResponseData as EthereumSendCallsRpcResponseData, type EthereumSendTransactionRpcInput as EthereumSendTransactionRpcInput, type EthereumSendTransactionRpcInputParams as EthereumSendTransactionRpcInputParams, type EthereumSendTransactionRpcResponse as EthereumSendTransactionRpcResponse, type EthereumSendTransactionRpcResponseData as EthereumSendTransactionRpcResponseData, type EthereumSign7702Authorization as EthereumSign7702Authorization, type EthereumSign7702AuthorizationRpcInput as EthereumSign7702AuthorizationRpcInput, type EthereumSign7702AuthorizationRpcInputParams as EthereumSign7702AuthorizationRpcInputParams, type EthereumSign7702AuthorizationRpcResponse as EthereumSign7702AuthorizationRpcResponse, type EthereumSign7702AuthorizationRpcResponseData as EthereumSign7702AuthorizationRpcResponseData, type EthereumSignTransactionRpcInput as EthereumSignTransactionRpcInput, type EthereumSignTransactionRpcInputParams as EthereumSignTransactionRpcInputParams, type EthereumSignTransactionRpcResponse as EthereumSignTransactionRpcResponse, type EthereumSignTransactionRpcResponseData as EthereumSignTransactionRpcResponseData, type EthereumSignTypedDataRpcInput as EthereumSignTypedDataRpcInput, type EthereumSignTypedDataRpcInputParams as EthereumSignTypedDataRpcInputParams, type EthereumSignTypedDataRpcResponse as EthereumSignTypedDataRpcResponse, type EthereumSignTypedDataRpcResponseData as EthereumSignTypedDataRpcResponseData, type EthereumSignUserOperationRpcInput as EthereumSignUserOperationRpcInput, type EthereumSignUserOperationRpcInputParams as EthereumSignUserOperationRpcInputParams, type EthereumSignUserOperationRpcResponse as EthereumSignUserOperationRpcResponse, type EthereumSignUserOperationRpcResponseData as EthereumSignUserOperationRpcResponseData, type EthereumTypedDataInput as EthereumTypedDataInput, type ExportPrivateKeyRpcInput as ExportPrivateKeyRpcInput, type ExportPrivateKeyRpcResponse as ExportPrivateKeyRpcResponse, type ExportSeedPhraseRpcInput as ExportSeedPhraseRpcInput, type ExportSeedPhraseRpcResponse as ExportSeedPhraseRpcResponse, type ExportType as ExportType, type ExtendedChainType as ExtendedChainType, type FeeConfiguration as FeeConfiguration, type FeeLineItem as FeeLineItem, type FirstClassChainType as FirstClassChainType, type Gas as Gas, type GetByWalletAddressRequestBody as GetByWalletAddressRequestBody, type HDInitInput as HDInitInput, type HDPath as HDPath, type HDSubmitInput as HDSubmitInput, type HpkeAeadAlgorithm as HpkeAeadAlgorithm, type HpkeEncryption as HpkeEncryption, type HpkeImportConfig as HpkeImportConfig, type Hex as Hex, type IntentBinding as IntentBinding, type NamedTokenTransferSource as NamedTokenTransferSource, type NearRpcRequestBody as NearRpcRequestBody, type NearRpcResponse as NearRpcResponse, type NearSignTransactionRpcRequestBody as NearSignTransactionRpcRequestBody, type NearSignTransactionRpcRequestBodyParams as NearSignTransactionRpcRequestBodyParams, type NearSignTransactionRpcResponse as NearSignTransactionRpcResponse, type NearSignTransactionRpcResponseData as NearSignTransactionRpcResponseData, type NearSignedTransactionBorshBase64 as NearSignedTransactionBorshBase64, type NearUnsignedTransactionBorshBase64 as NearUnsignedTransactionBorshBase64, type OutputWithPreviousTransactionData as OutputWithPreviousTransactionData, type PolicyInput as PolicyInput, type PrivateKeyExportInput as PrivateKeyExportInput, type PrivateKeyExportResponse as PrivateKeyExportResponse, type PrivateKeyInitInput as PrivateKeyInitInput, type PrivateKeySubmitInput as PrivateKeySubmitInput, type PrivyFee as PrivyFee, type Quantity as Quantity, type RawBoundAuthenticateResponse as RawBoundAuthenticateResponse, type RawSignBytesEncoding as RawSignBytesEncoding, type RawSignBytesHashFunction as RawSignBytesHashFunction, type RawSignBytesParams as RawSignBytesParams, type RawSignHashParams as RawSignHashParams, type RawSignInput as RawSignInput, type RawSignInputParams as RawSignInputParams, type RawSignResponse as RawSignResponse, type RawSignResponseData as RawSignResponseData, type RawWalletAuthenticateResponse as RawWalletAuthenticateResponse, type RecipientPublicKey as RecipientPublicKey, type RelayerFee as RelayerFee, type RpcSponsorAsset as RpcSponsorAsset, type RpcSponsorOptions as RpcSponsorOptions, type SeedPhraseExportInput as SeedPhraseExportInput, type SeedPhraseExportResponse as SeedPhraseExportResponse, type SignatureOptions as SignatureOptions, type SignatureType as SignatureType, type SigningAlgorithm as SigningAlgorithm, type SolanaRpcInput as SolanaRpcInput, type SolanaRpcResponse as SolanaRpcResponse, type SolanaSignAndSendTransactionRpcInput as SolanaSignAndSendTransactionRpcInput, type SolanaSignAndSendTransactionRpcInputParams as SolanaSignAndSendTransactionRpcInputParams, type SolanaSignAndSendTransactionRpcResponse as SolanaSignAndSendTransactionRpcResponse, type SolanaSignAndSendTransactionRpcResponseData as SolanaSignAndSendTransactionRpcResponseData, type SolanaSignMessageRpcInput as SolanaSignMessageRpcInput, type SolanaSignMessageRpcInputParams as SolanaSignMessageRpcInputParams, type SolanaSignMessageRpcResponse as SolanaSignMessageRpcResponse, type SolanaSignMessageRpcResponseData as SolanaSignMessageRpcResponseData, type SolanaSignTransactionRpcInput as SolanaSignTransactionRpcInput, type SolanaSignTransactionRpcInputParams as SolanaSignTransactionRpcInputParams, type SolanaSignTransactionRpcResponse as SolanaSignTransactionRpcResponse, type SolanaSignTransactionRpcResponseData as SolanaSignTransactionRpcResponseData, type SolanaWalletDerivationStrategy as SolanaWalletDerivationStrategy, type SparkBalance as SparkBalance, type SparkClaimStaticDepositRpcInput as SparkClaimStaticDepositRpcInput, type SparkClaimStaticDepositRpcInputParams as SparkClaimStaticDepositRpcInputParams, type SparkClaimStaticDepositRpcResponse as SparkClaimStaticDepositRpcResponse, type SparkClaimStaticDepositRpcResponseData as SparkClaimStaticDepositRpcResponseData, type SparkCoopExitFeeQuote as SparkCoopExitFeeQuote, type SparkCoopExitRequest as SparkCoopExitRequest, type SparkCreateLightningInvoiceRpcInput as SparkCreateLightningInvoiceRpcInput, type SparkCreateLightningInvoiceRpcInputParams as SparkCreateLightningInvoiceRpcInputParams, type SparkCreateLightningInvoiceRpcResponse as SparkCreateLightningInvoiceRpcResponse, type SparkCurrencyAmount as SparkCurrencyAmount, type SparkExitSpeed as SparkExitSpeed, type SparkGetBalanceRpcInput as SparkGetBalanceRpcInput, type SparkGetBalanceRpcResponse as SparkGetBalanceRpcResponse, type SparkGetClaimStaticDepositQuoteRpcInput as SparkGetClaimStaticDepositQuoteRpcInput, type SparkGetClaimStaticDepositQuoteRpcInputParams as SparkGetClaimStaticDepositQuoteRpcInputParams, type SparkGetClaimStaticDepositQuoteRpcResponse as SparkGetClaimStaticDepositQuoteRpcResponse, type SparkGetClaimStaticDepositQuoteRpcResponseData as SparkGetClaimStaticDepositQuoteRpcResponseData, type SparkGetStaticDepositAddressRpcInput as SparkGetStaticDepositAddressRpcInput, type SparkGetStaticDepositAddressRpcResponse as SparkGetStaticDepositAddressRpcResponse, type SparkGetStaticDepositAddressRpcResponseData as SparkGetStaticDepositAddressRpcResponseData, type SparkGetWithdrawalFeeQuoteRpcInput as SparkGetWithdrawalFeeQuoteRpcInput, type SparkGetWithdrawalFeeQuoteRpcInputParams as SparkGetWithdrawalFeeQuoteRpcInputParams, type SparkGetWithdrawalFeeQuoteRpcResponse as SparkGetWithdrawalFeeQuoteRpcResponse, type SparkLightningFee as SparkLightningFee, type SparkLightningReceiveRequest as SparkLightningReceiveRequest, type SparkLightningSendRequest as SparkLightningSendRequest, type SparkNetwork as SparkNetwork, type SparkOutputSelectionStrategy as SparkOutputSelectionStrategy, type SparkPayLightningInvoiceRpcInput as SparkPayLightningInvoiceRpcInput, type SparkPayLightningInvoiceRpcInputParams as SparkPayLightningInvoiceRpcInputParams, type SparkPayLightningInvoiceRpcResponse as SparkPayLightningInvoiceRpcResponse, type SparkRpcInput as SparkRpcInput, type SparkRpcResponse as SparkRpcResponse, type SparkSignMessageWithIdentityKeyRpcInput as SparkSignMessageWithIdentityKeyRpcInput, type SparkSignMessageWithIdentityKeyRpcInputParams as SparkSignMessageWithIdentityKeyRpcInputParams, type SparkSignMessageWithIdentityKeyRpcResponse as SparkSignMessageWithIdentityKeyRpcResponse, type SparkSignMessageWithIdentityKeyRpcResponseData as SparkSignMessageWithIdentityKeyRpcResponseData, type SparkSigningKeyshare as SparkSigningKeyshare, type SparkTokenBalance as SparkTokenBalance, type SparkTransfer as SparkTransfer, type SparkTransferLeaf as SparkTransferLeaf, type SparkTransferRpcInput as SparkTransferRpcInput, type SparkTransferRpcInputParams as SparkTransferRpcInputParams, type SparkTransferRpcResponse as SparkTransferRpcResponse, type SparkTransferTokensRpcInput as SparkTransferTokensRpcInput, type SparkTransferTokensRpcInputParams as SparkTransferTokensRpcInputParams, type SparkTransferTokensRpcResponse as SparkTransferTokensRpcResponse, type SparkTransferTokensRpcResponseData as SparkTransferTokensRpcResponseData, type SparkUserTokenMetadata as SparkUserTokenMetadata, type SparkWalletLeaf as SparkWalletLeaf, type SparkWithdrawRpcInput as SparkWithdrawRpcInput, type SparkWithdrawRpcInputParams as SparkWithdrawRpcInputParams, type SparkWithdrawRpcResponse as SparkWithdrawRpcResponse, type SuiCommandName as SuiCommandName, type SwapSubmissionStatus as SwapSubmissionStatus, type TempoAaAuthorization as TempoAaAuthorization, type TempoCall as TempoCall, type TempoFeePayerSignature as TempoFeePayerSignature, type TokenOutput as TokenOutput, type TokenTransferDestination as TokenTransferDestination, type TokenTransferSource as TokenTransferSource, type TotalFeeConfigurationBps as TotalFeeConfigurationBps, type TransactionChainNameInput as TransactionChainNameInput, type TransactionDetail as TransactionDetail, type TransactionTokenAddressInput as TransactionTokenAddressInput, type TransferQuoteRequestBody as TransferQuoteRequestBody, type TransferQuoteResponse as TransferQuoteResponse, type TransferReceivedTransactionDetail as TransferReceivedTransactionDetail, type TransferRequestBody as TransferRequestBody, type TransferSentTransactionDetail as TransferSentTransactionDetail, type TronContract as TronContract, type TronRawDataForSend as TronRawDataForSend, type TronRawDataForSign as TronRawDataForSign, type TronRpcInput as TronRpcInput, type TronRpcResponse as TronRpcResponse, type TronSendTransactionRpcInput as TronSendTransactionRpcInput, type TronSendTransactionRpcInputParams as TronSendTransactionRpcInputParams, type TronSendTransactionRpcResponse as TronSendTransactionRpcResponse, type TronSendTransactionRpcResponseData as TronSendTransactionRpcResponseData, type TronSignTransactionRpcInput as TronSignTransactionRpcInput, type TronSignTransactionRpcInputParams as TronSignTransactionRpcInputParams, type TronSignTransactionRpcResponse as TronSignTransactionRpcResponse, type TronSignTransactionRpcResponseData as TronSignTransactionRpcResponseData, type TronTransferContract as TronTransferContract, type TronTriggerSmartContract as TronTriggerSmartContract, type TypedDataDomainInputParams as TypedDataDomainInputParams, type TypedDataTypeFieldInput as TypedDataTypeFieldInput, type TypedDataTypesInputParams as TypedDataTypesInputParams, type UnsignedEthereumTransaction as UnsignedEthereumTransaction, type UnsignedStandardEthereumTransaction as UnsignedStandardEthereumTransaction, type UnsignedTempoTransaction as UnsignedTempoTransaction, type UserOperationInput as UserOperationInput, type UserSigningKeyBinding as UserSigningKeyBinding, type Wallet as Wallet, type WalletActionNonce as WalletActionNonce, type WalletAdditionalSigner as WalletAdditionalSigner, type WalletAdditionalSignerItem as WalletAdditionalSignerItem, type WalletAPIRegisterAuthorizationKeyInput as WalletAPIRegisterAuthorizationKeyInput, type WalletAPIRevokeAuthorizationKeyInput as WalletAPIRevokeAuthorizationKeyInput, type WalletAsset as WalletAsset, type WalletAssetChainNameInput as WalletAssetChainNameInput, type WalletAuthenticateBoundEncryptedRequestBody as WalletAuthenticateBoundEncryptedRequestBody, type WalletAuthenticateBoundRequestBody as WalletAuthenticateBoundRequestBody, type WalletAuthenticateBoundUnencryptedRequestBody as WalletAuthenticateBoundUnencryptedRequestBody, type WalletAuthenticateIntentsResponse as WalletAuthenticateIntentsResponse, type WalletAuthenticateRequestBody as WalletAuthenticateRequestBody, type WalletAuthenticateWithJwtResponse as WalletAuthenticateWithJwtResponse, type WalletAuthorizationHeaders as WalletAuthorizationHeaders, type WalletAutomationAttachmentListResponse as WalletAutomationAttachmentListResponse, type WalletAutomationAttachmentResponse as WalletAutomationAttachmentResponse, type WalletBatchCreateInput as WalletBatchCreateInput, type WalletBatchCreateResponse as WalletBatchCreateResponse, type WalletBatchCreateResult as WalletBatchCreateResult, type WalletBatchItemInput as WalletBatchItemInput, type WalletChainType as WalletChainType, type WalletCreateWalletsWithRecoveryResponse as WalletCreateWalletsWithRecoveryResponse, type WalletCustodian as WalletCustodian, type WalletEntity as WalletEntity, type WalletEntityAssignmentRequestBody as WalletEntityAssignmentRequestBody, type WalletEntityAssignmentResponse as WalletEntityAssignmentResponse, type WalletEntityType as WalletEntityType, type WalletEntropyType as WalletEntropyType, type WalletEthereumAsset as WalletEthereumAsset, type WalletExportRequestBody as WalletExportRequestBody, type WalletExportResponseBody as WalletExportResponseBody, type WalletImportInitResponse as WalletImportInitResponse, type WalletImportSupportedChains as WalletImportSupportedChains, type WalletImportSupportedEntropyTypes as WalletImportSupportedEntropyTypes, type WalletRevokeResponse as WalletRevokeResponse, type WalletRpcRequestBody as WalletRpcRequestBody, type WalletRpcResponse as WalletRpcResponse, type WalletSolanaAsset as WalletSolanaAsset, type WalletTronAsset as WalletTronAsset, type WalletUpdateRequestBody as WalletUpdateRequestBody, type XrplRpcInput as XrplRpcInput, type XrplRpcResponse as XrplRpcResponse, type XrplSignTransactionRpcInput as XrplSignTransactionRpcInput, type XrplSignTransactionRpcInputParams as XrplSignTransactionRpcInputParams, type XrplSignTransactionRpcResponse as XrplSignTransactionRpcResponse, type XrplSignTransactionRpcResponseData as XrplSignTransactionRpcResponseData, type WalletsCursor as WalletsCursor, type WalletCreateParams as WalletCreateParams, type WalletUpdateParams as WalletUpdateParams, type WalletListParams as WalletListParams, type WalletExportParams as WalletExportParams, type WalletGetParams as WalletGetParams, type WalletRawSignParams as WalletRawSignParams, type WalletRpcParams as WalletRpcParams, };
    export { Balance as Balance, type BalanceGetResponse as BalanceGetResponse, type BalanceGetParams as BalanceGetParams, };
    export { Transactions as Transactions, type TransactionGetResponse as TransactionGetResponse, type TransactionGetParams as TransactionGetParams, };
    export { Actions as Actions, type AaveVaultDetails as AaveVaultDetails, type CustodianTransactionWalletActionStep as CustodianTransactionWalletActionStep, type CustodianTransactionWalletActionStepStatus as CustodianTransactionWalletActionStepStatus, type EvmTransactionWalletActionStep as EvmTransactionWalletActionStep, type EvmUserOperationEntrypointVersion as EvmUserOperationEntrypointVersion, type EvmUserOperationWalletActionStep as EvmUserOperationWalletActionStep, type EvmWalletActionStepStatus as EvmWalletActionStepStatus, type EarnAsset as EarnAsset, type EarnDepositActionResponse as EarnDepositActionResponse, type EarnDepositRequestBody as EarnDepositRequestBody, type EarnFeeCollectActionResponse as EarnFeeCollectActionResponse, type EarnFeeCollectRequestBody as EarnFeeCollectRequestBody, type EarnIncentiveClaimActionResponse as EarnIncentiveClaimActionResponse, type EarnIncentiveClaimRequestBody as EarnIncentiveClaimRequestBody, type EarnIncentiveRewardEntry as EarnIncentiveRewardEntry, type EarnIncentiveRewardsQuery as EarnIncentiveRewardsQuery, type EarnIncentiveRewardsResponse as EarnIncentiveRewardsResponse, type EarnIncetiveClaimRewardEntry as EarnIncetiveClaimRewardEntry, type EarnWithdrawActionResponse as EarnWithdrawActionResponse, type EarnWithdrawRequestBody as EarnWithdrawRequestBody, type EthereumEarnPositionQuery as EthereumEarnPositionQuery, type EthereumEarnPositionResponse as EthereumEarnPositionResponse, type EthereumEarnProvider as EthereumEarnProvider, type EthereumEarnVaultDetailsResponse as EthereumEarnVaultDetailsResponse, type ExternalTransactionWalletActionStep as ExternalTransactionWalletActionStep, type ExternalTransactionWalletActionStepStatus as ExternalTransactionWalletActionStepStatus, type FailureReason as FailureReason, type ListWalletActionsQuery as ListWalletActionsQuery, type ListWalletActionsResponse as ListWalletActionsResponse, type MorphoVaultDetails as MorphoVaultDetails, type PayoutResponse as PayoutResponse, type SvmTransactionWalletActionStep as SvmTransactionWalletActionStep, type SvmWalletActionStepStatus as SvmWalletActionStepStatus, type SwapActionResponse as SwapActionResponse, type TvmTransactionWalletActionStep as TvmTransactionWalletActionStep, type TvmWalletActionStepStatus as TvmWalletActionStepStatus, type TempoVaultDetails as TempoVaultDetails, type TransferActionResponse as TransferActionResponse, type VedaVaultDetails as VedaVaultDetails, type WalletActionInclude as WalletActionInclude, type WalletActionResponse as WalletActionResponse, type WalletActionStatus as WalletActionStatus, type WalletActionStep as WalletActionStep, type WalletActionStepType as WalletActionStepType, type WalletActionType as WalletActionType, };
}
//# sourceMappingURL=wallets.d.mts.map