@privy-io/api-types 0.6.1 → 0.8.0

package/src/resources/wallets/wallets.ts

@@ -2,6 +2,8 @@
 
 import { APIResource } from '../../core/resource';
 import * as WalletsAPI from './wallets';
+import * as AppsAPI from '../apps';
+import * as SharedAPI from '../shared';
 import * as BalanceAPI from './balance';
 import { Balance, BalanceGetParams, BalanceGetResponse } from './balance';
 import * as TransactionsAPI from './transactions';
@@ -73,7 +75,11 @@ export class Wallets extends APIResource {
     params: WalletExportParams,
     options?: RequestOptions,
   ): APIPromise<WalletExportResponse> {
-    const { 'privy-authorization-signature': privyAuthorizationSignature, ...body } = params;
+    const {
+      'privy-authorization-signature': privyAuthorizationSignature,
+      'privy-request-expiry': privyRequestExpiry,
+      ...body
+    } = params;
     return this._client.post(path`/v1/wallets/${walletID}/export`, {
       body,
       ...options,
@@ -82,6 +88,7 @@ export class Wallets extends APIResource {
           ...(privyAuthorizationSignature != null ?
             { 'privy-authorization-signature': privyAuthorizationSignature }
           : undefined),
+          ...(privyRequestExpiry != null ? { 'privy-request-expiry': privyRequestExpiry } : undefined),
         },
         options?.headers,
       ]),
@@ -111,7 +118,7 @@ export class Wallets extends APIResource {
    *
    * @example
    * ```ts
-   * const response = await client.wallets._rawSign(
+   * const rawSignResponse = await client.wallets._rawSign(
    *   'wallet_id',
    *   {
    *     params: {
@@ -125,10 +132,11 @@ export class Wallets extends APIResource {
     walletID: string,
     params: WalletRawSignParams,
     options?: RequestOptions,
-  ): APIPromise<WalletRawSignResponse> {
+  ): APIPromise<RawSignResponse> {
     const {
       'privy-authorization-signature': privyAuthorizationSignature,
       'privy-idempotency-key': privyIdempotencyKey,
+      'privy-request-expiry': privyRequestExpiry,
       ...body
     } = params;
     return this._client.post(path`/v1/wallets/${walletID}/raw_sign`, {
@@ -140,6 +148,7 @@ export class Wallets extends APIResource {
             { 'privy-authorization-signature': privyAuthorizationSignature }
           : undefined),
           ...(privyIdempotencyKey != null ? { 'privy-idempotency-key': privyIdempotencyKey } : undefined),
+          ...(privyRequestExpiry != null ? { 'privy-request-expiry': privyRequestExpiry } : undefined),
         },
         options?.headers,
       ]),
@@ -151,16 +160,26 @@ export class Wallets extends APIResource {
    *
    * @example
    * ```ts
-   * const response = await client.wallets._rpc('wallet_id', {
-   *   method: 'personal_sign',
-   *   params: { encoding: 'utf-8', message: 'message' },
-   * });
+   * 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> {
     const {
       'privy-authorization-signature': privyAuthorizationSignature,
       'privy-idempotency-key': privyIdempotencyKey,
+      'privy-request-expiry': privyRequestExpiry,
       ...body
     } = params;
     return this._client.post(path`/v1/wallets/${walletID}/rpc`, {
@@ -172,6 +191,7 @@ export class Wallets extends APIResource {
             { 'privy-authorization-signature': privyAuthorizationSignature }
           : undefined),
           ...(privyIdempotencyKey != null ? { 'privy-idempotency-key': privyIdempotencyKey } : undefined),
+          ...(privyRequestExpiry != null ? { 'privy-request-expiry': privyRequestExpiry } : undefined),
         },
         options?.headers,
       ]),
@@ -206,11 +226,17 @@ export class Wallets extends APIResource {
    *
    * @example
    * ```ts
-   * const wallet = await client.wallets._update('wallet_id');
+   * const wallet = await client.wallets._update('wallet_id', {
+   *   policy_ids: ['tb54eps4z44ed0jepousxi4n'],
+   * });
    * ```
    */
   _update(walletID: string, params: WalletUpdateParams, options?: RequestOptions): APIPromise<Wallet> {
-    const { 'privy-authorization-signature': privyAuthorizationSignature, ...body } = params;
+    const {
+      'privy-authorization-signature': privyAuthorizationSignature,
+      'privy-request-expiry': privyRequestExpiry,
+      ...body
+    } = params;
     return this._client.patch(path`/v1/wallets/${walletID}`, {
       body,
       ...options,
@@ -219,6 +245,7 @@ export class Wallets extends APIResource {
           ...(privyAuthorizationSignature != null ?
             { 'privy-authorization-signature': privyAuthorizationSignature }
           : undefined),
+          ...(privyRequestExpiry != null ? { 'privy-request-expiry': privyRequestExpiry } : undefined),
         },
         options?.headers,
       ]),
@@ -231,6 +258,9 @@ export class Wallets extends APIResource {
    * @example
    * ```ts
    * const response = await client.wallets.authenticateWithJwt({
+   *   encryption_type: 'HPKE',
+   *   recipient_public_key:
+   *     'DAQcDQgAEx4aoeD72yykviK+fckqE2CItVIGn1rCnvCXZ1HgpOcMEMialRmTrqIK4oZlYd1',
    *   user_jwt:
    *     'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsImlhdCI6MTUxNjIzOTAyMn0.KMUFsIDTnFmyG3nMiGM6H9FNFUROf3wh7SmqJp-QV30',
    * });
@@ -331,6 +361,72 @@ export type WalletChainType =
   | 'starknet'
   | 'spark';
 
+/**
+ * The role of an authorization key, controlling what actions it can authorize on a
+ * wallet.
+ */
+export type AuthorizationKeyRole = 'root' | 'manager' | 'delegated-actions' | null;
+
+/**
+ * The entropy type of the wallet.
+ */
+export type WalletEntropyType = 'hd' | 'private-key';
+
+/**
+ * The derivation strategy used for Solana wallets.
+ */
+export type SolanaWalletDerivationStrategy = 'ENTROPY_TO_SEED' | 'ENTROPY_TO_MNEMONIC_TO_SEED';
+
+/**
+ * An optional list of up to one policy ID to enforce on the wallet.
+ */
+export type PolicyInput = Array<string>;
+
+/**
+ * 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;
+}
+
+/**
+ * Additional signers for the wallet.
+ */
+export type AdditionalSignerInput = Array<AdditionalSignerItemInput>;
+
+/**
+ * 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;
+}
+
+/**
+ * Additional signers for the wallet.
+ */
+export type WalletAdditionalSigner = Array<WalletAdditionalSignerItem>;
+
+/**
+ * A blockchain wallet address (Ethereum or Solana).
+ */
+export type Address = string;
+
 /**
  * Information about the custodian managing this wallet.
  */
@@ -354,7 +450,7 @@ export type CustodialWalletProvider = 'bridge';
 /**
  * The chain type of the custodial wallet.
  */
-export type CustodialWalletChainType = 'ethereum';
+export type CustodialWalletChainType = 'ethereum' | 'solana';
 
 /**
  * The input for creating a custodial wallet.
@@ -376,27 +472,21 @@ export interface CustodialWalletCreateInput {
    */
   provider_user_id: string;
 
-  additional_signers?: Array<CustodialWalletCreateInput.AdditionalSigner>;
-
-  owner?: CustodialWalletCreateInput.UserID | CustodialWalletCreateInput.PublicKey | null;
-
-  policy_ids?: Array<string>;
-}
-
-export namespace CustodialWalletCreateInput {
-  export interface AdditionalSigner {
-    signer_id: string;
-
-    override_policy_ids?: Array<string>;
-  }
+  /**
+   * Additional signers for the wallet.
+   */
+  additional_signers?: AdditionalSignerInput;
 
-  export interface UserID {
-    user_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;
 
-  export interface PublicKey {
-    public_key: string;
-  }
+  /**
+   * An optional list of up to one policy ID to enforce on the wallet.
+   */
+  policy_ids?: PolicyInput;
 }
 
 /**
@@ -419,402 +509,608 @@ export interface CustodialWallet {
 
   owner_id: string | null;
 
-  additional_signers?: Array<CustodialWallet.AdditionalSigner>;
+  /**
+   * Additional signers for the wallet.
+   */
+  additional_signers?: WalletAdditionalSigner;
 
   policy_ids?: Array<string>;
 }
 
-export namespace CustodialWallet {
-  export interface AdditionalSigner {
-    signer_id: string;
+/**
+ * The encryption type of the wallet to import. Currently only supports `HPKE`.
+ */
+export type HpkeEncryption = 'HPKE';
 
-    override_policy_ids?: Array<string>;
-  }
-}
+/**
+ * The recipient public key for HPKE encryption, in PEM or DER (base64-encoded)
+ * format.
+ */
+export type RecipientPublicKey = string;
 
 /**
- * Optional HPKE configuration for wallet import decryption. These parameters allow
- * importing wallets encrypted by external providers that use different HPKE
- * configurations.
+ * The export type. 'display' is for showing the key to the user in the UI,
+ * 'client' is for exporting to the client application.
  */
-export interface HpkeImportConfig {
+export type ExportType = 'display' | 'client';
+
+/**
+ * Input for exporting a wallet (private key or seed phrase) with HPKE encryption.
+ */
+export interface PrivateKeyExportInput {
   /**
-   * Additional Authenticated Data (AAD) used during encryption. Should be
-   * base64-encoded bytes.
+   * The encryption type of the wallet to import. Currently only supports `HPKE`.
    */
-  aad?: string;
+  encryption_type: HpkeEncryption;
 
   /**
-   * The AEAD algorithm used for encryption. Defaults to CHACHA20_POLY1305 if not
-   * specified.
+   * The recipient public key for HPKE encryption, in PEM or DER (base64-encoded)
+   * format.
    */
-  aead_algorithm?: 'CHACHA20_POLY1305' | 'AES_GCM256';
+  recipient_public_key: RecipientPublicKey;
+
+  export_seed_phrase?: boolean;
 
   /**
-   * Application-specific context information (INFO) used during HPKE encryption.
-   * Should be base64-encoded bytes.
+   * The export type. 'display' is for showing the key to the user in the UI,
+   * 'client' is for exporting to the client application.
    */
-  info?: string;
+  export_type?: ExportType;
 }
 
 /**
- * SUI transaction commands allowlist for raw_sign endpoint policy evaluation
+ * Response containing HPKE-encrypted wallet data (private key or seed phrase).
  */
-export type SuiCommandName = 'TransferObjects' | 'SplitCoins' | 'MergeCoins';
+export interface PrivateKeyExportResponse {
+  ciphertext: string;
+
+  encapsulated_key: string;
+
+  /**
+   * The encryption type of the wallet to import. Currently only supports `HPKE`.
+   */
+  encryption_type: HpkeEncryption;
+}
 
 /**
- * A wallet managed by Privy's wallet infrastructure.
+ * Input for exporting a wallet (private key or seed phrase) with HPKE encryption.
  */
-export interface Wallet {
+export interface SeedPhraseExportInput {
   /**
-   * Unique ID of the wallet. This will be the primary identifier when using the
-   * wallet in the future.
+   * The encryption type of the wallet to import. Currently only supports `HPKE`.
    */
-  id: string;
+  encryption_type: HpkeEncryption;
 
   /**
-   * Additional signers for the wallet.
+   * The recipient public key for HPKE encryption, in PEM or DER (base64-encoded)
+   * format.
    */
-  additional_signers: Array<Wallet.AdditionalSigner>;
+  recipient_public_key: RecipientPublicKey;
+
+  export_seed_phrase?: boolean;
 
   /**
-   * Address of the wallet.
+   * The export type. 'display' is for showing the key to the user in the UI,
+   * 'client' is for exporting to the client application.
    */
-  address: string;
+  export_type?: ExportType;
+}
+
+/**
+ * Response containing HPKE-encrypted wallet data (private key or seed phrase).
+ */
+export interface SeedPhraseExportResponse {
+  ciphertext: string;
+
+  encapsulated_key: string;
 
   /**
-   * The wallet chain types.
+   * The encryption type of the wallet to import. Currently only supports `HPKE`.
    */
-  chain_type: WalletChainType;
+  encryption_type: HpkeEncryption;
+}
+
+/**
+ * The chain type of the wallet to import. Currently supports `ethereum` and
+ * `solana`.
+ */
+export type WalletImportSupportedChains = 'ethereum' | 'solana';
+
+/**
+ * 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';
+
+/**
+ * Response from initializing a wallet import, containing the encryption public
+ * key.
+ */
+export interface WalletImportInitResponse {
+  encryption_public_key: string;
 
   /**
-   * Unix timestamp of when the wallet was created in milliseconds.
+   * The encryption type of the wallet to import. Currently only supports `HPKE`.
    */
-  created_at: number;
+  encryption_type: HpkeEncryption;
+}
+
+/**
+ * The AEAD algorithm used for HPKE encryption.
+ */
+export type HpkeAeadAlgorithm = 'CHACHA20_POLY1305' | 'AES_GCM256';
 
+/**
+ * Optional HPKE configuration for wallet import decryption. These parameters allow
+ * importing wallets encrypted by external providers that use different HPKE
+ * configurations.
+ */
+export interface HpkeImportConfig {
   /**
-   * Unix timestamp of when the wallet was exported in milliseconds, if the wallet
-   * was exported.
+   * Additional Authenticated Data (AAD) used during encryption. Should be
+   * base64-encoded bytes.
    */
-  exported_at: number | null;
+  aad?: string;
 
   /**
-   * Unix timestamp of when the wallet was imported in milliseconds, if the wallet
-   * was imported.
+   * The AEAD algorithm used for HPKE encryption.
    */
-  imported_at: number | null;
+  aead_algorithm?: HpkeAeadAlgorithm;
 
   /**
-   * The key quorum ID of the owner of the wallet.
+   * Application-specific context information (INFO) used during HPKE encryption.
+   * Should be base64-encoded bytes.
    */
-  owner_id: string | null;
+  info?: string;
+}
+
+/**
+ * The cryptographic curve type used by the wallet.
+ */
+export type CurveType = 'secp256k1' | 'ed25519' | 'starknet';
+
+/**
+ * A BIP-32 hierarchical deterministic wallet derivation path.
+ */
+export type HDPath = string;
+
+/**
+ * The signing algorithm used by the wallet.
+ */
+export type SigningAlgorithm = 'ECDSA' | 'EdDSA';
+
+/**
+ * A hex-encoded string prefixed with '0x'.
+ */
+export type Hex = string;
+
+/**
+ * A quantity value that can be either a hex string starting with '0x' or a
+ * non-negative integer.
+ */
+export type Quantity = Hex | number;
+
+/**
+ * Exports the private key of the wallet.
+ */
+export interface ExportPrivateKeyRpcInput {
+  address: string;
+
+  method: 'exportPrivateKey';
 
   /**
-   * List of policy IDs for policies that are enforced on the wallet.
+   * Input for exporting a wallet (private key or seed phrase) with HPKE encryption.
    */
-  policy_ids: Array<string>;
+  params: PrivateKeyExportInput;
+}
 
+/**
+ * Response to the `exportPrivateKey` RPC.
+ */
+export interface ExportPrivateKeyRpcResponse {
   /**
-   * The compressed, raw public key for the wallet along the chain cryptographic
-   * curve.
+   * Input for exporting a wallet (private key or seed phrase) with HPKE encryption.
    */
-  public_key?: string;
+  data: PrivateKeyExportInput;
+
+  method: 'exportPrivateKey';
 }
 
-export namespace Wallet {
-  export interface AdditionalSigner {
-    signer_id: string;
+/**
+ * Exports the seed phrase of the wallet.
+ */
+export interface ExportSeedPhraseRpcInput {
+  address: string;
 
-    /**
-     * The array of policy IDs that will be applied to wallet requests. If specified,
-     * this will override the base policy IDs set on the wallet.
-     */
-    override_policy_ids?: Array<string>;
-  }
+  method: 'exportSeedPhrase';
+
+  /**
+   * Input for exporting a wallet (private key or seed phrase) with HPKE encryption.
+   */
+  params: SeedPhraseExportInput;
 }
 
 /**
- * Input for a single wallet in a batch creation request.
+ * Response to the `exportSeedPhrase` RPC.
  */
-export interface WalletBatchItemInput {
+export interface ExportSeedPhraseRpcResponse {
   /**
-   * The wallet chain types.
+   * Response containing HPKE-encrypted wallet data (private key or seed phrase).
    */
-  chain_type: WalletChainType;
+  data: SeedPhraseExportResponse;
+
+  method: 'exportSeedPhrase';
+}
 
+/**
+ * Parameters for signing a pre-computed hash with the `raw_sign` RPC.
+ */
+export interface RawSignHashParams {
   /**
-   * Additional signers for the wallet.
+   * A hex-encoded string prefixed with '0x'.
    */
-  additional_signers?: Array<WalletBatchItemInput.AdditionalSigner>;
+  hash: Hex;
+}
+
+/**
+ * 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 owner of the resource. If you provide this, do not specify an owner_id as it
-   * will be generated automatically. When updating a wallet, you can set the owner
-   * to null to remove the owner.
+   * The bytes to hash and sign.
    */
-  owner?: WalletBatchItemInput.PublicKeyOwner | WalletBatchItemInput.UserOwner | null;
+  bytes: string;
 
   /**
-   * The key quorum ID to set as the owner of the resource. If you provide this, do
-   * not specify an owner.
+   * Encoding scheme for bytes in the `raw_sign` RPC.
    */
-  owner_id?: string;
+  encoding: RawSignBytesEncoding;
 
   /**
-   * List of policy IDs for policies that should be enforced on the wallet.
-   * Currently, only one policy is supported per wallet.
+   * Hash function for bytes in the `raw_sign` RPC.
    */
-  policy_ids?: Array<string>;
+  hash_function: RawSignBytesHashFunction;
 }
 
-export namespace WalletBatchItemInput {
-  export interface AdditionalSigner {
-    signer_id: string;
-
-    /**
-     * The array of policy IDs that will be applied to wallet requests. If specified,
-     * this will override the base policy IDs set on the wallet.
-     */
-    override_policy_ids?: Array<string>;
-  }
+/**
+ * Parameters for the `raw_sign` RPC.
+ */
+export type RawSignInputParams = RawSignHashParams | RawSignBytesParams;
 
+/**
+ * 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 {
   /**
-   * The P-256 public key of the owner of the resource, in base64-encoded DER format.
-   * If you provide this, do not specify an owner_id as it will be generated
-   * automatically.
+   * Parameters for the `raw_sign` RPC.
    */
-  export interface PublicKeyOwner {
-    public_key: string;
-  }
+  params: RawSignInputParams;
+}
+
+/**
+ * Data returned by the `raw_sign` RPC.
+ */
+export interface RawSignResponseData {
+  encoding: 'hex';
 
   /**
-   * The user ID of the owner of the resource. The user must already exist, and this
-   * value must start with "did:privy:". If you provide this, do not specify an
-   * owner_id as it will be generated automatically.
+   * A hex-encoded string prefixed with '0x'.
    */
-  export interface UserOwner {
-    user_id: string;
-  }
+  signature: Hex;
 }
 
 /**
- * Request body for batch wallet creation.
+ * Response to the `raw_sign` RPC.
  */
-export interface WalletBatchCreateInput {
+export interface RawSignResponse {
   /**
-   * Array of wallet creation requests. Minimum 1, maximum 100.
+   * Data returned by the `raw_sign` RPC.
    */
-  wallets: Array<WalletBatchItemInput>;
+  data: RawSignResponseData;
+
+  method: 'raw_sign';
 }
 
 /**
- * A single result from a batch wallet creation operation.
+ * A signed EIP-7702 authorization that delegates code execution to a contract
+ * address.
  */
-export type WalletBatchCreateResult =
-  | WalletBatchCreateResult.WalletBatchCreateSuccess
-  | WalletBatchCreateResult.WalletBatchCreateFailure;
-
-export namespace WalletBatchCreateResult {
+export interface EthereumSign7702Authorization {
   /**
-   * A successful wallet creation result within a batch operation.
+   * A quantity value that can be either a hex string starting with '0x' or a
+   * non-negative integer.
    */
-  export interface WalletBatchCreateSuccess {
-    /**
-     * The index of the wallet in the original request array.
-     */
-    index: number;
+  chain_id: Quantity;
 
-    success: true;
-
-    /**
-     * A wallet managed by Privy's wallet infrastructure.
-     */
-    wallet: WalletsAPI.Wallet;
-  }
+  contract: string;
 
   /**
-   * A failed wallet creation result within a batch operation.
+   * A quantity value that can be either a hex string starting with '0x' or a
+   * non-negative integer.
    */
-  export interface WalletBatchCreateFailure {
-    /**
-     * A PrivyErrorCode string identifying the error type (e.g., "invalid_data",
-     * "resource_conflict").
-     */
-    code: string;
+  nonce: Quantity;
 
-    /**
-     * A human-readable error message with details about what went wrong.
-     */
-    error: string;
+  /**
+   * A hex-encoded string prefixed with '0x'.
+   */
+  r: Hex;
 
-    /**
-     * The index of the wallet in the original request array.
-     */
-    index: number;
+  /**
+   * A hex-encoded string prefixed with '0x'.
+   */
+  s: Hex;
 
-    success: false;
-  }
+  y_parity: number;
 }
 
 /**
- * Response for a batch wallet creation request.
+ * An unsigned Ethereum transaction object.
  */
-export interface WalletBatchCreateResponse {
+export interface UnsignedEthereumTransaction {
+  authorization_list?: Array<EthereumSign7702Authorization>;
+
   /**
-   * Array of results for each wallet creation request, in the same order as input.
+   * A quantity value that can be either a hex string starting with '0x' or a
+   * non-negative integer.
    */
-  results: Array<WalletBatchCreateResult>;
-}
+  chain_id?: Quantity;
 
-/**
- * Executes the EVM `personal_sign` RPC (EIP-191) to sign a message.
- */
-export interface EthereumPersonalSignRpcInput {
-  method: 'personal_sign';
+  /**
+   * A hex-encoded string prefixed with '0x'.
+   */
+  data?: Hex;
 
-  params: EthereumPersonalSignRpcInput.Params;
+  from?: string;
 
-  address?: string;
+  /**
+   * A quantity value that can be either a hex string starting with '0x' or a
+   * non-negative integer.
+   */
+  gas_limit?: Quantity;
 
-  chain_type?: 'ethereum';
-}
+  /**
+   * A quantity value that can be either a hex string starting with '0x' or a
+   * non-negative integer.
+   */
+  gas_price?: Quantity;
 
-export namespace EthereumPersonalSignRpcInput {
-  export interface Params {
-    encoding: 'utf-8' | 'hex';
+  /**
+   * A quantity value that can be either a hex string starting with '0x' or a
+   * non-negative integer.
+   */
+  max_fee_per_gas?: Quantity;
 
-    message: string;
-  }
-}
+  /**
+   * A quantity value that can be either a hex string starting with '0x' or a
+   * non-negative integer.
+   */
+  max_priority_fee_per_gas?: Quantity;
 
-/**
- * Executes the EVM `eth_signTransaction` RPC to sign a transaction.
- */
-export interface EthereumSignTransactionRpcInput {
-  method: 'eth_signTransaction';
+  /**
+   * A quantity value that can be either a hex string starting with '0x' or a
+   * non-negative integer.
+   */
+  nonce?: Quantity;
 
-  params: EthereumSignTransactionRpcInput.Params;
+  to?: string;
 
-  address?: string;
+  type?: 0 | 1 | 2 | 4;
 
-  chain_type?: 'ethereum';
+  /**
+   * A quantity value that can be either a hex string starting with '0x' or a
+   * non-negative integer.
+   */
+  value?: Quantity;
 }
 
-export namespace EthereumSignTransactionRpcInput {
-  export interface Params {
-    transaction: Params.Transaction;
-  }
-
-  export namespace Params {
-    export interface Transaction {
-      authorization_list?: Array<Transaction.AuthorizationList>;
+/**
+ * An ERC-4337 user operation.
+ */
+export interface UserOperationInput {
+  /**
+   * A hex-encoded string prefixed with '0x'.
+   */
+  call_data: Hex;
 
-      chain_id?: string | number;
+  /**
+   * A hex-encoded string prefixed with '0x'.
+   */
+  call_gas_limit: Hex;
 
-      data?: string;
+  /**
+   * A hex-encoded string prefixed with '0x'.
+   */
+  max_fee_per_gas: Hex;
 
-      from?: string;
+  /**
+   * A hex-encoded string prefixed with '0x'.
+   */
+  max_priority_fee_per_gas: Hex;
 
-      gas_limit?: string | number;
+  /**
+   * A hex-encoded string prefixed with '0x'.
+   */
+  nonce: Hex;
 
-      gas_price?: string | number;
+  /**
+   * A hex-encoded string prefixed with '0x'.
+   */
+  pre_verification_gas: Hex;
 
-      max_fee_per_gas?: string | number;
+  sender: string;
 
-      max_priority_fee_per_gas?: string | number;
+  /**
+   * A hex-encoded string prefixed with '0x'.
+   */
+  verification_gas_limit: Hex;
 
-      nonce?: string | number;
+  paymaster?: string;
 
-      to?: string;
+  /**
+   * A hex-encoded string prefixed with '0x'.
+   */
+  paymaster_data?: Hex;
 
-      type?: 0 | 1 | 2 | 4;
+  /**
+   * A hex-encoded string prefixed with '0x'.
+   */
+  paymaster_post_op_gas_limit?: Hex;
 
-      value?: string | number;
-    }
+  /**
+   * A hex-encoded string prefixed with '0x'.
+   */
+  paymaster_verification_gas_limit?: Hex;
+}
 
-    export namespace Transaction {
-      export interface AuthorizationList {
-        chain_id: string | number;
+/**
+ * The domain parameters for EIP-712 typed data signing.
+ */
+export type TypedDataDomainInputParams = { [key: string]: unknown };
 
-        contract: string;
+/**
+ * A single field definition in an EIP-712 typed data type.
+ */
+export interface TypedDataTypeFieldInput {
+  name: string;
 
-        nonce: string | number;
+  type: string;
+}
 
-        r: string;
+/**
+ * The type definitions for EIP-712 typed data signing.
+ */
+export type TypedDataTypesInputParams = { [key: string]: Array<TypedDataTypeFieldInput> };
 
-        s: string;
+/**
+ * Parameters for the EVM `personal_sign` RPC.
+ */
+export interface EthereumPersonalSignRpcInputParams {
+  encoding: 'utf-8' | 'hex';
 
-        y_parity: number;
-      }
-    }
-  }
+  message: string;
 }
 
 /**
- * Executes the EVM `eth_sendTransaction` RPC to sign and broadcast a transaction.
+ * Executes the EVM `personal_sign` RPC (EIP-191) to sign a message.
  */
-export interface EthereumSendTransactionRpcInput {
-  caip2: string;
-
-  method: 'eth_sendTransaction';
+export interface EthereumPersonalSignRpcInput {
+  method: 'personal_sign';
 
-  params: EthereumSendTransactionRpcInput.Params;
+  /**
+   * Parameters for the EVM `personal_sign` RPC.
+   */
+  params: EthereumPersonalSignRpcInputParams;
 
   address?: string;
 
   chain_type?: 'ethereum';
 
-  sponsor?: boolean;
+  wallet_id?: string;
 }
 
-export namespace EthereumSendTransactionRpcInput {
-  export interface Params {
-    transaction: Params.Transaction;
-  }
+/**
+ * Parameters for the EVM `eth_signTransaction` RPC.
+ */
+export interface EthereumSignTransactionRpcInputParams {
+  /**
+   * An unsigned Ethereum transaction object.
+   */
+  transaction: UnsignedEthereumTransaction;
+}
+
+/**
+ * Executes the EVM `eth_signTransaction` RPC to sign a transaction.
+ */
+export interface EthereumSignTransactionRpcInput {
+  method: 'eth_signTransaction';
 
-  export namespace Params {
-    export interface Transaction {
-      authorization_list?: Array<Transaction.AuthorizationList>;
+  /**
+   * Parameters for the EVM `eth_signTransaction` RPC.
+   */
+  params: EthereumSignTransactionRpcInputParams;
 
-      chain_id?: string | number;
+  address?: string;
 
-      data?: string;
+  chain_type?: 'ethereum';
 
-      from?: string;
+  wallet_id?: string;
+}
 
-      gas_limit?: string | number;
+/**
+ * Parameters for the EVM `eth_sendTransaction` RPC.
+ */
+export interface EthereumSendTransactionRpcInputParams {
+  /**
+   * An unsigned Ethereum transaction object.
+   */
+  transaction: UnsignedEthereumTransaction;
+}
 
-      gas_price?: string | number;
+/**
+ * Executes the EVM `eth_sendTransaction` RPC to sign and broadcast a transaction.
+ */
+export interface EthereumSendTransactionRpcInput {
+  /**
+   * A valid CAIP-2 chain ID (e.g. 'eip155:1').
+   */
+  caip2: AppsAPI.Caip2;
 
-      max_fee_per_gas?: string | number;
+  method: 'eth_sendTransaction';
 
-      max_priority_fee_per_gas?: string | number;
+  /**
+   * Parameters for the EVM `eth_sendTransaction` RPC.
+   */
+  params: EthereumSendTransactionRpcInputParams;
 
-      nonce?: string | number;
+  address?: string;
 
-      to?: string;
+  chain_type?: 'ethereum';
 
-      type?: 0 | 1 | 2 | 4;
+  reference_id?: string;
 
-      value?: string | number;
-    }
+  sponsor?: boolean;
 
-    export namespace Transaction {
-      export interface AuthorizationList {
-        chain_id: string | number;
+  wallet_id?: string;
+}
 
-        contract: string;
+/**
+ * EIP-712 typed data object.
+ */
+export interface EthereumTypedDataInput {
+  /**
+   * The domain parameters for EIP-712 typed data signing.
+   */
+  domain: TypedDataDomainInputParams;
 
-        nonce: string | number;
+  message: { [key: string]: unknown };
 
-        r: string;
+  primary_type: string;
 
-        s: string;
+  /**
+   * The type definitions for EIP-712 typed data signing.
+   */
+  types: TypedDataTypesInputParams;
+}
 
-        y_parity: number;
-      }
-    }
-  }
+/**
+ * Parameters for the EVM `eth_signTypedData_v4` RPC.
+ */
+export interface EthereumSignTypedDataRpcInputParams {
+  /**
+   * EIP-712 typed data object.
+   */
+  typed_data: EthereumTypedDataInput;
 }
 
 /**
@@ -824,88 +1120,65 @@ export namespace EthereumSendTransactionRpcInput {
 export interface EthereumSignTypedDataRpcInput {
   method: 'eth_signTypedData_v4';
 
-  params: EthereumSignTypedDataRpcInput.Params;
+  /**
+   * Parameters for the EVM `eth_signTypedData_v4` RPC.
+   */
+  params: EthereumSignTypedDataRpcInputParams;
 
   address?: string;
 
   chain_type?: 'ethereum';
-}
-
-export namespace EthereumSignTypedDataRpcInput {
-  export interface Params {
-    typed_data: Params.TypedData;
-  }
-
-  export namespace Params {
-    export interface TypedData {
-      domain: { [key: string]: unknown };
-
-      message: { [key: string]: unknown };
-
-      primary_type: string;
-
-      types: { [key: string]: Array<TypedData.Type> };
-    }
 
-    export namespace TypedData {
-      export interface Type {
-        name: string;
+  wallet_id?: string;
+}
 
-        type: string;
-      }
-    }
-  }
+/**
+ * Parameters for the EVM `secp256k1_sign` RPC.
+ */
+export interface EthereumSecp256k1SignRpcInputParams {
+  /**
+   * A hex-encoded string prefixed with '0x'.
+   */
+  hash: Hex;
 }
 
 /**
- * Executes an RPC method to hash and sign a UserOperation.
+ * Signs a raw hash on the secp256k1 curve.
  */
-export interface EthereumSignUserOperationRpcInput {
-  method: 'eth_signUserOperation';
+export interface EthereumSecp256k1SignRpcInput {
+  method: 'secp256k1_sign';
 
-  params: EthereumSignUserOperationRpcInput.Params;
+  /**
+   * Parameters for the EVM `secp256k1_sign` RPC.
+   */
+  params: EthereumSecp256k1SignRpcInputParams;
 
   address?: string;
 
   chain_type?: 'ethereum';
-}
 
-export namespace EthereumSignUserOperationRpcInput {
-  export interface Params {
-    chain_id: string | number;
-
-    contract: string;
-
-    user_operation: Params.UserOperation;
-  }
-
-  export namespace Params {
-    export interface UserOperation {
-      call_data: string;
-
-      call_gas_limit: string;
-
-      max_fee_per_gas: string;
-
-      max_priority_fee_per_gas: string;
-
-      nonce: string;
-
-      paymaster: string;
-
-      paymaster_data: string;
-
-      paymaster_post_op_gas_limit: string;
+  wallet_id?: string;
+}
 
-      paymaster_verification_gas_limit: 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;
 
-      pre_verification_gas: string;
+  contract: string;
 
-      sender: string;
+  executor?: 'self';
 
-      verification_gas_limit: string;
-    }
-  }
+  /**
+   * A quantity value that can be either a hex string starting with '0x' or a
+   * non-negative integer.
+   */
+  nonce?: Quantity;
 }
 
 /**
@@ -914,392 +1187,1414 @@ export namespace EthereumSignUserOperationRpcInput {
 export interface EthereumSign7702AuthorizationRpcInput {
   method: 'eth_sign7702Authorization';
 
-  params: EthereumSign7702AuthorizationRpcInput.Params;
+  /**
+   * Parameters for the EVM `eth_sign7702Authorization` RPC.
+   */
+  params: EthereumSign7702AuthorizationRpcInputParams;
 
   address?: string;
 
   chain_type?: 'ethereum';
+
+  wallet_id?: string;
 }
 
-export namespace EthereumSign7702AuthorizationRpcInput {
-  export interface Params {
-    chain_id: string | number;
+/**
+ * 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;
+  contract: string;
 
-    nonce?: string | number;
-  }
+  /**
+   * An ERC-4337 user operation.
+   */
+  user_operation: UserOperationInput;
 }
 
 /**
- * Signs a raw hash on the secp256k1 curve.
+ * Executes an RPC method to hash and sign a UserOperation.
  */
-export interface EthereumSecp256k1SignRpcInput {
-  method: 'secp256k1_sign';
+export interface EthereumSignUserOperationRpcInput {
+  method: 'eth_signUserOperation';
 
-  params: EthereumSecp256k1SignRpcInput.Params;
+  /**
+   * Parameters for the EVM `eth_signUserOperation` RPC.
+   */
+  params: EthereumSignUserOperationRpcInputParams;
 
   address?: string;
 
   chain_type?: 'ethereum';
-}
 
-export namespace EthereumSecp256k1SignRpcInput {
-  export interface Params {
-    hash: string;
-  }
+  wallet_id?: string;
 }
 
 /**
- * Executes the SVM `signTransaction` RPC to sign a transaction.
+ * A single call within a batched wallet_sendCalls request.
  */
-export interface SolanaSignTransactionRpcInput {
-  method: 'signTransaction';
-
-  params: SolanaSignTransactionRpcInput.Params;
+export interface EthereumSendCallsCall {
+  to: string;
 
-  address?: string;
+  /**
+   * A hex-encoded string prefixed with '0x'.
+   */
+  data?: Hex;
 
-  chain_type?: 'solana';
+  /**
+   * A quantity value that can be either a hex string starting with '0x' or a
+   * non-negative integer.
+   */
+  value?: Quantity;
 }
 
-export namespace SolanaSignTransactionRpcInput {
-  export interface Params {
-    encoding: 'base64';
-
-    transaction: string;
-  }
+/**
+ * Parameters for the `wallet_sendCalls` RPC.
+ */
+export interface EthereumSendCallsRpcInputParams {
+  calls: Array<EthereumSendCallsCall>;
 }
 
 /**
- * Executes the SVM `signAndSendTransaction` RPC to sign and broadcast a
- * transaction.
+ * Executes the `wallet_sendCalls` RPC (EIP-5792) to batch multiple calls into a
+ * single atomic transaction.
  */
-export interface SolanaSignAndSendTransactionRpcInput {
-  caip2: string;
+export interface EthereumSendCallsRpcInput {
+  /**
+   * A valid CAIP-2 chain ID (e.g. 'eip155:1').
+   */
+  caip2: AppsAPI.Caip2;
 
-  method: 'signAndSendTransaction';
+  method: 'wallet_sendCalls';
 
-  params: SolanaSignAndSendTransactionRpcInput.Params;
+  /**
+   * Parameters for the `wallet_sendCalls` RPC.
+   */
+  params: EthereumSendCallsRpcInputParams;
 
   address?: string;
 
-  chain_type?: 'solana';
+  chain_type?: 'ethereum';
 
   sponsor?: boolean;
-}
-
-export namespace SolanaSignAndSendTransactionRpcInput {
-  export interface Params {
-    encoding: 'base64';
 
-    transaction: string;
-  }
+  wallet_id?: string;
 }
 
 /**
- * Executes the SVM `signMessage` RPC to sign a message.
+ * Request body for Ethereum wallet RPC operations, discriminated by method.
  */
-export interface SolanaSignMessageRpcInput {
-  method: 'signMessage';
+export type EthereumRpcInput =
+  | EthereumSignTransactionRpcInput
+  | EthereumSendTransactionRpcInput
+  | EthereumPersonalSignRpcInput
+  | EthereumSignTypedDataRpcInput
+  | EthereumSecp256k1SignRpcInput
+  | EthereumSign7702AuthorizationRpcInput
+  | EthereumSignUserOperationRpcInput
+  | EthereumSendCallsRpcInput;
 
-  params: SolanaSignMessageRpcInput.Params;
+/**
+ * Data returned by the EVM `personal_sign` RPC.
+ */
+export interface EthereumPersonalSignRpcResponseData {
+  encoding: 'hex';
 
-  address?: string;
+  signature: string;
+}
 
-  chain_type?: 'solana';
+/**
+ * Response to the EVM `personal_sign` RPC.
+ */
+export interface EthereumPersonalSignRpcResponse {
+  /**
+   * Data returned by the EVM `personal_sign` RPC.
+   */
+  data: EthereumPersonalSignRpcResponseData;
+
+  method: 'personal_sign';
 }
 
-export namespace SolanaSignMessageRpcInput {
-  export interface Params {
-    encoding: 'base64';
+/**
+ * Data returned by the EVM `eth_signTransaction` RPC.
+ */
+export interface EthereumSignTransactionRpcResponseData {
+  encoding: 'rlp';
 
-    message: string;
-  }
+  signed_transaction: string;
 }
 
 /**
  * Response to the EVM `eth_signTransaction` RPC.
  */
 export interface EthereumSignTransactionRpcResponse {
-  data: EthereumSignTransactionRpcResponse.Data;
+  /**
+   * Data returned by the EVM `eth_signTransaction` RPC.
+   */
+  data: EthereumSignTransactionRpcResponseData;
 
   method: 'eth_signTransaction';
 }
 
-export namespace EthereumSignTransactionRpcResponse {
-  export interface Data {
-    encoding: 'rlp';
+/**
+ * Data returned by the EVM `eth_sendTransaction` RPC.
+ */
+export interface EthereumSendTransactionRpcResponseData {
+  /**
+   * A valid CAIP-2 chain ID (e.g. 'eip155:1').
+   */
+  caip2: AppsAPI.Caip2;
 
-    signed_transaction: string;
-  }
+  hash: string;
+
+  reference_id?: string | null;
+
+  transaction_id?: string;
+
+  /**
+   * An unsigned Ethereum transaction object.
+   */
+  transaction_request?: UnsignedEthereumTransaction;
+
+  user_operation_hash?: string;
 }
 
 /**
  * Response to the EVM `eth_sendTransaction` RPC.
  */
 export interface EthereumSendTransactionRpcResponse {
-  data: EthereumSendTransactionRpcResponse.Data;
+  /**
+   * Data returned by the EVM `eth_sendTransaction` RPC.
+   */
+  data: EthereumSendTransactionRpcResponseData;
 
   method: 'eth_sendTransaction';
 }
 
-export namespace EthereumSendTransactionRpcResponse {
-  export interface Data {
-    caip2: string;
-
-    hash: string;
+/**
+ * Data returned by the EVM `eth_signTypedData_v4` RPC.
+ */
+export interface EthereumSignTypedDataRpcResponseData {
+  encoding: 'hex';
 
-    transaction_id?: string;
+  signature: string;
+}
 
-    transaction_request?: Data.TransactionRequest;
+/**
+ * Response to the EVM `eth_signTypedData_v4` RPC.
+ */
+export interface EthereumSignTypedDataRpcResponse {
+  /**
+   * Data returned by the EVM `eth_signTypedData_v4` RPC.
+   */
+  data: EthereumSignTypedDataRpcResponseData;
 
-    user_operation_hash?: string;
-  }
+  method: 'eth_signTypedData_v4';
+}
 
-  export namespace Data {
-    export interface TransactionRequest {
-      authorization_list?: Array<TransactionRequest.AuthorizationList>;
+/**
+ * Data returned by the EVM `secp256k1_sign` RPC.
+ */
+export interface EthereumSecp256k1SignRpcResponseData {
+  encoding: 'hex';
 
-      chain_id?: string | number;
+  /**
+   * A hex-encoded string prefixed with '0x'.
+   */
+  signature: Hex;
+}
 
-      data?: string;
+/**
+ * Response to the EVM `secp256k1_sign` RPC.
+ */
+export interface EthereumSecp256k1SignRpcResponse {
+  /**
+   * Data returned by the EVM `secp256k1_sign` RPC.
+   */
+  data: EthereumSecp256k1SignRpcResponseData;
 
-      from?: string;
+  method: 'secp256k1_sign';
+}
 
-      gas_limit?: string | number;
+/**
+ * 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;
+}
 
-      gas_price?: string | number;
+/**
+ * Response to the EVM `eth_sign7702Authorization` RPC.
+ */
+export interface EthereumSign7702AuthorizationRpcResponse {
+  /**
+   * Data returned by the EVM `eth_sign7702Authorization` RPC.
+   */
+  data: EthereumSign7702AuthorizationRpcResponseData;
 
-      max_fee_per_gas?: string | number;
+  method: 'eth_sign7702Authorization';
+}
 
-      max_priority_fee_per_gas?: string | number;
+/**
+ * Data returned by the EVM `eth_signUserOperation` RPC.
+ */
+export interface EthereumSignUserOperationRpcResponseData {
+  encoding: 'hex';
 
-      nonce?: string | number;
+  signature: string;
+}
 
-      to?: string;
+/**
+ * Response to the EVM `eth_signUserOperation` RPC.
+ */
+export interface EthereumSignUserOperationRpcResponse {
+  /**
+   * Data returned by the EVM `eth_signUserOperation` RPC.
+   */
+  data: EthereumSignUserOperationRpcResponseData;
 
-      type?: 0 | 1 | 2 | 4;
+  method: 'eth_signUserOperation';
+}
 
-      value?: string | number;
-    }
+/**
+ * Data returned by the `wallet_sendCalls` RPC.
+ */
+export interface EthereumSendCallsRpcResponseData {
+  /**
+   * A valid CAIP-2 chain ID (e.g. 'eip155:1').
+   */
+  caip2: AppsAPI.Caip2;
 
-    export namespace TransactionRequest {
-      export interface AuthorizationList {
-        chain_id: string | number;
+  transaction_id: string;
+}
 
-        contract: string;
+/**
+ * Response to the `wallet_sendCalls` RPC.
+ */
+export interface EthereumSendCallsRpcResponse {
+  /**
+   * Data returned by the `wallet_sendCalls` RPC.
+   */
+  data: EthereumSendCallsRpcResponseData;
 
-        nonce: string | number;
+  method: 'wallet_sendCalls';
+}
 
-        r: string;
+/**
+ * Response body for Ethereum wallet RPC operations, discriminated by method.
+ */
+export type EthereumRpcResponse =
+  | EthereumPersonalSignRpcResponse
+  | EthereumSignTypedDataRpcResponse
+  | EthereumSignTransactionRpcResponse
+  | EthereumSendTransactionRpcResponse
+  | EthereumSignUserOperationRpcResponse
+  | EthereumSign7702AuthorizationRpcResponse
+  | EthereumSecp256k1SignRpcResponse
+  | EthereumSendCallsRpcResponse;
 
-        s: string;
+/**
+ * Parameters for the SVM `signTransaction` RPC.
+ */
+export interface SolanaSignTransactionRpcInputParams {
+  encoding: 'base64';
 
-        y_parity: number;
-      }
-    }
-  }
+  transaction: string;
 }
 
 /**
- * Response to the EVM `personal_sign` RPC.
+ * Executes the SVM `signTransaction` RPC to sign a transaction.
  */
-export interface EthereumPersonalSignRpcResponse {
-  data: EthereumPersonalSignRpcResponse.Data;
+export interface SolanaSignTransactionRpcInput {
+  method: 'signTransaction';
 
-  method: 'personal_sign';
-}
+  /**
+   * Parameters for the SVM `signTransaction` RPC.
+   */
+  params: SolanaSignTransactionRpcInputParams;
 
-export namespace EthereumPersonalSignRpcResponse {
-  export interface Data {
-    encoding: 'hex';
+  address?: string;
 
-    signature: string;
-  }
+  chain_type?: 'solana';
+
+  wallet_id?: string;
 }
 
 /**
- * Response to the EVM `eth_signTypedData_v4` RPC.
+ * Parameters for the SVM `signAndSendTransaction` RPC.
  */
-export interface EthereumSignTypedDataRpcResponse {
-  data: EthereumSignTypedDataRpcResponse.Data;
-
-  method: 'eth_signTypedData_v4';
-}
-
-export namespace EthereumSignTypedDataRpcResponse {
-  export interface Data {
-    encoding: 'hex';
+export interface SolanaSignAndSendTransactionRpcInputParams {
+  encoding: 'base64';
 
-    signature: string;
-  }
+  transaction: string;
 }
 
 /**
- * Response to the EVM `eth_signUserOperation` RPC.
+ * Executes the SVM `signAndSendTransaction` RPC to sign and broadcast a
+ * transaction.
  */
-export interface EthereumSignUserOperationRpcResponse {
-  data: EthereumSignUserOperationRpcResponse.Data;
+export interface SolanaSignAndSendTransactionRpcInput {
+  /**
+   * A valid CAIP-2 chain ID (e.g. 'eip155:1').
+   */
+  caip2: AppsAPI.Caip2;
 
-  method: 'eth_signUserOperation';
-}
+  method: 'signAndSendTransaction';
 
-export namespace EthereumSignUserOperationRpcResponse {
-  export interface Data {
-    encoding: 'hex';
+  /**
+   * Parameters for the SVM `signAndSendTransaction` RPC.
+   */
+  params: SolanaSignAndSendTransactionRpcInputParams;
 
-    signature: string;
-  }
+  address?: string;
+
+  chain_type?: 'solana';
+
+  reference_id?: string;
+
+  sponsor?: boolean;
+
+  wallet_id?: string;
 }
 
 /**
- * Response to the EVM `eth_sign7702Authorization` RPC.
+ * Parameters for the SVM `signMessage` RPC.
  */
-export interface EthereumSign7702AuthorizationRpcResponse {
-  data: EthereumSign7702AuthorizationRpcResponse.Data;
+export interface SolanaSignMessageRpcInputParams {
+  encoding: 'base64';
 
-  method: 'eth_sign7702Authorization';
+  message: string;
 }
 
-export namespace EthereumSign7702AuthorizationRpcResponse {
-  export interface Data {
-    authorization: Data.Authorization;
-  }
-
-  export namespace Data {
-    export interface Authorization {
-      chain_id: string | number;
-
-      contract: string;
+/**
+ * Executes the SVM `signMessage` RPC to sign a message.
+ */
+export interface SolanaSignMessageRpcInput {
+  method: 'signMessage';
 
-      nonce: string | number;
+  /**
+   * Parameters for the SVM `signMessage` RPC.
+   */
+  params: SolanaSignMessageRpcInputParams;
 
-      r: string;
+  address?: string;
 
-      s: string;
+  chain_type?: 'solana';
 
-      y_parity: number;
-    }
-  }
+  wallet_id?: string;
 }
 
 /**
- * Response to the EVM `secp256k1_sign` RPC.
+ * Request body for Solana wallet RPC operations, discriminated by method.
  */
-export interface EthereumSecp256k1SignRpcResponse {
-  data: EthereumSecp256k1SignRpcResponse.Data;
-
-  method: 'secp256k1_sign';
-}
+export type SolanaRpcInput =
+  | SolanaSignTransactionRpcInput
+  | SolanaSignAndSendTransactionRpcInput
+  | SolanaSignMessageRpcInput;
 
-export namespace EthereumSecp256k1SignRpcResponse {
-  export interface Data {
-    encoding: 'hex';
+/**
+ * Data returned by the SVM `signTransaction` RPC.
+ */
+export interface SolanaSignTransactionRpcResponseData {
+  encoding: 'base64';
 
-    signature: string;
-  }
+  signed_transaction: string;
 }
 
 /**
  * Response to the SVM `signTransaction` RPC.
  */
 export interface SolanaSignTransactionRpcResponse {
-  data: SolanaSignTransactionRpcResponse.Data;
+  /**
+   * Data returned by the SVM `signTransaction` RPC.
+   */
+  data: SolanaSignTransactionRpcResponseData;
 
   method: 'signTransaction';
 }
 
-export namespace SolanaSignTransactionRpcResponse {
-  export interface Data {
-    encoding: 'base64';
+/**
+ * Data returned by the SVM `signAndSendTransaction` RPC.
+ */
+export interface SolanaSignAndSendTransactionRpcResponseData {
+  /**
+   * A valid CAIP-2 chain ID (e.g. 'eip155:1').
+   */
+  caip2: AppsAPI.Caip2;
 
-    signed_transaction: string;
-  }
+  hash: string;
+
+  reference_id?: string | null;
+
+  transaction_id?: string;
 }
 
 /**
  * Response to the SVM `signAndSendTransaction` RPC.
  */
 export interface SolanaSignAndSendTransactionRpcResponse {
-  data: SolanaSignAndSendTransactionRpcResponse.Data;
+  /**
+   * Data returned by the SVM `signAndSendTransaction` RPC.
+   */
+  data: SolanaSignAndSendTransactionRpcResponseData;
 
   method: 'signAndSendTransaction';
 }
 
-export namespace SolanaSignAndSendTransactionRpcResponse {
-  export interface Data {
-    caip2: string;
-
-    hash: string;
+/**
+ * Data returned by the SVM `signMessage` RPC.
+ */
+export interface SolanaSignMessageRpcResponseData {
+  encoding: 'base64';
 
-    transaction_id?: string;
-  }
+  signature: string;
 }
 
 /**
  * Response to the SVM `signMessage` RPC.
  */
 export interface SolanaSignMessageRpcResponse {
-  data: SolanaSignMessageRpcResponse.Data;
+  /**
+   * Data returned by the SVM `signMessage` RPC.
+   */
+  data: SolanaSignMessageRpcResponseData;
 
   method: 'signMessage';
 }
 
-export namespace SolanaSignMessageRpcResponse {
-  export interface Data {
-    encoding: 'base64';
+/**
+ * Response body for Solana wallet RPC operations, discriminated by method.
+ */
+export type SolanaRpcResponse =
+  | SolanaSignMessageRpcResponse
+  | SolanaSignTransactionRpcResponse
+  | SolanaSignAndSendTransactionRpcResponse;
 
-    signature: string;
-  }
+/**
+ * The Spark network.
+ */
+export type SparkNetwork = 'MAINNET' | 'REGTEST';
+
+/**
+ * A Spark signing keyshare.
+ */
+export interface SparkSigningKeyshare {
+  owner_identifiers: Array<string>;
+
+  public_key: string;
+
+  public_shares: { [key: string]: string };
+
+  threshold: number;
+
+  updated_time: string;
 }
 
-export interface WalletExportResponse {
-  /**
-   * The encrypted private key.
-   */
-  ciphertext: string;
+/**
+ * A Spark wallet leaf node.
+ */
+export interface SparkWalletLeaf {
+  id: string;
 
   /**
-   * The base64-encoded encapsulated key that was generated during encryption, for
-   * use during decryption.
+   * The Spark network.
    */
-  encapsulated_key: string;
+  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;
 
   /**
-   * The encryption type of the wallet to import. Currently only supports `HPKE`.
+   * A Spark signing keyshare.
    */
-  encryption_type: 'HPKE';
+  signing_keyshare?: SparkSigningKeyshare;
 }
 
-export interface WalletInitImportResponse {
-  /**
-   * The base64-encoded encryption public key to encrypt the wallet entropy with.
-   */
-  encryption_public_key: string;
+/**
+ * A Spark transfer leaf.
+ */
+export interface SparkTransferLeaf {
+  intermediate_refund_tx: string;
+
+  secret_cipher: string;
+
+  signature: string;
 
   /**
-   * The encryption type of the wallet to import. Currently only supports `HPKE`.
+   * A Spark wallet leaf node.
    */
-  encryption_type: 'HPKE';
+  leaf?: SparkWalletLeaf;
 }
 
-export interface WalletRawSignResponse {
-  data: WalletRawSignResponse.Data;
+/**
+ * A Spark transfer.
+ */
+export interface SparkTransfer {
+  id: string;
 
-  method: 'raw_sign';
-}
+  leaves: Array<SparkTransferLeaf>;
 
-export namespace WalletRawSignResponse {
-  export interface Data {
-    encoding: 'hex';
+  receiver_identity_public_key: string;
 
-    signature: 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;
 }
 
 /**
- * Response to the EVM `personal_sign` RPC.
+ * 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;
+}
+
+/**
+ * Balance of a Spark token.
+ */
+export interface SparkTokenBalance {
+  balance: string;
+
+  /**
+   * Metadata for a Spark user token.
+   */
+  token_metadata: SparkUserTokenMetadata;
+}
+
+/**
+ * The balance of a Spark wallet.
+ */
+export interface SparkBalance {
+  balance: string;
+
+  token_balances: { [key: string]: SparkTokenBalance };
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Parameters for the Spark `transfer` RPC.
+ */
+export interface SparkTransferRpcInputParams {
+  amount_sats: number;
+
+  receiver_spark_address: string;
+}
+
+/**
+ * Transfers satoshis to a Spark address.
+ */
+export interface SparkTransferRpcInput {
+  method: 'transfer';
+
+  /**
+   * Parameters for the Spark `transfer` RPC.
+   */
+  params: SparkTransferRpcInputParams;
+
+  /**
+   * The Spark network.
+   */
+  network?: SparkNetwork;
+}
+
+/**
+ * Gets the balance of the Spark wallet.
+ */
+export interface SparkGetBalanceRpcInput {
+  method: 'getBalance';
+
+  /**
+   * The Spark network.
+   */
+  network?: SparkNetwork;
+}
+
+/**
+ * Strategy for selecting outputs in a Spark token transfer.
+ */
+export type SparkOutputSelectionStrategy = 'SMALL_FIRST' | 'LARGE_FIRST';
+
+/**
+ * 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>;
+}
+
+/**
+ * Transfers tokens to a Spark address.
+ */
+export interface SparkTransferTokensRpcInput {
+  method: 'transferTokens';
+
+  /**
+   * Parameters for the Spark `transferTokens` RPC.
+   */
+  params: SparkTransferTokensRpcInputParams;
+
+  /**
+   * The Spark network.
+   */
+  network?: SparkNetwork;
+}
+
+/**
+ * Gets a static deposit address for the Spark wallet.
+ */
+export interface SparkGetStaticDepositAddressRpcInput {
+  method: 'getStaticDepositAddress';
+
+  /**
+   * The Spark network.
+   */
+  network?: SparkNetwork;
+}
+
+/**
+ * Parameters for the Spark `getClaimStaticDepositQuote` RPC.
+ */
+export interface SparkGetClaimStaticDepositQuoteRpcInputParams {
+  transaction_id: string;
+
+  output_index?: number;
+}
+
+/**
+ * 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 `claimStaticDeposit` RPC.
+ */
+export interface SparkClaimStaticDepositRpcInputParams {
+  credit_amount_sats: number;
+
+  signature: string;
+
+  transaction_id: string;
+
+  output_index?: number;
+}
+
+/**
+ * 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 `createLightningInvoice` RPC.
+ */
+export interface SparkCreateLightningInvoiceRpcInputParams {
+  amount_sats: number;
+
+  description_hash?: string;
+
+  expiry_seconds?: number;
+
+  include_spark_address?: boolean;
+
+  memo?: string;
+
+  receiver_identity_pubkey?: 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 `payLightningInvoice` RPC.
+ */
+export interface SparkPayLightningInvoiceRpcInputParams {
+  invoice: string;
+
+  max_fee_sats: number;
+
+  amount_sats_to_send?: number;
+
+  prefer_spark?: boolean;
+}
+
+/**
+ * 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 `signMessageWithIdentityKey` RPC.
+ */
+export interface SparkSignMessageWithIdentityKeyRpcInputParams {
+  message: string;
+
+  compact?: boolean;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Request body for Spark wallet RPC operations, discriminated by method.
+ */
+export type SparkRpcInput =
+  | SparkTransferRpcInput
+  | SparkGetBalanceRpcInput
+  | SparkTransferTokensRpcInput
+  | SparkGetStaticDepositAddressRpcInput
+  | SparkGetClaimStaticDepositQuoteRpcInput
+  | SparkClaimStaticDepositRpcInput
+  | SparkCreateLightningInvoiceRpcInput
+  | SparkPayLightningInvoiceRpcInput
+  | SparkSignMessageWithIdentityKeyRpcInput;
+
+/**
+ * Response to the Spark `transfer` RPC.
+ */
+export interface SparkTransferRpcResponse {
+  method: 'transfer';
+
+  /**
+   * A Spark transfer.
+   */
+  data?: SparkTransfer;
+}
+
+/**
+ * Response to the Spark `getBalance` RPC.
+ */
+export interface SparkGetBalanceRpcResponse {
+  method: 'getBalance';
+
+  /**
+   * The balance of a Spark wallet.
+   */
+  data?: SparkBalance;
+}
+
+/**
+ * Data returned by the Spark `transferTokens` RPC.
+ */
+export interface SparkTransferTokensRpcResponseData {
+  id: string;
+}
+
+/**
+ * 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 `getStaticDepositAddress` RPC.
+ */
+export interface SparkGetStaticDepositAddressRpcResponseData {
+  address: string;
+}
+
+/**
+ * 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 `getClaimStaticDepositQuote` RPC.
+ */
+export interface SparkGetClaimStaticDepositQuoteRpcResponseData {
+  credit_amount_sats: number;
+
+  network: string;
+
+  output_index: number;
+
+  signature: string;
+
+  transaction_id: string;
+}
+
+/**
+ * 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 `claimStaticDeposit` RPC.
+ */
+export interface SparkClaimStaticDepositRpcResponseData {
+  transfer_id: string;
+}
+
+/**
+ * Response to the Spark `claimStaticDeposit` RPC.
+ */
+export interface SparkClaimStaticDepositRpcResponse {
+  method: 'claimStaticDeposit';
+
+  /**
+   * Data returned by the Spark `claimStaticDeposit` RPC.
+   */
+  data?: SparkClaimStaticDepositRpcResponseData;
+}
+
+/**
+ * Response to the Spark `createLightningInvoice` RPC.
+ */
+export interface SparkCreateLightningInvoiceRpcResponse {
+  method: 'createLightningInvoice';
+
+  /**
+   * A Spark Lightning receive request.
+   */
+  data?: SparkLightningReceiveRequest;
+}
+
+/**
+ * Response to the Spark `payLightningInvoice` RPC.
+ */
+export interface SparkPayLightningInvoiceRpcResponse {
+  method: 'payLightningInvoice';
+
+  /**
+   * A Spark transfer.
+   */
+  data?: SparkTransfer | SparkLightningSendRequest;
+}
+
+/**
+ * Data returned by the Spark `signMessageWithIdentityKey` RPC.
+ */
+export interface SparkSignMessageWithIdentityKeyRpcResponseData {
+  signature: string;
+}
+
+/**
+ * Response to the Spark `signMessageWithIdentityKey` RPC.
+ */
+export interface SparkSignMessageWithIdentityKeyRpcResponse {
+  method: 'signMessageWithIdentityKey';
+
+  /**
+   * Data returned by the Spark `signMessageWithIdentityKey` RPC.
+   */
+  data?: SparkSignMessageWithIdentityKeyRpcResponseData;
+}
+
+/**
+ * Response body for Spark wallet RPC operations, discriminated by method.
+ */
+export type SparkRpcResponse =
+  | SparkTransferRpcResponse
+  | SparkGetBalanceRpcResponse
+  | SparkTransferTokensRpcResponse
+  | SparkGetStaticDepositAddressRpcResponse
+  | SparkGetClaimStaticDepositQuoteRpcResponse
+  | SparkClaimStaticDepositRpcResponse
+  | SparkCreateLightningInvoiceRpcResponse
+  | SparkPayLightningInvoiceRpcResponse
+  | SparkSignMessageWithIdentityKeyRpcResponse;
+
+/**
+ * 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>;
+
+  /**
+   * 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;
+
+  /**
+   * A customer-provided identifier for mapping to external systems. Write-once, set
+   * only at creation.
+   */
+  external_id?: string;
+
+  /**
+   * The compressed, raw public key for the wallet along the chain cryptographic
+   * curve.
+   */
+  public_key?: string;
+}
+
+/**
+ * Request body for looking up a wallet by its blockchain address.
+ */
+export interface GetByWalletAddressRequestBody {
+  /**
+   * A blockchain wallet address (Ethereum or Solana).
+   */
+  address: Address;
+}
+
+/**
+ * Request body for updating a wallet.
+ */
+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;
+
+  /**
+   * 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>;
+}
+
+/**
+ * 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;
+
+  /**
+   * 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>;
+}
+
+/**
+ * Request body for batch wallet creation.
+ */
+export interface WalletBatchCreateInput {
+  /**
+   * Array of wallet creation requests. Minimum 1, maximum 100.
+   */
+  wallets: Array<WalletBatchItemInput>;
+}
+
+/**
+ * A single result from a batch wallet creation operation.
+ */
+export type WalletBatchCreateResult =
+  | WalletBatchCreateResult.WalletBatchCreateSuccess
+  | WalletBatchCreateResult.WalletBatchCreateFailure;
+
+export namespace WalletBatchCreateResult {
+  /**
+   * A successful wallet creation result within a batch operation.
+   */
+  export 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.
+   */
+  export 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;
+  }
+}
+
+/**
+ * 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>;
+}
+
+/**
+ * Request body for wallet RPC operations, discriminated by method.
+ */
+export type WalletRpcRequestBody =
+  | EthereumSignTransactionRpcInput
+  | EthereumSendTransactionRpcInput
+  | EthereumPersonalSignRpcInput
+  | EthereumSignTypedDataRpcInput
+  | EthereumSecp256k1SignRpcInput
+  | EthereumSign7702AuthorizationRpcInput
+  | EthereumSignUserOperationRpcInput
+  | EthereumSendCallsRpcInput
+  | SolanaSignTransactionRpcInput
+  | SolanaSignAndSendTransactionRpcInput
+  | SolanaSignMessageRpcInput
+  | SparkTransferRpcInput
+  | SparkGetBalanceRpcInput
+  | SparkTransferTokensRpcInput
+  | SparkGetStaticDepositAddressRpcInput
+  | SparkGetClaimStaticDepositQuoteRpcInput
+  | SparkClaimStaticDepositRpcInput
+  | SparkCreateLightningInvoiceRpcInput
+  | SparkPayLightningInvoiceRpcInput
+  | SparkSignMessageWithIdentityKeyRpcInput
+  | ExportPrivateKeyRpcInput
+  | ExportSeedPhraseRpcInput;
+
+/**
+ * Response body for wallet RPC operations, discriminated by method.
  */
 export type WalletRpcResponse =
   | EthereumPersonalSignRpcResponse
@@ -1309,9 +2604,206 @@ export type WalletRpcResponse =
   | EthereumSignUserOperationRpcResponse
   | EthereumSign7702AuthorizationRpcResponse
   | EthereumSecp256k1SignRpcResponse
+  | EthereumSendCallsRpcResponse
   | SolanaSignMessageRpcResponse
   | SolanaSignTransactionRpcResponse
-  | SolanaSignAndSendTransactionRpcResponse;
+  | SolanaSignAndSendTransactionRpcResponse
+  | SparkTransferRpcResponse
+  | SparkGetBalanceRpcResponse
+  | SparkTransferTokensRpcResponse
+  | SparkGetStaticDepositAddressRpcResponse
+  | SparkGetClaimStaticDepositQuoteRpcResponse
+  | SparkClaimStaticDepositRpcResponse
+  | SparkCreateLightningInvoiceRpcResponse
+  | SparkPayLightningInvoiceRpcResponse
+  | SparkSignMessageWithIdentityKeyRpcResponse
+  | ExportPrivateKeyRpcResponse
+  | ExportSeedPhraseRpcResponse;
+
+/**
+ * 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 source asset, amount, and chain for a token transfer.
+ */
+export interface TokenTransferSource {
+  /**
+   * 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). Not in the smallest on-chain unit (wei, lamports,
+   * etc.).
+   */
+  amount: string;
+
+  /**
+   * The asset to transfer. Supported: 'usdc', 'usdb', 'usdt' (stablecoins), 'eth'
+   * (native Ethereum), 'sol' (native Solana).
+   */
+  asset: string;
+
+  /**
+   * The blockchain network on which to perform the transfer. Supported chains
+   * include: 'ethereum', 'base', 'arbitrum', 'polygon', 'solana', and their
+   * respective testnets.
+   */
+  chain: string;
+}
+
+/**
+ * The destination address for a token transfer.
+ */
+export interface TokenTransferDestination {
+  /**
+   * Recipient address (hex for EVM, base58 for Solana)
+   */
+  address: string;
+}
+
+/**
+ * Request body for initiating a sponsored token transfer from an embedded wallet.
+ */
+export interface CreateTokenTransferRequest {
+  /**
+   * The destination address for a token transfer.
+   */
+  destination: TokenTransferDestination;
+
+  /**
+   * The source asset, amount, and chain for a token transfer.
+   */
+  source: TokenTransferSource;
+}
+
+/**
+ * SUI transaction commands allowlist for raw_sign endpoint policy evaluation
+ */
+export type SuiCommandName = 'TransferObjects' | 'SplitCoins' | 'MergeCoins';
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+
+export interface WalletExportResponse {
+  /**
+   * 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;
+}
+
+export interface WalletInitImportResponse {
+  /**
+   * The base64-encoded encryption public key to encrypt the wallet entropy with.
+   */
+  encryption_public_key: string;
+
+  /**
+   * The encryption type of the wallet to import. Currently only supports `HPKE`.
+   */
+  encryption_type: HpkeEncryption;
+}
 
 export type WalletAuthenticateWithJwtResponse =
   | WalletAuthenticateWithJwtResponse.WithEncryption
@@ -1392,62 +2884,42 @@ export interface WalletCreateParams {
   /**
    * Body param: Additional signers for the wallet.
    */
-  additional_signers?: Array<WalletCreateParams.AdditionalSigner>;
+  additional_signers?: AdditionalSignerInput;
 
   /**
-   * Body param: The owner of the resource. If you provide this, do not specify an
-   * owner_id as it will be generated automatically. When updating a wallet, you can
-   * set the owner to null to remove the owner.
+   * Body param: A human-readable label for the wallet.
    */
-  owner?: WalletCreateParams.PublicKeyOwner | WalletCreateParams.UserOwner | null;
+  display_name?: string;
 
   /**
-   * Body param: The key quorum ID to set as the owner of the resource. If you
-   * provide this, do not specify an owner.
+   * 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.
    */
-  owner_id?: string;
+  external_id?: string;
 
   /**
-   * Body param: List of policy IDs for policies that should be enforced on the
-   * wallet. Currently, only one policy is supported per wallet.
+   * 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.
    */
-  policy_ids?: Array<string>;
+  owner?: SharedAPI.OwnerInput | null;
 
   /**
-   * Header param: Idempotency keys ensure API requests are executed only once within
-   * a 24-hour window.
+   * Body param: The key quorum ID to set as the owner of the resource. If you
+   * provide this, do not specify an owner.
    */
-  'privy-idempotency-key'?: string;
-}
-
-export namespace WalletCreateParams {
-  export interface AdditionalSigner {
-    signer_id: string;
-
-    /**
-     * The array of policy IDs that will be applied to wallet requests. If specified,
-     * this will override the base policy IDs set on the wallet.
-     */
-    override_policy_ids?: Array<string>;
-  }
+  owner_id?: SharedAPI.OwnerIDInput | null;
 
   /**
-   * The P-256 public key of the owner of the resource, in base64-encoded DER format.
-   * If you provide this, do not specify an owner_id as it will be generated
-   * automatically.
+   * Body param: An optional list of up to one policy ID to enforce on the wallet.
    */
-  export interface PublicKeyOwner {
-    public_key: string;
-  }
+  policy_ids?: PolicyInput;
 
   /**
-   * The user ID of the owner of the resource. The user must already exist, and this
-   * value must start with "did:privy:". If you provide this, do not specify an
-   * owner_id as it will be generated automatically.
+   * Header param: Idempotency keys ensure API requests are executed only once within
+   * a 24-hour window.
    */
-  export interface UserOwner {
-    user_id: string;
-  }
+  'privy-idempotency-key'?: string;
 }
 
 export interface WalletListParams extends CursorParams {
@@ -1463,6 +2935,11 @@ export interface WalletListParams extends CursorParams {
    */
   chain_type?: WalletChainType;
 
+  /**
+   * Filter wallets by external ID.
+   */
+  external_id?: string;
+
   /**
    * Filter wallets by user ID. Cannot be used together with authorization_key.
    */
@@ -1474,7 +2951,7 @@ export interface WalletExportParams {
    * Body param: The encryption type of the wallet to import. Currently only supports
    * `HPKE`.
    */
-  encryption_type: 'HPKE';
+  encryption_type: HpkeEncryption;
 
   /**
    * Body param: The base64-encoded encryption public key to encrypt the wallet
@@ -1482,141 +2959,378 @@ export interface WalletExportParams {
    */
   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 type WalletInitImportParams =
   | WalletInitImportParams.HDInitInput
   | WalletInitImportParams.PrivateKeyInitInput;
 
-export declare namespace WalletInitImportParams {
-  export interface HDInitInput {
+export declare namespace WalletInitImportParams {
+  export interface HDInitInput {
+    /**
+     * The address of the wallet to import.
+     */
+    address: string;
+
+    /**
+     * The chain type of the wallet to import. Currently supports `ethereum` and
+     * `solana`.
+     */
+    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;
+  }
+
+  export interface PrivateKeyInitInput {
+    /**
+     * The address of the wallet to import.
+     */
+    address: string;
+
+    /**
+     * The chain type of the wallet to import. Currently supports `ethereum` and
+     * `solana`.
+     */
+    chain_type: WalletImportSupportedChains;
+
+    /**
+     * The encryption type of the wallet to import. Currently only supports `HPKE`.
+     */
+    encryption_type: HpkeEncryption;
+
+    entropy_type: 'private-key';
+  }
+}
+
+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.SolanaSignTransactionRpcInput
+  | WalletRpcParams.SolanaSignAndSendTransactionRpcInput
+  | WalletRpcParams.SolanaSignMessageRpcInput
+  | WalletRpcParams.SparkTransferRpcInput
+  | WalletRpcParams.SparkGetBalanceRpcInput
+  | WalletRpcParams.SparkTransferTokensRpcInput
+  | WalletRpcParams.SparkGetStaticDepositAddressRpcInput
+  | WalletRpcParams.SparkGetClaimStaticDepositQuoteRpcInput
+  | WalletRpcParams.SparkClaimStaticDepositRpcInput
+  | WalletRpcParams.SparkCreateLightningInvoiceRpcInput
+  | WalletRpcParams.SparkPayLightningInvoiceRpcInput
+  | WalletRpcParams.SparkSignMessageWithIdentityKeyRpcInput
+  | WalletRpcParams.ExportPrivateKeyRpcInput
+  | WalletRpcParams.ExportSeedPhraseRpcInput;
+
+export declare namespace WalletRpcParams {
+  export 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;
+  }
+
+  export interface EthereumSendTransactionRpcInput {
+    /**
+     * Body param: A valid CAIP-2 chain ID (e.g. 'eip155:1').
+     */
+    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
+     */
+    reference_id?: string;
+
+    /**
+     * Body param
+     */
+    sponsor?: boolean;
+
+    /**
+     * 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;
+  }
+
+  export interface EthereumPersonalSignRpcInput {
+    /**
+     * Body param
+     */
+    method: 'personal_sign';
+
+    /**
+     * Body param: Parameters for the EVM `personal_sign` RPC.
+     */
+    params: EthereumPersonalSignRpcInputParams;
+
+    /**
+     * 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;
+  }
+
+  export interface EthereumSignTypedDataRpcInput {
+    /**
+     * Body param
+     */
+    method: 'eth_signTypedData_v4';
+
     /**
-     * The address of the wallet to import.
+     * Body param: Parameters for the EVM `eth_signTypedData_v4` RPC.
      */
-    address: string;
+    params: EthereumSignTypedDataRpcInputParams;
 
     /**
-     * The chain type of the wallet to import. Currently supports `ethereum` and
-     * `solana`.
+     * Body param
      */
-    chain_type: 'ethereum' | 'solana';
+    address?: string;
 
     /**
-     * The encryption type of the wallet to import. Currently only supports `HPKE`.
+     * Body param
      */
-    encryption_type: 'HPKE';
+    chain_type?: 'ethereum';
 
     /**
-     * The entropy type of the wallet to import.
+     * Body param
      */
-    entropy_type: 'hd';
+    wallet_id?: string;
 
     /**
-     * The index of the wallet to import.
+     * Header param: Request authorization signature. If multiple signatures are
+     * required, they should be comma separated.
      */
-    index: number;
-  }
+    'privy-authorization-signature'?: string;
 
-  export interface PrivateKeyInitInput {
     /**
-     * The address of the wallet to import.
+     * Header param: Idempotency keys ensure API requests are executed only once within
+     * a 24-hour window.
      */
-    address: string;
+    'privy-idempotency-key'?: string;
 
     /**
-     * The chain type of the wallet to import. Currently supports `ethereum` and
-     * `solana`.
+     * Header param: Request expiry. Value is a Unix timestamp in milliseconds
+     * representing the deadline by which the request must be processed.
      */
-    chain_type: 'ethereum' | 'solana';
+    'privy-request-expiry'?: string;
+  }
 
+  export interface EthereumSecp256k1SignRpcInput {
     /**
-     * The encryption type of the wallet to import. Currently only supports `HPKE`.
+     * Body param
      */
-    encryption_type: 'HPKE';
-
-    entropy_type: 'private-key';
-  }
-}
+    method: 'secp256k1_sign';
 
-export interface WalletRawSignParams {
-  /**
-   * Body param: Sign a pre-computed hash
-   */
-  params: WalletRawSignParams.Hash | WalletRawSignParams.Bytes;
+    /**
+     * Body param: Parameters for the EVM `secp256k1_sign` RPC.
+     */
+    params: EthereumSecp256k1SignRpcInputParams;
 
-  /**
-   * Header param: Request authorization signature. If multiple signatures are
-   * required, they should be comma separated.
-   */
-  'privy-authorization-signature'?: string;
+    /**
+     * Body param
+     */
+    address?: string;
 
-  /**
-   * Header param: Idempotency keys ensure API requests are executed only once within
-   * a 24-hour window.
-   */
-  'privy-idempotency-key'?: string;
-}
+    /**
+     * Body param
+     */
+    chain_type?: 'ethereum';
 
-export namespace WalletRawSignParams {
-  /**
-   * Sign a pre-computed hash
-   */
-  export interface Hash {
     /**
-     * The hash to sign. Must start with `0x`.
+     * Body param
      */
-    hash: string;
-  }
+    wallet_id?: string;
 
-  /**
-   * Hash and sign bytes using the specified encoding and hash function.
-   */
-  export interface Bytes {
     /**
-     * The bytes to hash and sign.
+     * Header param: Request authorization signature. If multiple signatures are
+     * required, they should be comma separated.
      */
-    bytes: string;
+    'privy-authorization-signature'?: string;
 
     /**
-     * The encoding scheme for the bytes.
+     * Header param: Idempotency keys ensure API requests are executed only once within
+     * a 24-hour window.
      */
-    encoding: 'utf-8' | 'hex' | 'base64';
+    'privy-idempotency-key'?: string;
 
     /**
-     * The hash function to hash the bytes.
+     * Header param: Request expiry. Value is a Unix timestamp in milliseconds
+     * representing the deadline by which the request must be processed.
      */
-    hash_function: 'keccak256' | 'sha256' | 'blake2b256';
+    'privy-request-expiry'?: string;
   }
-}
-
-export type WalletRpcParams =
-  | WalletRpcParams.EthereumPersonalSignRpcInput
-  | WalletRpcParams.EthereumSignTypedDataRpcInput
-  | WalletRpcParams.EthereumSignTransactionRpcInput
-  | WalletRpcParams.EthereumSignUserOperationRpcInput
-  | WalletRpcParams.EthereumSendTransactionRpcInput
-  | WalletRpcParams.EthereumSign7702AuthorizationRpcInput
-  | WalletRpcParams.EthereumSecp256k1SignRpcInput
-  | WalletRpcParams.SolanaSignMessageRpcInput
-  | WalletRpcParams.SolanaSignTransactionRpcInput
-  | WalletRpcParams.SolanaSignAndSendTransactionRpcInput;
 
-export declare namespace WalletRpcParams {
-  export interface EthereumPersonalSignRpcInput {
+  export interface EthereumSign7702AuthorizationRpcInput {
     /**
      * Body param
      */
-    method: 'personal_sign';
+    method: 'eth_sign7702Authorization';
 
     /**
-     * Body param
+     * Body param: Parameters for the EVM `eth_sign7702Authorization` RPC.
      */
-    params: EthereumPersonalSignRpcInput.Params;
+    params: EthereumSign7702AuthorizationRpcInputParams;
 
     /**
      * Body param
@@ -1628,6 +3342,11 @@ export declare namespace WalletRpcParams {
      */
     chain_type?: 'ethereum';
 
+    /**
+     * Body param
+     */
+    wallet_id?: string;
+
     /**
      * Header param: Request authorization signature. If multiple signatures are
      * required, they should be comma separated.
@@ -1639,26 +3358,24 @@ export declare namespace WalletRpcParams {
      * a 24-hour window.
      */
     'privy-idempotency-key'?: string;
-  }
 
-  export namespace EthereumPersonalSignRpcInput {
-    export interface Params {
-      encoding: 'utf-8' | 'hex';
-
-      message: 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 EthereumSignTypedDataRpcInput {
+  export interface EthereumSignUserOperationRpcInput {
     /**
      * Body param
      */
-    method: 'eth_signTypedData_v4';
+    method: 'eth_signUserOperation';
 
     /**
-     * Body param
+     * Body param: Parameters for the EVM `eth_signUserOperation` RPC.
      */
-    params: EthereumSignTypedDataRpcInput.Params;
+    params: EthereumSignUserOperationRpcInputParams;
 
     /**
      * Body param
@@ -1670,6 +3387,11 @@ export declare namespace WalletRpcParams {
      */
     chain_type?: 'ethereum';
 
+    /**
+     * Body param
+     */
+    wallet_id?: string;
+
     /**
      * Header param: Request authorization signature. If multiple signatures are
      * required, they should be comma separated.
@@ -1681,44 +3403,79 @@ export declare namespace WalletRpcParams {
      * 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 namespace EthereumSignTypedDataRpcInput {
-    export interface Params {
-      typed_data: Params.TypedData;
-    }
+  export interface EthereumSendCallsRpcInput {
+    /**
+     * Body param: A valid CAIP-2 chain ID (e.g. 'eip155:1').
+     */
+    caip2: AppsAPI.Caip2;
+
+    /**
+     * Body param
+     */
+    method: 'wallet_sendCalls';
+
+    /**
+     * Body param: Parameters for the `wallet_sendCalls` RPC.
+     */
+    params: EthereumSendCallsRpcInputParams;
+
+    /**
+     * Body param
+     */
+    address?: string;
 
-    export namespace Params {
-      export interface TypedData {
-        domain: { [key: string]: unknown };
+    /**
+     * Body param
+     */
+    chain_type?: 'ethereum';
 
-        message: { [key: string]: unknown };
+    /**
+     * Body param
+     */
+    sponsor?: boolean;
 
-        primary_type: string;
+    /**
+     * Body param
+     */
+    wallet_id?: string;
 
-        types: { [key: string]: Array<TypedData.Type> };
-      }
+    /**
+     * Header param: Request authorization signature. If multiple signatures are
+     * required, they should be comma separated.
+     */
+    'privy-authorization-signature'?: string;
 
-      export namespace TypedData {
-        export interface Type {
-          name: string;
+    /**
+     * Header param: Idempotency keys ensure API requests are executed only once within
+     * a 24-hour window.
+     */
+    'privy-idempotency-key'?: string;
 
-          type: 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 EthereumSignTransactionRpcInput {
+  export interface SolanaSignTransactionRpcInput {
     /**
      * Body param
      */
-    method: 'eth_signTransaction';
+    method: 'signTransaction';
 
     /**
-     * Body param
+     * Body param: Parameters for the SVM `signTransaction` RPC.
      */
-    params: EthereumSignTransactionRpcInput.Params;
+    params: SolanaSignTransactionRpcInputParams;
 
     /**
      * Body param
@@ -1728,7 +3485,12 @@ export declare namespace WalletRpcParams {
     /**
      * Body param
      */
-    chain_type?: 'ethereum';
+    chain_type?: 'solana';
+
+    /**
+     * Body param
+     */
+    wallet_id?: string;
 
     /**
      * Header param: Request authorization signature. If multiple signatures are
@@ -1741,78 +3503,164 @@ export declare namespace WalletRpcParams {
      * 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 namespace EthereumSignTransactionRpcInput {
-    export interface Params {
-      transaction: Params.Transaction;
-    }
+  export interface SolanaSignAndSendTransactionRpcInput {
+    /**
+     * Body param: A valid CAIP-2 chain ID (e.g. 'eip155:1').
+     */
+    caip2: AppsAPI.Caip2;
 
-    export namespace Params {
-      export interface Transaction {
-        authorization_list?: Array<Transaction.AuthorizationList>;
+    /**
+     * Body param
+     */
+    method: 'signAndSendTransaction';
 
-        chain_id?: string | number;
+    /**
+     * Body param: Parameters for the SVM `signAndSendTransaction` RPC.
+     */
+    params: SolanaSignAndSendTransactionRpcInputParams;
 
-        data?: string;
+    /**
+     * Body param
+     */
+    address?: string;
 
-        from?: string;
+    /**
+     * Body param
+     */
+    chain_type?: 'solana';
 
-        gas_limit?: string | number;
+    /**
+     * Body param
+     */
+    reference_id?: string;
 
-        gas_price?: string | number;
+    /**
+     * Body param
+     */
+    sponsor?: boolean;
 
-        max_fee_per_gas?: string | number;
+    /**
+     * Body param
+     */
+    wallet_id?: string;
 
-        max_priority_fee_per_gas?: string | number;
+    /**
+     * Header param: Request authorization signature. If multiple signatures are
+     * required, they should be comma separated.
+     */
+    'privy-authorization-signature'?: string;
 
-        nonce?: string | number;
+    /**
+     * Header param: Idempotency keys ensure API requests are executed only once within
+     * a 24-hour window.
+     */
+    'privy-idempotency-key'?: string;
 
-        to?: 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;
+  }
 
-        type?: 0 | 1 | 2 | 4;
+  export interface SolanaSignMessageRpcInput {
+    /**
+     * Body param
+     */
+    method: 'signMessage';
 
-        value?: string | number;
-      }
+    /**
+     * Body param: Parameters for the SVM `signMessage` RPC.
+     */
+    params: SolanaSignMessageRpcInputParams;
 
-      export namespace Transaction {
-        export interface AuthorizationList {
-          chain_id: string | number;
+    /**
+     * Body param
+     */
+    address?: string;
 
-          contract: string;
+    /**
+     * Body param
+     */
+    chain_type?: 'solana';
 
-          nonce: string | number;
+    /**
+     * Body param
+     */
+    wallet_id?: string;
 
-          r: string;
+    /**
+     * Header param: Request authorization signature. If multiple signatures are
+     * required, they should be comma separated.
+     */
+    'privy-authorization-signature'?: string;
 
-          s: string;
+    /**
+     * Header param: Idempotency keys ensure API requests are executed only once within
+     * a 24-hour window.
+     */
+    'privy-idempotency-key'?: string;
 
-          y_parity: number;
-        }
-      }
-    }
+    /**
+     * 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 EthereumSignUserOperationRpcInput {
+  export interface SparkTransferRpcInput {
     /**
      * Body param
      */
-    method: 'eth_signUserOperation';
+    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;
 
     /**
-     * Body param
+     * Header param: Request expiry. Value is a Unix timestamp in milliseconds
+     * representing the deadline by which the request must be processed.
      */
-    params: EthereumSignUserOperationRpcInput.Params;
+    'privy-request-expiry'?: string;
+  }
 
+  export interface SparkGetBalanceRpcInput {
     /**
      * Body param
      */
-    address?: string;
+    method: 'getBalance';
 
     /**
-     * Body param
+     * Body param: The Spark network.
      */
-    chain_type?: 'ethereum';
+    network?: SparkNetwork;
 
     /**
      * Header param: Request authorization signature. If multiple signatures are
@@ -1825,76 +3673,59 @@ export declare namespace WalletRpcParams {
      * a 24-hour window.
      */
     'privy-idempotency-key'?: string;
-  }
-
-  export namespace EthereumSignUserOperationRpcInput {
-    export interface Params {
-      chain_id: string | number;
-
-      contract: string;
-
-      user_operation: Params.UserOperation;
-    }
-
-    export namespace Params {
-      export interface UserOperation {
-        call_data: string;
-
-        call_gas_limit: string;
-
-        max_fee_per_gas: string;
-
-        max_priority_fee_per_gas: string;
-
-        nonce: string;
 
-        paymaster: string;
-
-        paymaster_data: string;
-
-        paymaster_post_op_gas_limit: string;
-
-        paymaster_verification_gas_limit: string;
-
-        pre_verification_gas: string;
-
-        sender: string;
-
-        verification_gas_limit: 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 EthereumSendTransactionRpcInput {
+  export interface SparkTransferTokensRpcInput {
     /**
      * Body param
      */
-    caip2: string;
+    method: 'transferTokens';
 
     /**
-     * Body param
+     * Body param: Parameters for the Spark `transferTokens` RPC.
      */
-    method: 'eth_sendTransaction';
+    params: SparkTransferTokensRpcInputParams;
 
     /**
-     * Body param
+     * Body param: The Spark network.
      */
-    params: EthereumSendTransactionRpcInput.Params;
+    network?: SparkNetwork;
 
     /**
-     * Body param
+     * Header param: Request authorization signature. If multiple signatures are
+     * required, they should be comma separated.
      */
-    address?: string;
+    'privy-authorization-signature'?: string;
 
     /**
-     * Body param
+     * Header param: Idempotency keys ensure API requests are executed only once within
+     * a 24-hour window.
      */
-    chain_type?: 'ethereum';
+    '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 interface SparkGetStaticDepositAddressRpcInput {
     /**
      * Body param
      */
-    sponsor?: boolean;
+    method: 'getStaticDepositAddress';
+
+    /**
+     * Body param: The Spark network.
+     */
+    network?: SparkNetwork;
 
     /**
      * Header param: Request authorization signature. If multiple signatures are
@@ -1907,78 +3738,64 @@ export declare namespace WalletRpcParams {
      * a 24-hour window.
      */
     'privy-idempotency-key'?: string;
-  }
 
-  export namespace EthereumSendTransactionRpcInput {
-    export interface Params {
-      transaction: Params.Transaction;
-    }
-
-    export namespace Params {
-      export interface Transaction {
-        authorization_list?: Array<Transaction.AuthorizationList>;
-
-        chain_id?: string | number;
-
-        data?: string;
-
-        from?: string;
-
-        gas_limit?: string | number;
-
-        gas_price?: string | number;
-
-        max_fee_per_gas?: string | number;
-
-        max_priority_fee_per_gas?: string | number;
-
-        nonce?: string | number;
-
-        to?: string;
-
-        type?: 0 | 1 | 2 | 4;
-
-        value?: string | number;
-      }
-
-      export namespace Transaction {
-        export interface AuthorizationList {
-          chain_id: string | number;
+    /**
+     * 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;
+  }
 
-          contract: string;
+  export interface SparkGetClaimStaticDepositQuoteRpcInput {
+    /**
+     * Body param
+     */
+    method: 'getClaimStaticDepositQuote';
 
-          nonce: string | number;
+    /**
+     * Body param: Parameters for the Spark `getClaimStaticDepositQuote` RPC.
+     */
+    params: SparkGetClaimStaticDepositQuoteRpcInputParams;
 
-          r: string;
+    /**
+     * Body param: The Spark network.
+     */
+    network?: SparkNetwork;
 
-          s: string;
+    /**
+     * Header param: Request authorization signature. If multiple signatures are
+     * required, they should be comma separated.
+     */
+    'privy-authorization-signature'?: string;
 
-          y_parity: number;
-        }
-      }
-    }
-  }
+    /**
+     * Header param: Idempotency keys ensure API requests are executed only once within
+     * a 24-hour window.
+     */
+    'privy-idempotency-key'?: string;
 
-  export interface EthereumSign7702AuthorizationRpcInput {
     /**
-     * Body param
+     * Header param: Request expiry. Value is a Unix timestamp in milliseconds
+     * representing the deadline by which the request must be processed.
      */
-    method: 'eth_sign7702Authorization';
+    'privy-request-expiry'?: string;
+  }
 
+  export interface SparkClaimStaticDepositRpcInput {
     /**
      * Body param
      */
-    params: EthereumSign7702AuthorizationRpcInput.Params;
+    method: 'claimStaticDeposit';
 
     /**
-     * Body param
+     * Body param: Parameters for the Spark `claimStaticDeposit` RPC.
      */
-    address?: string;
+    params: SparkClaimStaticDepositRpcInputParams;
 
     /**
-     * Body param
+     * Body param: The Spark network.
      */
-    chain_type?: 'ethereum';
+    network?: SparkNetwork;
 
     /**
      * Header param: Request authorization signature. If multiple signatures are
@@ -1991,38 +3808,29 @@ export declare namespace WalletRpcParams {
      * a 24-hour window.
      */
     'privy-idempotency-key'?: string;
-  }
-
-  export namespace EthereumSign7702AuthorizationRpcInput {
-    export interface Params {
-      chain_id: string | number;
-
-      contract: string;
-
-      nonce?: string | number;
-    }
-  }
 
-  export interface EthereumSecp256k1SignRpcInput {
     /**
-     * Body param
+     * Header param: Request expiry. Value is a Unix timestamp in milliseconds
+     * representing the deadline by which the request must be processed.
      */
-    method: 'secp256k1_sign';
+    'privy-request-expiry'?: string;
+  }
 
+  export interface SparkCreateLightningInvoiceRpcInput {
     /**
      * Body param
      */
-    params: EthereumSecp256k1SignRpcInput.Params;
+    method: 'createLightningInvoice';
 
     /**
-     * Body param
+     * Body param: Parameters for the Spark `createLightningInvoice` RPC.
      */
-    address?: string;
+    params: SparkCreateLightningInvoiceRpcInputParams;
 
     /**
-     * Body param
+     * Body param: The Spark network.
      */
-    chain_type?: 'ethereum';
+    network?: SparkNetwork;
 
     /**
      * Header param: Request authorization signature. If multiple signatures are
@@ -2035,34 +3843,29 @@ export declare namespace WalletRpcParams {
      * a 24-hour window.
      */
     'privy-idempotency-key'?: string;
-  }
-
-  export namespace EthereumSecp256k1SignRpcInput {
-    export interface Params {
-      hash: string;
-    }
-  }
 
-  export interface SolanaSignMessageRpcInput {
     /**
-     * Body param
+     * Header param: Request expiry. Value is a Unix timestamp in milliseconds
+     * representing the deadline by which the request must be processed.
      */
-    method: 'signMessage';
+    'privy-request-expiry'?: string;
+  }
 
+  export interface SparkPayLightningInvoiceRpcInput {
     /**
      * Body param
      */
-    params: SolanaSignMessageRpcInput.Params;
+    method: 'payLightningInvoice';
 
     /**
-     * Body param
+     * Body param: Parameters for the Spark `payLightningInvoice` RPC.
      */
-    address?: string;
+    params: SparkPayLightningInvoiceRpcInputParams;
 
     /**
-     * Body param
+     * Body param: The Spark network.
      */
-    chain_type?: 'solana';
+    network?: SparkNetwork;
 
     /**
      * Header param: Request authorization signature. If multiple signatures are
@@ -2075,36 +3878,29 @@ export declare namespace WalletRpcParams {
      * a 24-hour window.
      */
     'privy-idempotency-key'?: string;
-  }
-
-  export namespace SolanaSignMessageRpcInput {
-    export interface Params {
-      encoding: 'base64';
 
-      message: string;
-    }
-  }
-
-  export interface SolanaSignTransactionRpcInput {
     /**
-     * Body param
+     * Header param: Request expiry. Value is a Unix timestamp in milliseconds
+     * representing the deadline by which the request must be processed.
      */
-    method: 'signTransaction';
+    'privy-request-expiry'?: string;
+  }
 
+  export interface SparkSignMessageWithIdentityKeyRpcInput {
     /**
      * Body param
      */
-    params: SolanaSignTransactionRpcInput.Params;
+    method: 'signMessageWithIdentityKey';
 
     /**
-     * Body param
+     * Body param: Parameters for the Spark `signMessageWithIdentityKey` RPC.
      */
-    address?: string;
+    params: SparkSignMessageWithIdentityKeyRpcInputParams;
 
     /**
-     * Body param
+     * Body param: The Spark network.
      */
-    chain_type?: 'solana';
+    network?: SparkNetwork;
 
     /**
      * Header param: Request authorization signature. If multiple signatures are
@@ -2117,46 +3913,66 @@ export declare namespace WalletRpcParams {
      * a 24-hour window.
      */
     'privy-idempotency-key'?: string;
-  }
 
-  export namespace SolanaSignTransactionRpcInput {
-    export interface Params {
-      encoding: 'base64';
-
-      transaction: 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 SolanaSignAndSendTransactionRpcInput {
+  export interface ExportPrivateKeyRpcInput {
     /**
      * Body param
      */
-    caip2: string;
+    address: string;
 
     /**
      * Body param
      */
-    method: 'signAndSendTransaction';
+    method: 'exportPrivateKey';
 
     /**
-     * Body param
+     * Body param: Input for exporting a wallet (private key or seed phrase) with HPKE
+     * encryption.
      */
-    params: SolanaSignAndSendTransactionRpcInput.Params;
+    params: PrivateKeyExportInput;
 
     /**
-     * Body param
+     * Header param: Request authorization signature. If multiple signatures are
+     * required, they should be comma separated.
      */
-    address?: string;
+    '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 interface ExportSeedPhraseRpcInput {
     /**
      * Body param
      */
-    chain_type?: 'solana';
+    address: string;
 
     /**
      * Body param
      */
-    sponsor?: boolean;
+    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
@@ -2169,27 +3985,51 @@ export declare namespace WalletRpcParams {
      * a 24-hour window.
      */
     'privy-idempotency-key'?: string;
-  }
 
-  export namespace SolanaSignAndSendTransactionRpcInput {
-    export interface Params {
-      encoding: 'base64';
-
-      transaction: 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 WalletSubmitImportParams {
   wallet: WalletSubmitImportParams.HDSubmitInput | WalletSubmitImportParams.PrivateKeySubmitInput;
 
-  additional_signers?: Array<WalletSubmitImportParams.AdditionalSigner>;
+  /**
+   * Additional signers for the wallet.
+   */
+  additional_signers?: AdditionalSignerInput;
 
-  owner?: WalletSubmitImportParams.UserID | WalletSubmitImportParams.PublicKey | null;
+  /**
+   * A human-readable label for the wallet.
+   */
+  display_name?: string;
 
-  owner_id?: 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
+   * after creation.
+   */
+  external_id?: string;
 
-  policy_ids?: Array<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;
+
+  /**
+   * An optional list of up to one policy ID to enforce on the wallet.
+   */
+  policy_ids?: PolicyInput;
 }
 
 export namespace WalletSubmitImportParams {
@@ -2203,7 +4043,7 @@ export namespace WalletSubmitImportParams {
      * The chain type of the wallet to import. Currently supports `ethereum` and
      * `solana`.
      */
-    chain_type: 'ethereum' | 'solana';
+    chain_type: WalletsAPI.WalletImportSupportedChains;
 
     /**
      * The encrypted entropy of the wallet to import.
@@ -2219,7 +4059,7 @@ export namespace WalletSubmitImportParams {
     /**
      * The encryption type of the wallet to import. Currently only supports `HPKE`.
      */
-    encryption_type: 'HPKE';
+    encryption_type: WalletsAPI.HpkeEncryption;
 
     /**
      * The entropy type of the wallet to import.
@@ -2249,7 +4089,7 @@ export namespace WalletSubmitImportParams {
      * The chain type of the wallet to import. Currently supports `ethereum` and
      * `solana`.
      */
-    chain_type: 'ethereum' | 'solana';
+    chain_type: WalletsAPI.WalletImportSupportedChains;
 
     /**
      * The encrypted entropy of the wallet to import.
@@ -2265,7 +4105,7 @@ export namespace WalletSubmitImportParams {
     /**
      * The encryption type of the wallet to import. Currently only supports `HPKE`.
      */
-    encryption_type: 'HPKE';
+    encryption_type: WalletsAPI.HpkeEncryption;
 
     entropy_type: 'private-key';
 
@@ -2276,39 +4116,30 @@ export namespace WalletSubmitImportParams {
      */
     hpke_config?: WalletsAPI.HpkeImportConfig;
   }
-
-  export interface AdditionalSigner {
-    signer_id: string;
-
-    override_policy_ids?: Array<string>;
-  }
-
-  export interface UserID {
-    user_id: string;
-  }
-
-  export interface PublicKey {
-    public_key: string;
-  }
 }
 
 export interface WalletUpdateParams {
   /**
    * Body param: Additional signers for the wallet.
    */
-  additional_signers?: Array<WalletUpdateParams.AdditionalSigner>;
+  additional_signers?: AdditionalSignerInput;
 
   /**
-   * Body param: The owner of the resource. If you provide this, do not specify an
-   * owner_id as it will be generated automatically. When updating a wallet, you can
-   * set the owner to null to remove the owner.
+   * Body param: A human-readable label for the wallet. Set to null to clear.
    */
-  owner?: WalletUpdateParams.PublicKeyOwner | WalletUpdateParams.UserOwner | null;
+  display_name?: string | null;
 
   /**
-   * Body param
+   * 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_id?: string | null;
+  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
@@ -2321,55 +4152,31 @@ export interface WalletUpdateParams {
    * required, they should be comma separated.
    */
   'privy-authorization-signature'?: string;
-}
-
-export namespace WalletUpdateParams {
-  export interface AdditionalSigner {
-    signer_id: string;
-
-    /**
-     * The array of policy IDs that will be applied to wallet requests. If specified,
-     * this will override the base policy IDs set on the wallet.
-     */
-    override_policy_ids?: Array<string>;
-  }
-
-  /**
-   * The P-256 public key of the owner of the resource, in base64-encoded DER format.
-   * If you provide this, do not specify an owner_id as it will be generated
-   * automatically.
-   */
-  export interface PublicKeyOwner {
-    public_key: string;
-  }
 
   /**
-   * The user ID of the owner of the resource. The user must already exist, and this
-   * value must start with "did:privy:". If you provide this, do not specify an
-   * owner_id as it will be generated automatically.
+   * Header param: Request expiry. Value is a Unix timestamp in milliseconds
+   * representing the deadline by which the request must be processed.
    */
-  export interface UserOwner {
-    user_id: string;
-  }
+  'privy-request-expiry'?: string;
 }
 
 export interface WalletAuthenticateWithJwtParams {
-  /**
-   * The user's JWT, to be used to authenticate the user.
-   */
-  user_jwt: string;
-
   /**
    * The encryption type for the authentication response. Currently only supports
    * HPKE.
    */
-  encryption_type?: '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;
+  recipient_public_key: string;
+
+  /**
+   * The user's JWT, to be used to authenticate the user.
+   */
+  user_jwt: string;
 }
 
 export interface WalletCreateWalletsWithRecoveryParams {
@@ -2419,10 +4226,21 @@ export namespace WalletCreateWalletsWithRecoveryParams {
     chain_type: WalletsAPI.WalletChainType;
 
     /**
-     * List of policy IDs for policies that should be enforced on the wallet.
-     * Currently, only one policy is supported per wallet.
+     * A human-readable label for the wallet.
+     */
+    display_name?: string;
+
+    /**
+     * 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;
+
+    /**
+     * An optional list of up to one policy ID to enforce on the wallet.
      */
-    policy_ids?: Array<string>;
+    policy_ids?: WalletsAPI.PolicyInput;
   }
 }
 
@@ -2436,42 +4254,172 @@ export declare namespace Wallets {
     type ExtendedChainType as ExtendedChainType,
     type FirstClassChainType as FirstClassChainType,
     type WalletChainType as WalletChainType,
+    type AuthorizationKeyRole as AuthorizationKeyRole,
+    type WalletEntropyType as WalletEntropyType,
+    type SolanaWalletDerivationStrategy as SolanaWalletDerivationStrategy,
+    type PolicyInput as PolicyInput,
+    type AdditionalSignerItemInput as AdditionalSignerItemInput,
+    type AdditionalSignerInput as AdditionalSignerInput,
+    type WalletAdditionalSignerItem as WalletAdditionalSignerItem,
+    type WalletAdditionalSigner as WalletAdditionalSigner,
+    type Address as Address,
     type WalletCustodian as WalletCustodian,
     type CustodialWalletProvider as CustodialWalletProvider,
     type CustodialWalletChainType as CustodialWalletChainType,
     type CustodialWalletCreateInput as CustodialWalletCreateInput,
     type CustodialWallet as CustodialWallet,
+    type HpkeEncryption as HpkeEncryption,
+    type RecipientPublicKey as RecipientPublicKey,
+    type ExportType as ExportType,
+    type PrivateKeyExportInput as PrivateKeyExportInput,
+    type PrivateKeyExportResponse as PrivateKeyExportResponse,
+    type SeedPhraseExportInput as SeedPhraseExportInput,
+    type SeedPhraseExportResponse as SeedPhraseExportResponse,
+    type WalletImportSupportedChains as WalletImportSupportedChains,
+    type WalletImportSupportedEntropyTypes as WalletImportSupportedEntropyTypes,
+    type WalletImportInitResponse as WalletImportInitResponse,
+    type HpkeAeadAlgorithm as HpkeAeadAlgorithm,
     type HpkeImportConfig as HpkeImportConfig,
-    type SuiCommandName as SuiCommandName,
-    type Wallet as Wallet,
-    type WalletBatchItemInput as WalletBatchItemInput,
-    type WalletBatchCreateInput as WalletBatchCreateInput,
-    type WalletBatchCreateResult as WalletBatchCreateResult,
-    type WalletBatchCreateResponse as WalletBatchCreateResponse,
+    type CurveType as CurveType,
+    type HDPath as HDPath,
+    type SigningAlgorithm as SigningAlgorithm,
+    type Hex as Hex,
+    type Quantity as Quantity,
+    type ExportPrivateKeyRpcInput as ExportPrivateKeyRpcInput,
+    type ExportPrivateKeyRpcResponse as ExportPrivateKeyRpcResponse,
+    type ExportSeedPhraseRpcInput as ExportSeedPhraseRpcInput,
+    type ExportSeedPhraseRpcResponse as ExportSeedPhraseRpcResponse,
+    type RawSignHashParams as RawSignHashParams,
+    type RawSignBytesEncoding as RawSignBytesEncoding,
+    type RawSignBytesHashFunction as RawSignBytesHashFunction,
+    type RawSignBytesParams as RawSignBytesParams,
+    type RawSignInputParams as RawSignInputParams,
+    type RawSignInput as RawSignInput,
+    type RawSignResponseData as RawSignResponseData,
+    type RawSignResponse as RawSignResponse,
+    type EthereumSign7702Authorization as EthereumSign7702Authorization,
+    type UnsignedEthereumTransaction as UnsignedEthereumTransaction,
+    type UserOperationInput as UserOperationInput,
+    type TypedDataDomainInputParams as TypedDataDomainInputParams,
+    type TypedDataTypeFieldInput as TypedDataTypeFieldInput,
+    type TypedDataTypesInputParams as TypedDataTypesInputParams,
+    type EthereumPersonalSignRpcInputParams as EthereumPersonalSignRpcInputParams,
     type EthereumPersonalSignRpcInput as EthereumPersonalSignRpcInput,
+    type EthereumSignTransactionRpcInputParams as EthereumSignTransactionRpcInputParams,
     type EthereumSignTransactionRpcInput as EthereumSignTransactionRpcInput,
+    type EthereumSendTransactionRpcInputParams as EthereumSendTransactionRpcInputParams,
     type EthereumSendTransactionRpcInput as EthereumSendTransactionRpcInput,
+    type EthereumTypedDataInput as EthereumTypedDataInput,
+    type EthereumSignTypedDataRpcInputParams as EthereumSignTypedDataRpcInputParams,
     type EthereumSignTypedDataRpcInput as EthereumSignTypedDataRpcInput,
-    type EthereumSignUserOperationRpcInput as EthereumSignUserOperationRpcInput,
-    type EthereumSign7702AuthorizationRpcInput as EthereumSign7702AuthorizationRpcInput,
+    type EthereumSecp256k1SignRpcInputParams as EthereumSecp256k1SignRpcInputParams,
     type EthereumSecp256k1SignRpcInput as EthereumSecp256k1SignRpcInput,
-    type SolanaSignTransactionRpcInput as SolanaSignTransactionRpcInput,
-    type SolanaSignAndSendTransactionRpcInput as SolanaSignAndSendTransactionRpcInput,
-    type SolanaSignMessageRpcInput as SolanaSignMessageRpcInput,
+    type EthereumSign7702AuthorizationRpcInputParams as EthereumSign7702AuthorizationRpcInputParams,
+    type EthereumSign7702AuthorizationRpcInput as EthereumSign7702AuthorizationRpcInput,
+    type EthereumSignUserOperationRpcInputParams as EthereumSignUserOperationRpcInputParams,
+    type EthereumSignUserOperationRpcInput as EthereumSignUserOperationRpcInput,
+    type EthereumSendCallsCall as EthereumSendCallsCall,
+    type EthereumSendCallsRpcInputParams as EthereumSendCallsRpcInputParams,
+    type EthereumSendCallsRpcInput as EthereumSendCallsRpcInput,
+    type EthereumRpcInput as EthereumRpcInput,
+    type EthereumPersonalSignRpcResponseData as EthereumPersonalSignRpcResponseData,
+    type EthereumPersonalSignRpcResponse as EthereumPersonalSignRpcResponse,
+    type EthereumSignTransactionRpcResponseData as EthereumSignTransactionRpcResponseData,
     type EthereumSignTransactionRpcResponse as EthereumSignTransactionRpcResponse,
+    type EthereumSendTransactionRpcResponseData as EthereumSendTransactionRpcResponseData,
     type EthereumSendTransactionRpcResponse as EthereumSendTransactionRpcResponse,
-    type EthereumPersonalSignRpcResponse as EthereumPersonalSignRpcResponse,
+    type EthereumSignTypedDataRpcResponseData as EthereumSignTypedDataRpcResponseData,
     type EthereumSignTypedDataRpcResponse as EthereumSignTypedDataRpcResponse,
-    type EthereumSignUserOperationRpcResponse as EthereumSignUserOperationRpcResponse,
-    type EthereumSign7702AuthorizationRpcResponse as EthereumSign7702AuthorizationRpcResponse,
+    type EthereumSecp256k1SignRpcResponseData as EthereumSecp256k1SignRpcResponseData,
     type EthereumSecp256k1SignRpcResponse as EthereumSecp256k1SignRpcResponse,
+    type EthereumSign7702AuthorizationRpcResponseData as EthereumSign7702AuthorizationRpcResponseData,
+    type EthereumSign7702AuthorizationRpcResponse as EthereumSign7702AuthorizationRpcResponse,
+    type EthereumSignUserOperationRpcResponseData as EthereumSignUserOperationRpcResponseData,
+    type EthereumSignUserOperationRpcResponse as EthereumSignUserOperationRpcResponse,
+    type EthereumSendCallsRpcResponseData as EthereumSendCallsRpcResponseData,
+    type EthereumSendCallsRpcResponse as EthereumSendCallsRpcResponse,
+    type EthereumRpcResponse as EthereumRpcResponse,
+    type SolanaSignTransactionRpcInputParams as SolanaSignTransactionRpcInputParams,
+    type SolanaSignTransactionRpcInput as SolanaSignTransactionRpcInput,
+    type SolanaSignAndSendTransactionRpcInputParams as SolanaSignAndSendTransactionRpcInputParams,
+    type SolanaSignAndSendTransactionRpcInput as SolanaSignAndSendTransactionRpcInput,
+    type SolanaSignMessageRpcInputParams as SolanaSignMessageRpcInputParams,
+    type SolanaSignMessageRpcInput as SolanaSignMessageRpcInput,
+    type SolanaRpcInput as SolanaRpcInput,
+    type SolanaSignTransactionRpcResponseData as SolanaSignTransactionRpcResponseData,
     type SolanaSignTransactionRpcResponse as SolanaSignTransactionRpcResponse,
+    type SolanaSignAndSendTransactionRpcResponseData as SolanaSignAndSendTransactionRpcResponseData,
     type SolanaSignAndSendTransactionRpcResponse as SolanaSignAndSendTransactionRpcResponse,
+    type SolanaSignMessageRpcResponseData as SolanaSignMessageRpcResponseData,
     type SolanaSignMessageRpcResponse as SolanaSignMessageRpcResponse,
+    type SolanaRpcResponse as SolanaRpcResponse,
+    type SparkNetwork as SparkNetwork,
+    type SparkSigningKeyshare as SparkSigningKeyshare,
+    type SparkWalletLeaf as SparkWalletLeaf,
+    type SparkTransferLeaf as SparkTransferLeaf,
+    type SparkTransfer as SparkTransfer,
+    type SparkUserTokenMetadata as SparkUserTokenMetadata,
+    type SparkTokenBalance as SparkTokenBalance,
+    type SparkBalance as SparkBalance,
+    type TokenOutput as TokenOutput,
+    type OutputWithPreviousTransactionData as OutputWithPreviousTransactionData,
+    type SparkLightningFee as SparkLightningFee,
+    type SparkLightningReceiveRequest as SparkLightningReceiveRequest,
+    type SparkLightningSendRequest as SparkLightningSendRequest,
+    type SparkTransferRpcInputParams as SparkTransferRpcInputParams,
+    type SparkTransferRpcInput as SparkTransferRpcInput,
+    type SparkGetBalanceRpcInput as SparkGetBalanceRpcInput,
+    type SparkOutputSelectionStrategy as SparkOutputSelectionStrategy,
+    type SparkTransferTokensRpcInputParams as SparkTransferTokensRpcInputParams,
+    type SparkTransferTokensRpcInput as SparkTransferTokensRpcInput,
+    type SparkGetStaticDepositAddressRpcInput as SparkGetStaticDepositAddressRpcInput,
+    type SparkGetClaimStaticDepositQuoteRpcInputParams as SparkGetClaimStaticDepositQuoteRpcInputParams,
+    type SparkGetClaimStaticDepositQuoteRpcInput as SparkGetClaimStaticDepositQuoteRpcInput,
+    type SparkClaimStaticDepositRpcInputParams as SparkClaimStaticDepositRpcInputParams,
+    type SparkClaimStaticDepositRpcInput as SparkClaimStaticDepositRpcInput,
+    type SparkCreateLightningInvoiceRpcInputParams as SparkCreateLightningInvoiceRpcInputParams,
+    type SparkCreateLightningInvoiceRpcInput as SparkCreateLightningInvoiceRpcInput,
+    type SparkPayLightningInvoiceRpcInputParams as SparkPayLightningInvoiceRpcInputParams,
+    type SparkPayLightningInvoiceRpcInput as SparkPayLightningInvoiceRpcInput,
+    type SparkSignMessageWithIdentityKeyRpcInputParams as SparkSignMessageWithIdentityKeyRpcInputParams,
+    type SparkSignMessageWithIdentityKeyRpcInput as SparkSignMessageWithIdentityKeyRpcInput,
+    type SparkRpcInput as SparkRpcInput,
+    type SparkTransferRpcResponse as SparkTransferRpcResponse,
+    type SparkGetBalanceRpcResponse as SparkGetBalanceRpcResponse,
+    type SparkTransferTokensRpcResponseData as SparkTransferTokensRpcResponseData,
+    type SparkTransferTokensRpcResponse as SparkTransferTokensRpcResponse,
+    type SparkGetStaticDepositAddressRpcResponseData as SparkGetStaticDepositAddressRpcResponseData,
+    type SparkGetStaticDepositAddressRpcResponse as SparkGetStaticDepositAddressRpcResponse,
+    type SparkGetClaimStaticDepositQuoteRpcResponseData as SparkGetClaimStaticDepositQuoteRpcResponseData,
+    type SparkGetClaimStaticDepositQuoteRpcResponse as SparkGetClaimStaticDepositQuoteRpcResponse,
+    type SparkClaimStaticDepositRpcResponseData as SparkClaimStaticDepositRpcResponseData,
+    type SparkClaimStaticDepositRpcResponse as SparkClaimStaticDepositRpcResponse,
+    type SparkCreateLightningInvoiceRpcResponse as SparkCreateLightningInvoiceRpcResponse,
+    type SparkPayLightningInvoiceRpcResponse as SparkPayLightningInvoiceRpcResponse,
+    type SparkSignMessageWithIdentityKeyRpcResponseData as SparkSignMessageWithIdentityKeyRpcResponseData,
+    type SparkSignMessageWithIdentityKeyRpcResponse as SparkSignMessageWithIdentityKeyRpcResponse,
+    type SparkRpcResponse as SparkRpcResponse,
+    type Wallet as Wallet,
+    type GetByWalletAddressRequestBody as GetByWalletAddressRequestBody,
+    type WalletUpdateRequestBody as WalletUpdateRequestBody,
+    type WalletBatchItemInput as WalletBatchItemInput,
+    type WalletBatchCreateInput as WalletBatchCreateInput,
+    type WalletBatchCreateResult as WalletBatchCreateResult,
+    type WalletBatchCreateResponse as WalletBatchCreateResponse,
+    type WalletRpcRequestBody as WalletRpcRequestBody,
+    type WalletRpcResponse as WalletRpcResponse,
+    type WalletAuthenticateRequestBody as WalletAuthenticateRequestBody,
+    type TokenTransferSource as TokenTransferSource,
+    type TokenTransferDestination as TokenTransferDestination,
+    type CreateTokenTransferRequest as CreateTokenTransferRequest,
+    type SuiCommandName as SuiCommandName,
+    type WalletAPIRegisterAuthorizationKeyInput as WalletAPIRegisterAuthorizationKeyInput,
+    type WalletAPIRevokeAuthorizationKeyInput as WalletAPIRevokeAuthorizationKeyInput,
+    type AuthorizationKeyDashboardResponse as AuthorizationKeyDashboardResponse,
+    type AuthorizationKeyResponse as AuthorizationKeyResponse,
+    type WalletAuthorizationHeaders as WalletAuthorizationHeaders,
     type WalletExportResponse as WalletExportResponse,
     type WalletInitImportResponse as WalletInitImportResponse,
-    type WalletRawSignResponse as WalletRawSignResponse,
-    type WalletRpcResponse as WalletRpcResponse,
     type WalletAuthenticateWithJwtResponse as WalletAuthenticateWithJwtResponse,
     type WalletCreateWalletsWithRecoveryResponse as WalletCreateWalletsWithRecoveryResponse,
     type WalletsCursor as WalletsCursor,