@privy-io/js-sdk-core/dist/dts/index.d.ts

Vanilla JS client for the Privy Auth API

import { AuthenticatedUser, CoinbaseOnRampInitInput, CoinbaseOnRampInitResponse, LinkedAccount, LinkedAccountBitcoinSegwitEmbeddedWallet, LinkedAccountBitcoinTaprootEmbeddedWallet, LinkedAccountEmbeddedWallet, LinkedAccountEmbeddedWalletWithID, LinkedAccountEthereumEmbeddedWallet, LinkedAccountSmartWallet, LinkedAccountSolanaEmbeddedWallet, MfaPasskeyInitRequestBody, MfaSMSInitRequestBody, MoonpayOnRampSignInput, OAuthProviderID, OAuthProviderID as OAuthProviderID$1, OAuthTokens, PasskeyAuthenticatorVerifyResponse, RawSignResponse, SmartWalletConfiguration, SmartWalletType as SmartWalletType$1, UnsignedEthereumTransaction, User, Wallet, WalletCreateParams, WalletRawSignParams, WalletRpcParams, WalletRpcResponse, WalletUpdateParams } from "@privy-io/api-types";
import { Chain, RpcConfig } from "@privy-io/chains";
import { Route } from "@privy-io/routes";
import "@metamask/eth-sig-util";
import "viem/account-abstraction";
import { StrictUnsignedTempoTransactionRequest, StrictUnsignedTransactionRequest } from "@privy-io/ethereum";
import EventEmitter from "eventemitter3";
import { PrivyErrorCode } from "@privy-io/api-base";
import { Connection, SendOptions, Transaction, VersionedTransaction } from "@solana/web3.js";
import { AuthenticationResponseJSON, RegistrationResponseJSON } from "@simplewebauthn/types";
import { Hex, HttpTransport, TypedDataDefinition } from "viem";
import "viem/chains";
import { AsYouType, CountryCallingCode, CountryCode, getCountryCallingCode } from "libphonenumber-js/min";
import { SolanaSignAndSendTransactionFeature, SolanaSignInFeature, SolanaSignMessageFeature, SolanaSignTransactionFeature } from "@solana/wallet-standard-features";
import { WalletWithFeatures } from "@wallet-standard/base";
import { StandardConnectFeature, StandardDisconnectFeature, StandardEventsFeature } from "@wallet-standard/features";
import { WalletAccount } from "@wallet-standard/core";
export * from "@privy-io/chains";
//#endregion
//#region src/embedded/errors.d.ts
declare enum PrivyEmbeddedWalletErrorCode {
  MISSING_OR_INVALID_PRIVY_APP_ID = "missing_or_invalid_privy_app_id",
  MISSING_OR_INVALID_PRIVY_ACCOUNT_ID = "missing_or_invalid_privy_account_id",
  INVALID_DATA = "invalid_data",
  LINKED_TO_ANOTHER_USER = "linked_to_another_user",
  ALLOWLIST_REJECTED = "allowlist_rejected",
  OAUTH_USER_DENIED = "oauth_user_denied",
  UNKNOWN_AUTH_ERROR = "unknown_auth_error",
  USER_EXITED_AUTH_FLOW = "exited_auth_flow",
  MUST_BE_AUTHENTICATED = "must_be_authenticated",
  UNKNOWN_CONNECT_WALLET_ERROR = "unknown_connect_wallet_error",
  GENERIC_CONNECT_WALLET_ERROR = "generic_connect_wallet_error",
  CLIENT_REQUEST_TIMEOUT = "client_request_timeout",
  INVALID_CREDENTIALS = "invalid_credentials"
}
declare abstract class PrivyError extends Error {
  /**
   * Privy error type.
   */
  abstract type: string;
  /**
   * Original Error object, it the error originated client-side.
   */
  cause?: Error;
  /**
   * An optional error code, often included in Privy API responses.
   */
  privyErrorCode?: PrivyEmbeddedWalletErrorCode;
  /**
   * @param type Privy error type.
   * @param message Human-readable message.
   * @param cause Source of this error.
   */
  protected constructor(message: string, cause?: unknown, privyErrorCode?: PrivyEmbeddedWalletErrorCode);
  toString(): string;
}
/**
 * A ProviderRpcError combines the necessary bits of the {PrivyError} with the
 * EIP-compliant ProviderRpcError. This is meant to be a type around errors raised
 * by the ethereum provider.
 */
declare class ProviderRpcError extends PrivyError {
  type: string;
  readonly code: number;
  readonly data?: unknown;
  constructor(message: string, code: number, data?: unknown);
}
declare class PrivyIframeError extends Error {
  type: PrivyIframeErrorTypesType;
  constructor(type: PrivyIframeErrorTypesType, message: string);
}
declare class PrivyConnectorError extends PrivyError {
  type: string;
  constructor(message: string, cause?: unknown, privyErrorCode?: PrivyEmbeddedWalletErrorCode);
}
declare class EmbeddedProviderError extends Error {
  code: number;
  data?: unknown;
  constructor(message: string, code: number, data?: unknown);
}
declare const ProviderErrors: {
  E32002_CONNECTION_ALREADY_PENDING: {
    eipCode: number;
    message: string;
    detail: string;
    retryable: boolean;
  };
  E32002_REQUEST_ALREADY_PENDING: {
    eipCode: number;
    message: string;
    detail: string;
    retryable: boolean;
  };
  E32002_WALLET_LOCKED: {
    eipCode: number;
    message: string;
    detail: string;
    retryable: boolean;
  };
  E4001_USER_REJECTED_REQUEST: {
    eipCode: number;
    message: string;
    detail: string;
    retryable: boolean;
  };
  E4001_DEFAULT_USER_REJECTED_REQUEST: {
    eipCode: number;
    message: string;
    detail: string;
    default: boolean;
    retryable: boolean;
  };
  E4100_DEFAULT_UNAUTHORIZED: {
    eipCode: number;
    message: string;
    detail: string;
    default: boolean;
    retryable: boolean;
  };
  E4200_DEFAULT_UNSUPPORTED_METHOD: {
    eipCode: number;
    message: string;
    detail: string;
    default: boolean;
    retryable: boolean;
  };
  E4900_DEFAULT_DISCONNECTED: {
    eipCode: number;
    message: string;
    detail: string;
    default: boolean;
    retryable: boolean;
  };
  E4901_DEFAULT_CHAIN_DISCONNECTED: {
    eipCode: number;
    message: string;
    detail: string;
    default: boolean;
    retryable: boolean;
  };
  E32700_DEFAULT_PARSE_ERROR: {
    eipCode: number;
    message: string;
    detail: string;
    default: boolean;
    retryable: boolean;
  };
  E32600_DEFAULT_INVALID_REQUEST: {
    eipCode: number;
    message: string;
    detail: string;
    default: boolean;
    retryable: boolean;
  };
  E32601_DEFAULT_METHOD_NOT_FOUND: {
    eipCode: number;
    message: string;
    detail: string;
    default: boolean;
    retryable: boolean;
  };
  E32602_DEFAULT_INVALID_PARAMS: {
    eipCode: number;
    message: string;
    detail: string;
    default: boolean;
    retryable: boolean;
  };
  E32603_DEFAULT_INTERNAL_ERROR: {
    eipCode: number;
    message: string;
    detail: string;
    default: boolean;
    retryable: boolean;
  };
  E32000_DEFAULT_INVALID_INPUT: {
    eipCode: number;
    message: string;
    detail: string;
    default: boolean;
    retryable: boolean;
  };
  E32001_DEFAULT_RESOURCE_NOT_FOUND: {
    eipCode: number;
    message: string;
    detail: string;
    default: boolean;
    retryable: boolean;
  };
  E32002_DEFAULT_RESOURCE_UNAVAILABLE: {
    eipCode: number;
    message: string;
    detail: string;
    default: boolean;
    retryable: boolean;
  };
  E32003_DEFAULT_TRANSACTION_REJECTED: {
    eipCode: number;
    message: string;
    detail: string;
    default: boolean;
    retryable: boolean;
  };
  E32004_DEFAULT_METHOD_NOT_SUPPORTED: {
    eipCode: number;
    message: string;
    detail: string;
    default: boolean;
    retryable: boolean;
  };
  E32005_DEFAULT_LIMIT_EXCEEDED: {
    eipCode: number;
    message: string;
    detail: string;
    default: boolean;
    retryable: boolean;
  };
  E32006_DEFAULT_JSON_RPC_VERSION_NOT_SUPPORTED: {
    eipCode: number;
    message: string;
    detail: string;
    default: boolean;
    retryable: boolean;
  };
  UNKNOWN_ERROR: {
    eipCode: number;
    message: string;
    detail: string;
    retryable: boolean;
  };
};
declare function errorIndicatesRecoveryIsNeeded(error: unknown): error is PrivyIframeError;
declare function errorIndicatesMfaTimeout(error: unknown): error is PrivyIframeError;
declare function errorIndicatesMfaVerificationFailed(error: unknown): error is PrivyIframeError;
declare function errorIndicatesMaxMfaRetries(error: unknown): error is PrivyIframeError;
declare function errorIndicatesMfaRateLimit(error: unknown): error is PrivyIframeError;
/**
 * Represents an error message meant to display within the UI
 */
type UiErrorMessage = {
  /**
   * Main message to convey, one line
   */
  message: string;
  /**
   * Additional detail that may be relevant if it cannot be conveyed in the message
   */
  detail: string;
  /**
   * Whether this error is expected to be retryable
   */
  retryable: boolean;
};
type ProviderError = UiErrorMessage & {
  /**
   * The EIP code, either [EIP-1193](https://eips.ethereum.org/EIPS/eip-1193#provider-errors)
   * or [EIP-1474](https://eips.ethereum.org/EIPS/eip-1474#error-codes)
   */
  eipCode: number;
  /**
   * Whether the contents (message & detail) are the default specified by the
   * EIP or if this is a custom message from our own semantic understanding of
   * the error.
   */
  default?: boolean;
};
/**
 * A PrivyProviderRpcError is a classified {ProviderRpcError}. When relevant,
 * we will attempt to replace the original messaging with our best guess of what
 * is going on.
 */
declare class PrivyProviderRpcError extends ProviderRpcError {
  details: ProviderError;
  constructor(error: unknown);
}
//#endregion
//#region src/embedded/EmbeddedWalletProvider.d.ts
type ProviderConnectInfo = {
  chainId: string;
};
type OnConnectEventHandler = (connectInfo: ProviderConnectInfo) => void;
type OnDisconnectEventHandler = (error: ProviderRpcError) => void;
type OnChainChangedEventHandler = (chainId: string | number) => void;
type OnAccountsChangedEventHandler = (accounts: string[]) => void;
type ProviderMessage = {
  type: string;
  data: unknown;
};
type OnMessageEventHandler = (message: ProviderMessage) => void;
type EIP1193OnEventHandler = OnConnectEventHandler | OnDisconnectEventHandler | OnChainChangedEventHandler | OnAccountsChangedEventHandler | OnMessageEventHandler;
interface EIP1193Provider {
  request: (request: {
    method: string;
    params?: Array<unknown> | undefined;
  }) => Promise<unknown>;
  on: (eventName: string, listener: EIP1193OnEventHandler) => unknown;
  removeListener: (eventName: string | symbol, listener: (...args: unknown[]) => void) => unknown;
}
type RequestArguments = {
  method: string;
  params?: Array<any> | undefined;
};
type OnNeedsRecovery = (input: {
  recoveryMethod: EmbeddedWalletRecoveryOptions;
  onRecovered: () => void;
}) => Promise<void> | void;
declare class EmbeddedWalletProvider extends EventEmitter implements EIP1193Provider {
  request(request: RequestArguments): Promise<any>;
  /**
   * Backfills a transaction that may not specify a `chainId` with the provider's `this._chainId`
   * and switches the provider to that chain. Works for both standard EVM and
   * Tempo (type 118) requests.
   */
  private ensureChainId;
  /**
   * If a chainId is provided that differs from the current `this._chainId`,
   * the new chain and StaticJsonRpcProvider will be set
   */
  private internalSwitchEthereumChain;
  private handlePopulateTransaction;
  private handleSignTransaction;
  private handleSendTransaction;
  private handleEstimateGas;
  private handleSwitchEthereumChain;
  private handleIFrameRpc;
  private handleJsonRpc;
  toJSON(): string;
}
//#endregion
//#region src/Error.d.ts
type AuthAction = 'login' | 'link';
type Method = 'email' | 'sms' | 'oauth' | 'siwe' | 'passkey' | 'farcaster' | 'siws';
type ClientErrorCode = `failed_to_complete_${AuthAction}_with_oauth` | `${AuthAction}_with_oauth_returned_with_invalid_credentials` | `${AuthAction}_with_oauth_was_cancelled_by_user` | 'attempted_rpc_call_before_logged_in' | 'attempted_submit_otp_before_sending' | 'attempted_to_set_password_before_connected' | 'attempted_to_set_password_but_password_already_set' | `attempted_login_with_${Method}_while_already_logged_in` | `attempted_link_${Method}_before_logged_in` | 'attempted_link_cross_app_before_logged_in' | 'attempted_login_with_cross_app_while_already_logged_in' | 'attempted_cross_app_request_before_logged_in' | 'attempted_update_before_logged_in' | 'attempted_update_email_without_a_linked_email' | 'attempted_update_phone_without_a_linked_phone' | 'cross_app_invalid_app' | 'cross_app_read_only' | 'cross_app_invalid_wallet' | 'cross_app_request_error' | `attempted_unlink_siwe_before_logged_in` | 'oauth_session_failed' | 'oauth_session_timeout' | 'user_signer_sign_error' | 'invalid_input' | 'embedded_wallet_before_logged_in' | 'embedded_wallet_needs_recovery' | 'embedded_wallet_creation_error' | 'embedded_wallet_recovery_error' | 'embedded_wallet_set_password_error' | 'embedded_wallet_set_recovery_error' | 'unknown_embedded_wallet_error' | 'embedded_wallet_does_not_exist' | 'embedded_wallet_already_exists' | 'embedded_wallet_webview_not_loaded' | 'embedded_wallet_request_error' | 'embedded_wallet_request_expired' | 'delegated_actions_before_logged_in' | 'delegated_actions_wallet_not_found' | 'delegated_actions_no_wallet_to_revoke' | 'no_passkey_found_for_challenge' | 'pkce_state_code_mismatch' | 'failed_to_create_passkey' | 'failed_to_generate_farcaster_uri' | 'failed_to_generate_farcaster_channel_token' | 'farcaster_polling_timeout' | 'farcaster_polling_canceled' | 'unsupported_recovery_method' | 'attempted_to_create_guest_account_for_logged_in_user' | 'attempted_to_read_storage_before_client_initialized' | 'third_party_auth_error' | 'invalid_native_app_id' | 'unsupported_mfa_method' | 'unsupported_chain_type' | 'invalid_mfa_code' | 'invalid_passkey_response' | 'storage_error' | 'smart_wallet_client_error' | 'chain_not_supported' | 'mfa_canceled' | 'configuration_error' | 'failed_to_fetch_moonpay_transaction_status' | 'unsupported_wallet_type';
type ErrorBody<T extends PrivyErrorCode | ClientErrorCode> = {
  error: string;
  code: T;
};
type ServerErrorBody = ErrorBody<PrivyErrorCode> & {
  status: number;
};
declare class PrivyApiError extends Error {
  name: string;
  error: string;
  code: PrivyErrorCode;
  status: number;
  constructor({ error, code, status }: ServerErrorBody);
}
declare class PrivyClientError extends Error {
  error: string;
  code: ClientErrorCode;
  constructor({ error, code }: ErrorBody<ClientErrorCode>);
}
declare class MoonpayApiError extends Error {
  error: string;
  code: ClientErrorCode;
  response: Response;
  constructor({ error, code, response }: ErrorBody<ClientErrorCode> & {
    response: Response;
  });
}
/**
 * This type converts the {@link PrivyErrorCode} enum into a string literal union type,
 * in order to match the structure of {@link ClientErrorCode}.
 *
 * Note this is valid because the {@link PrivyErrorCode} enum is a string enum.
 */
type PrivyApiErrorCode = `${PrivyErrorCode}`;
/**
 * All possible error codes, be it from the API or the client, plus an `'unknown_error'`
 * code for unexpected errors.
 */
type ErrorCode = PrivyApiErrorCode | ClientErrorCode | 'unknown_error';
/**
 * A partial map of error codes to error messages, with a `default` message as a fallback.
 */
type ErrorMessageMap = Partial<Record<ErrorCode, string>> & {
  default: string;
};
/**
 * Takes a message map and return an error formatter, that takes an error and
 * returns the corresponding error message.
 *
 * Valid errors are all those in the classes {@link PrivyApiError} and {@link PrivyClientError}.
 * Any other error will be treated as an unknown error.
 *
 * @param messageMap The partial map used to format error messages by their error code.
 * @returns
 */
declare const createErrorFormatter: (messageMap: ErrorMessageMap) => (error: unknown) => string;
declare function errorIndicatesMfaCanceled(error: unknown): unknown;
//#endregion
//#region src/embedded/withMfa.d.ts
type MfaMethod = 'sms' | 'totp' | 'passkey';
type MfaSubmitArgs = {
  mfaMethod: MfaMethod;
  mfaCode: string | PasskeyAuthenticatorVerifyResponse;
  relyingParty: string;
};
type MfaPromise = {
  current: {
    resolve: (args: MfaSubmitArgs) => void;
    reject: (error: PrivyClientError) => void;
  } | null;
};
type MfaSubmitPromise = {
  current: {
    resolve: (x: undefined) => void;
    reject: (error: PrivyIframeError) => void;
  } | null;
};
//#endregion
//#region src/embedded/types.d.ts
type Quantity = string | number | bigint;
type UnsignedTransactionRequest = {
  from?: string;
  to?: string;
  nonce?: Quantity;
  gasLimit?: Quantity;
  gasPrice?: Quantity;
  data?: ArrayLike<number> | string;
  value?: Quantity;
  chainId?: number;
  type?: number;
  accessList?: Array<{
    address: string;
    storageKeys: Array<string>;
  }> | Array<[string, Array<string>]> | Record<string, Array<string>>;
  maxPriorityFeePerGas?: Quantity;
  maxFeePerGas?: Quantity;
  /** Batch of calls to execute atomically. Required for Tempo transactions. */
  calls?: Array<{
    to: string;
    data?: string;
    value?: Quantity;
  }>;
  /** Token used to pay gas fees for Tempo transactions. */
  feeToken?: string;
  /** 2D nonce key for Tempo transactions (0 = protocol nonce, >0 = user nonces). */
  nonceKey?: Quantity;
  /** Earliest inclusion timestamp for Tempo transactions (seconds since epoch). */
  validAfter?: Quantity;
  /** Expiration timestamp for Tempo transactions (seconds since epoch). */
  validBefore?: Quantity;
};
/**
 * {@link UnsignedTransactionRequest} specifies the `chainId` field as optional,
 * which matches ethers, wagmi, and a bunch of other libraries.
 *
 * However, we need the transaction's `chainId` to ensure it does price conversion, quote
 * labeling, etc. importantly.
 *
 * > Note:
 * > If the developer does not set a `chainId` in their `UnsignedTransactionRequest`,
 * > we default to the embedded provider's  current `chainId`
 */
type UnsignedTransactionRequestWithChainId = UnsignedTransactionRequest & {
  chainId: number;
};
interface eth_populateTransactionRequestResponse {
  method: 'eth_populateTransactionRequest';
  data: UnsignedTransactionRequest;
}
interface eth_signResponse {
  method: 'eth_sign';
  data: string;
}
interface personal_signResponse {
  method: 'personal_sign';
  data: string;
}
interface eth_signTransactionResponse {
  method: 'eth_signTransaction';
  data: string;
}
interface eth_signTypedData_v4Response {
  method: 'eth_signTypedData_v4';
  data: string;
}
interface csw_signUserOperationResponse {
  method: 'csw_signUserOperation';
  data: string;
}
interface secp256k1_signResponse {
  method: 'secp256k1_sign';
  data: `0x${string}`;
}
type RpcResponseType = eth_signTransactionResponse | eth_populateTransactionRequestResponse | eth_signResponse | personal_signResponse | eth_signTypedData_v4Response | csw_signUserOperationResponse | secp256k1_signResponse;
interface SolanaRpcResponseType {
  data: {
    signature: string;
  };
}
type BaseBitcoinRpcResponseType = {
  method: string;
  data: any;
};
/**
 * The Privy SDK(s) will return the signature as a `Uint8Array`, but the iframe must serialize it to
 * a `string` in order to pass it over the message bus. You can see how this is done in the signature handler.
 *
 * The Privy SDK(s) themselves must then deserialize the `string` to a `Uint8Array` before
 * returning the signature to the caller.
 */
interface bitcoin_signResponse extends BaseBitcoinRpcResponseType {
  method: 'sign';
  data: {
    signature: string;
  };
}
interface bitcoin_signTransactionResponse extends BaseBitcoinRpcResponseType {
  method: 'signTransaction';
  data: {
    signedTransaction: string;
  };
}
type BitcoinRpcResponseType = bitcoin_signResponse | bitcoin_signTransactionResponse;
type PrivyEventType = 'privy:iframe:ready' | 'privy:user-signer:sign' | 'privy:wallets:create' | 'privy:wallets:add' | 'privy:wallets:set-recovery' | 'privy:wallets:connect' | 'privy:wallets:recover' | 'privy:wallets:rpc' | 'privy:wallet:create' | 'privy:wallet:connect' | 'privy:wallet:recover' | 'privy:wallet:rpc' | 'privy:solana-wallet:create' | 'privy:solana-wallet:create-additional' | 'privy:solana-wallet:connect' | 'privy:solana-wallet:recover' | 'privy:solana-wallet:rpc' | 'privy:delegated-actions:consent' | 'privy:mfa:verify' | 'privy:mfa:init-enrollment' | 'privy:mfa:submit-enrollment' | 'privy:mfa:unenroll' | 'privy:mfa:clear' | 'privy:auth:unlink-passkey';
type EmbeddedWalletRecoveryOptions = LinkedAccountEmbeddedWallet['recovery_method'];
type IEmbeddedWalletRecoveryOptions = EmbeddedWalletRecoveryOptions | 'icloud-native';
type PasswordRecoveryInput = {
  recoveryMethod: 'user-passcode';
  password: string;
};
type AppKeyRecoveryInput = {
  recoveryMethod: 'recovery-encryption-key';
  recoveryKey: string;
};
type CloudRecoveryInput = {
  recoveryMethod: 'google-drive' | 'icloud';
  recoveryAccessToken: string;
};
type ICloudNativeRecoveryInput = {
  recoveryMethod: 'icloud-native';
  recoverySecretOverride: string;
  iCloudRecordNameOverride: string;
};
type SetRecoveryInput = {
  wallet: LinkedAccountEthereumEmbeddedWallet | LinkedAccountSolanaEmbeddedWallet;
} & (PasswordRecoveryInput | CloudRecoveryInput | ICloudNativeRecoveryInput | PrivyRecoveryInput | AppKeyRecoveryInput);
interface SetRecoveryOutput {
  /** User object with the updated embedded wallet */
  user: User;
  /**
   * Provider for the embedded ethereum wallet.
   *
   * This value will be `null` if and only if the wallet passed in the input is not an Ethereum wallet.
   * @deprecated Get the provider instance from the `getProvider(...)` method instead.
   */
  provider: EmbeddedWalletProvider | null;
}
type BaseProxyRequest = {
  accessToken: string;
} & Partial<MfaSubmitArgs>;
type PrivyResponseBaseEventType<E extends PrivyEventType, D extends PrivyResponseDataType> = {
  id: string;
  event: E;
  data: D;
};
type ChainType = 'ethereum' | 'solana' | 'bitcoin-taproot' | 'bitcoin-segwit';
type BaseWalletsRequestData = BaseProxyRequest;
type IframeReadyResponseDataType = Record<string, never>;
type IframeReadyResponseEventType = PrivyResponseBaseEventType<'privy:iframe:ready', IframeReadyResponseDataType>;
type WalletsCreateResponseDataType = {
  address: string;
};
type WalletsCreateResponseEventType = PrivyResponseBaseEventType<'privy:wallets:create', WalletsCreateResponseDataType>;
type EntropyIdVerifier = 'ethereum-address-verifier' | 'solana-address-verifier';
type UserSignerSignResponseDataType = {
  /** The signature */
  signature: string;
};
type UserSignerSignResponseEventType = PrivyResponseBaseEventType<'privy:user-signer:sign', UserSignerSignResponseDataType>;
type WalletsAddResponseDataType = {
  address: string;
};
type WalletsAddResponseEventType = PrivyResponseBaseEventType<'privy:wallets:add', WalletsAddResponseDataType>;
type WalletsSetRecoveryBaseRequestDataType = BaseWalletsRequestData & {
  /**
   * Key with which to look up the existing entropy
   */
  entropyId: string;
  /**
   * Source of the `entropyId` property. This field determines how the entropyId will
   * be used. Possible values include:
   * - ethereum-address-verifier: the entropyId is the address of the Ethereum wallet derived
   * at index 0 for this entropy
   * - solana-address-verifier: the entropyId is a the address of the Solana wallet derived
   * at index 0 for this entropy
   *
   * When this field is a wallet address, we can verify reconstitution was successful by
   * deriving the specified wallet and comparing the address to the `entropyId`
   */
  entropyIdVerifier: EntropyIdVerifier;
  existingRecoveryMethod?: EmbeddedWalletRecoveryOptions;
};
type WalletsSetRecoveryPasswordDataType = WalletsSetRecoveryBaseRequestDataType & {
  recoveryMethod: 'user-passcode';
  recoveryPassword: string;
};
type WalletsSetRecoveryGoogleDriveDataType = WalletsSetRecoveryBaseRequestDataType & {
  recoveryMethod: 'google-drive';
  recoveryAccessToken: string;
};
type WalletsSetRecoveryICloudDataType = WalletsSetRecoveryBaseRequestDataType & {
  recoveryMethod: 'icloud';
  recoveryAccessToken: string;
};
type WalletsSetRecoveryICloudNativeDataType = WalletsSetRecoveryBaseRequestDataType & {
  recoveryMethod: 'icloud-native';
  recoverySecretOverride: string;
  iCloudRecordNameOverride: string;
};
type WalletsRecoveryEncyrptionKeyDataType = WalletsSetRecoveryBaseRequestDataType & {
  recoveryMethod: 'recovery-encryption-key';
  recoveryKey: string;
};
type WalletsSetRecoveryRequestDataType = Omit<WalletsSetRecoveryPasswordDataType, 'chainType'> | Omit<WalletsSetRecoveryGoogleDriveDataType, 'chainType'> | Omit<WalletsSetRecoveryICloudDataType, 'chainType'> | Omit<WalletsSetRecoveryICloudNativeDataType, 'chainType'> | Omit<WalletsRecoveryEncyrptionKeyDataType, 'chainType'>;
type WalletsSetRecoveryResponseDataType = {
  entropyId: string;
  entropyIdVerifier: EntropyIdVerifier;
  recoveryMethod: WalletsSetRecoveryRequestDataType['recoveryMethod'];
};
type WalletsSetRecoveryResponseEventType = PrivyResponseBaseEventType<'privy:wallets:set-recovery', WalletsSetRecoveryResponseDataType>;
type WalletsConnectResponseDataType = {
  entropyId: string;
};
type WalletsConnectResponseEventType = PrivyResponseBaseEventType<'privy:wallets:connect', WalletsConnectResponseDataType>;
type WalletsRecoverResponseDataType = {
  entropyId: string;
};
type WalletsRecoverResponseEventType = PrivyResponseBaseEventType<'privy:wallets:recover', WalletsRecoverResponseDataType>;
type WalletsRpcEthereumResponseDataType = {
  chainType: 'ethereum';
  response: RpcResponseType;
};
type WalletsRpcSolanaResponseDataType = {
  chainType: 'solana';
  response: SolanaRpcResponseType;
};
type WalletsRpcBitcoinResponseDataType = {
  chainType: 'bitcoin-taproot' | 'bitcoin-segwit';
  response: BitcoinRpcResponseType;
};
type WalletsRpcResponseDataType = {
  address: string;
} & (WalletsRpcEthereumResponseDataType | WalletsRpcSolanaResponseDataType | WalletsRpcBitcoinResponseDataType);
type WalletsRpcResponseEventType = PrivyResponseBaseEventType<'privy:wallets:rpc', WalletsRpcResponseDataType>;
type WalletCreateResponseDataType = {
  address: string;
};
type WalletCreateResponseEventType = PrivyResponseBaseEventType<'privy:wallet:create', WalletCreateResponseDataType>;
type WalletConnectResponseDataType = {
  address: string;
};
type WalletConnectResponseEventType = PrivyResponseBaseEventType<'privy:wallet:connect', WalletConnectResponseDataType>;
type WalletRecoverResponseDataType = {
  address: string;
};
type WalletRecoverResponseEventType = PrivyResponseBaseEventType<'privy:wallet:recover', WalletRecoverResponseDataType>;
type WalletRpcResponseDataType = {
  address: string;
  response: RpcResponseType;
};
type WalletRpcResponseEventType = PrivyResponseBaseEventType<'privy:wallet:rpc', WalletRpcResponseDataType>;
type SolanaWalletCreateResponseDataType = {
  publicKey: string;
};
type SolanaWalletCreateResponseEventType = PrivyResponseBaseEventType<'privy:solana-wallet:create', SolanaWalletCreateResponseDataType>;
type SolanaWalletCreateAdditionalResponseDataType = {
  publicKey: string;
};
type SolanaWalletCreateAdditionalResponseEventType = PrivyResponseBaseEventType<'privy:solana-wallet:create-additional', SolanaWalletCreateAdditionalResponseDataType>;
type SolanaWalletConnectResponseDataType = {
  publicKey: string;
};
type SolanaWalletConnectResponseEventType = PrivyResponseBaseEventType<'privy:solana-wallet:connect', SolanaWalletConnectResponseDataType>;
type SolanaWalletRecoverResponseDataType = {
  publicKey: string;
};
type SolanaWalletRecoverResponseEventType = PrivyResponseBaseEventType<'privy:solana-wallet:recover', SolanaWalletRecoverResponseDataType>;
type SolanaWalletRpcResponseDataType = {
  publicKey: string;
  response: SolanaRpcResponseType;
};
type SolanaWalletRpcResponseEventType = PrivyResponseBaseEventType<'privy:solana-wallet:rpc', SolanaWalletRpcResponseDataType>;
type RootWalletForDelegation = {
  /** Address of the root wallet for the entropy being delegated. */
  address: string;
  /** Chain type of the root wallet for the entropy being delegated. */
  chainType: 'ethereum' | 'solana';
  /** Whether or not the root wallet for the entropy being delegated is imported. */
  imported: boolean;
};
type DelegatedWallet = {
  /** Address for a wallet to delegate. */
  address: string;
  /** Chain type for a wallet to delegate. */
  chainType: 'ethereum' | 'solana';
  /** HD index for the wallet to delegate. */
  walletIndex: number;
};
type DelegatedActionsConsentResponseDataType = {
  success: boolean;
};
type DelegatedActionsConsentResponseEventType = PrivyResponseBaseEventType<'privy:delegated-actions:consent', DelegatedActionsConsentResponseDataType>;
type MfaVerifyResponseDataType = Record<string, never>;
type MfaVerifyResponseEventType = PrivyResponseBaseEventType<'privy:mfa:verify', MfaVerifyResponseDataType>;
type MfaInitEnrollmentResponseDataType = {
  method: string;
  secret?: string;
  authUrl?: string;
};
type MfaInitEnrollmentResponseEventType = PrivyResponseBaseEventType<'privy:mfa:init-enrollment', MfaInitEnrollmentResponseDataType>;
type MfaSubmitEnrollmentResponseDataType = Record<string, never>;
type MfaSubmitEnrollmentResponseEventType = PrivyResponseBaseEventType<'privy:mfa:submit-enrollment', MfaSubmitEnrollmentResponseDataType>;
type MfaUnenrollResponseDataType = Record<string, never>;
type MfaUnenrollResponseEventType = PrivyResponseBaseEventType<'privy:mfa:unenroll', MfaUnenrollResponseDataType>;
type MfaClearResponseDataType = Record<string, never>;
type MfaClearResponseEventType = PrivyResponseBaseEventType<'privy:mfa:clear', MfaClearResponseDataType>;
type UnlinkPasskeyResponseDataType = Record<string, never>;
type UnlinkPasskeyResponseEventType = PrivyResponseBaseEventType<'privy:auth:unlink-passkey', UnlinkPasskeyResponseDataType>;
type PrivyResponseDataType = IframeReadyResponseDataType | UserSignerSignResponseDataType | WalletsCreateResponseDataType | WalletsAddResponseDataType | WalletsSetRecoveryResponseDataType | WalletsConnectResponseDataType | WalletsRecoverResponseDataType | WalletsRpcResponseDataType | WalletCreateResponseDataType | WalletConnectResponseDataType | WalletRecoverResponseDataType | WalletRpcResponseDataType | SolanaWalletCreateResponseDataType | SolanaWalletConnectResponseDataType | SolanaWalletRecoverResponseDataType | SolanaWalletRpcResponseDataType | DelegatedActionsConsentResponseDataType | MfaVerifyResponseDataType | MfaInitEnrollmentResponseDataType | MfaSubmitEnrollmentResponseDataType | MfaUnenrollResponseDataType | MfaClearResponseDataType | UnlinkPasskeyResponseDataType;
declare const PrivyIframeErrorTypes: readonly ['error', 'invalid_request_arguments', 'wallet_not_on_device', 'invalid_recovery_pin', 'insufficient_funds', 'mfa_timeout', 'missing_or_invalid_mfa', 'mfa_verification_max_attempts_reached'];
type PrivyIframeErrorTypesType = (typeof PrivyIframeErrorTypes)[number];
type PrivyErrorResponseEventType = PrivyResponseBaseEventType<PrivyEventType, PrivyResponseDataType> & {
  error: {
    type: PrivyIframeErrorTypesType;
    message: string;
  };
};
type PrivyResponseEvent = IframeReadyResponseEventType | PrivyErrorResponseEventType | UserSignerSignResponseEventType | WalletsCreateResponseEventType | WalletsAddResponseEventType | WalletsSetRecoveryResponseEventType | WalletsConnectResponseEventType | WalletsRecoverResponseEventType | WalletsRpcResponseEventType | WalletCreateResponseEventType | WalletConnectResponseEventType | WalletRecoverResponseEventType | WalletRpcResponseEventType | SolanaWalletCreateResponseEventType | SolanaWalletCreateAdditionalResponseEventType | SolanaWalletConnectResponseEventType | SolanaWalletRecoverResponseEventType | SolanaWalletRpcResponseEventType | DelegatedActionsConsentResponseEventType | MfaVerifyResponseEventType | MfaInitEnrollmentResponseEventType | MfaSubmitEnrollmentResponseEventType | MfaUnenrollResponseEventType | MfaClearResponseEventType | UnlinkPasskeyResponseEventType;
type EmbeddedWalletMessagePoster = {
  postMessage: (message: any, targetOrigin: string, transfer?: Transferable) => void;
  reload: () => void;
};
type PreparedTransactionRequestEIP1559 = UnsignedTransactionRequest & {
  from: string;
  to: string;
  nonce: Quantity;
  chainId: number;
  gasLimit: Quantity;
  type: 2;
  maxFeePerGas: Quantity;
};
type PreparedTransactionRequestLegacy = UnsignedTransactionRequest & {
  from: string;
  to: string;
  nonce: Quantity;
  chainId: number;
  gasLimit: Quantity;
  type: 0 | 1;
  gasPrice: Quantity;
};
type PreparedTransactionRequestTempo = UnsignedTransactionRequest & {
  from: string;
  chainId: number;
  type: 118;
  calls: Array<{
    to: string;
    data?: string;
    value?: Quantity;
  }>;
};
type PreparedTransactionRequest = PreparedTransactionRequestEIP1559 | PreparedTransactionRequestLegacy | PreparedTransactionRequestTempo;
//#endregion
//#region src/storage/Storage.d.ts
interface Storage {
  get(key: string): unknown | Promise<unknown>;
  put(key: string, value: unknown): void | Promise<void>;
  del(key: string): void | Promise<void>;
  getKeys(): string[] | Promise<string[]>;
}
//#endregion
//#region src/utils/NonEmptyArray.d.ts
type NonEmptyArray<T> = [T, ...T[]];
//#endregion
//#region src/client/AppApi.d.ts
declare class AppApi {
  private _smartWalletConfig;
  getConfig(): import("@privy-io/api-types").AppResponse | undefined;
  getSmartWalletConfig(): Promise<SmartWalletConfiguration>;
  get appId(): string;
}
//#endregion
//#region src/client/CrossAppApi.d.ts
declare class CrossAppApi {
  /** Defines the format of the storage key for provider access tokens */
  private static providerAccessTokenStorageKey;
  /**
   * Updates the stored token information of a given cross-app provider.
   * @param providerAppId the Privy app ID to which the oauth tokens correspond.
   * @param tokens should be the result of cross app authentication (be it login or linking).
   */
  updateOnCrossAppAuthentication(providerAppId: string, tokens: OAuthTokens): Promise<void>;
  /**
   * Returns the last known access token for a given cross-app provider.
   * @param providerAppId the Privy app ID on which you want to act.
   */
  getProviderAccessToken(providerAppId: string): Promise<string | null>;
  /**
   * Fetches the metadata of all cross-app connections for the current app.
   */
  getCrossAppConnections(): Promise<import("@privy-io/api-types").CrossAppConnectionsResponse>;
}
//#endregion
//#region src/client/DelegatedWalletsApi.d.ts
declare class DelegatedWalletsApi {
  /**
   * Revokes delegation permission of all the wallets associated with the user.
   */
  revoke(): Promise<void>;
}
//#endregion
//#region src/embedded/EmbeddedSolanaWalletProvider.d.ts
type SignMessageRequestArguments = {
  method: 'signMessage';
  params: {
    message: string;
  };
};
type SignAndSendTransactionRequestArguments = {
  method: 'signAndSendTransaction';
  params: {
    transaction: Transaction | VersionedTransaction;
    connection: Connection;
    options?: SendOptions;
  };
};
type SignTransactionRequestArguments<T extends Transaction | VersionedTransaction = Transaction> = {
  method: 'signTransaction';
  params: {
    transaction: T;
  };
};
/**
 * Privy embedded wallet provider for Solana accounts.
 *
 * Currently only supports signing messages.
 */
declare class EmbeddedSolanaWalletProvider {
  request(request: SignMessageRequestArguments): Promise<{
    signature: string;
  }>;
  request(request: SignAndSendTransactionRequestArguments): Promise<{
    signature: string;
  }>;
  request<T extends Transaction | VersionedTransaction>(request: SignTransactionRequestArguments<T>): Promise<{
    signedTransaction: T;
  }>;
  /**
   * Legacy API for reading the public key for this provider.
   *
   * @deprecated
   */
  get _publicKey(): string;
  private connectAndRecover;
  private signMessageRpc;
  private handleIFrameRpc;
  private handleSignAndSendTransaction;
  private handleSignTransaction;
  /**
   * Pretty log output for when an instance of this class is `console.log`'d
   */
  toJSON(): string;
}
//#endregion
//#region src/embedded/EmbeddedBitcoinWalletProvider.d.ts
/**
 * Privy embedded wallet provider for Bitcoin accounts.
 *
 * Currently only supports signing messages.
 */
declare class EmbeddedBitcoinWalletProvider {
  /**
   * Sign an arbitrary message
   *
   * @param o the input object
   * @param o.message a byte array to sign
   *
   * @returns a base64-endoed signature
   */
  sign({ message }: {
    message: Uint8Array;
  }): Promise<{
    signature: string;
  }>;
  /**
   * Sign an encoded transaction
   *
   * @param o the input object
   * @param o.txPSBT a bitcoin transaction in PSBT format, hex-encoded
   *
   * @returns a hex-encoded signed transaction
   */
  signTransaction({ psbt }: {
    psbt: string;
  }): Promise<{
    signedTransaction: string;
  }>;
  private request;
  private handleIFrameRpc;
  /**
   * Pretty log output for when an instance of this class is `console.log`'d
   */
  toJSON(): string;
}
//#endregion
//#region src/client/EmbeddedWalletApi.d.ts
/** Options for creating the Solana embedded wallet */
type CreateSolanaOpts = {
  /**
   * The user's existing Ethereum embedded wallet if they have one. This parameter
   * MUST be set if the user has an Ethereum embedded wallet, otherwise Solana creation
   * will fail in the iframe.
   */
  ethereumAccount?: LinkedAccountEthereumEmbeddedWallet;
  /** Optional idempotency key for automatic wallet creation */
  idempotencyKey?: string;
};
declare class EmbeddedWalletApi {
  /**
   * @experimental
   * Sign a message with the user's signer.
   *
   * @param o input options
   * @param o.message the base64 encoded message to sign
   *
   * @returns an object containing the base64 encoded message signature
   */
  signWithUserSigner(opts: {
    message: string;
  }): Promise<{
    signature: string;
  }>;
  /**
   * Add a new embedded wallet account.
   *
   * Requires that the user already have created an embedded wallet via `create`.
   *
   * @param o input options
   * @param o.chainType the type of wallet to create
   * @param o.hdWalletIndex the index of the wallet to create
   * @param o.entropyId the key used to look up the existing wallet
   * @param o.entropyIdVerifier the method used to verify the entropy ID
   *
   * @returns the updated user
   */
  add(opts: {
    chainType: ChainType;
    hdWalletIndex: number;
    entropyId: string;
    entropyIdVerifier: EntropyIdVerifier;
  }): Promise<{
    user: import("@privy-io/api-types").User;
  }>;
  getBitcoinProvider({ wallet, entropyId, entropyIdVerifier, recoveryPassword, recoveryAccessToken, recoverySecretOverride }: {
    wallet: LinkedAccountBitcoinSegwitEmbeddedWallet | LinkedAccountBitcoinTaprootEmbeddedWallet;
    entropyId: string;
    entropyIdVerifier: EntropyIdVerifier;
    recoveryPassword?: string;
    recoveryAccessToken?: string;
    recoverySecretOverride?: string;
  }): Promise<EmbeddedBitcoinWalletProvider>;
  /**
   * Creates an embedded wallet
   *
   * @param password Recovery password for the embedded wallet
   * @param recoveryMethod recovery method to create the wallet with
   * @param recoveryToken access token for recovery
   * @param recoverySecretOverride override for the recovery secret used to encrypt the recovery shares
   * @param iCloudRecordNameOverride override for the icloud record name where the recovery secret is stored in cloud recovery
   * @param solanaAccount The user's existing Solana embedded wallet if they have one. This parameter
   * MUST be set if the user has an Solana embedded wallet, otherwise Ethereum creation
   * will fail in the iframe.
   * @param skipCallbacks whether or not to skip user update callbacks when refreshing the user object
   *
   * @returns the updated user
   */
  create({ password, recoveryMethod, recoveryToken, recoveryKey, recoverySecretOverride, iCloudRecordNameOverride, solanaAccount, skipCallbacks, idempotencyKey }: {
    password?: string;
    recoveryMethod?: IEmbeddedWalletRecoveryOptions;
    recoveryToken?: string;
    recoveryKey?: string;
    recoverySecretOverride?: string;
    iCloudRecordNameOverride?: string;
    solanaAccount?: LinkedAccountSolanaEmbeddedWallet;
    skipCallbacks?: boolean;
    /** Optional idempotency key for automatic wallet creation */
    idempotencyKey?: string;
  }): Promise<Omit<AuthenticatedUser, 'session_update_action'>>;
  /**
   * Creates an embedded Solana wallet
   *
   * @param opts.ethereumAccount the user's existing embedded wallet account if they have one. This parameter
   * MUST be passed if the user has an existing Ethereum embedded wallet otherwise Solana wallet creation will fail.
   *
   * @returns the updated user
   */
  createSolana(opts?: CreateSolanaOpts): Promise<Omit<AuthenticatedUser, 'session_update_action'>>;
  delegateWallets({ delegatedWallets, rootWallet }: {
    delegatedWallets: DelegatedWallet[];
    rootWallet: RootWalletForDelegation;
  }): Promise<void>;
  /**
   * Retrieve this user's embedded wallet.
   * If the wallet has never been used on this device recover.
   *
   * @param password Recovery password for the embedded wallet
   * @returns EmbeddedWalletProvider implementing EIP1193Provider
   */
  getProvider(wallet: LinkedAccountEthereumEmbeddedWallet, recoveryPassword?: string, recoveryAccessToken?: string, recoverySecretOverride?: string, recoveryKey?: string): Promise<EmbeddedWalletProvider>;
  /**
   * Load this user's embedded ethereum wallet through the given entropy.
   * If the wallet has never been used on this device recover.
   *
   * @returns EmbeddedWalletProvider implementing EIP1193Provider
   */
  getEthereumProvider({ wallet, entropyId, entropyIdVerifier, recoveryPassword, recoveryAccessToken, recoverySecretOverride, recoveryKey, onNeedsRecovery }: {
    wallet: LinkedAccountEthereumEmbeddedWallet;
    entropyId: string;
    entropyIdVerifier: EntropyIdVerifier;
    recoveryPassword?: string;
    recoveryAccessToken?: string;
    recoverySecretOverride?: string;
    recoveryKey?: string;
    /**
     * A function that will get called anytime the secure context throws an error that
     * indicates recover is required (i.e. on-demand recovery)
     *
     * @example
     * const provider = await getEthereumProvider({
     *   onNeedsRecovery: async ({recoveryMethod, onRecovered}) => {
     *     await promptRecovery({recoveryMethod})
     *     onRecovered();
     *   },
     * })
     */
    onNeedsRecovery?: OnNeedsRecovery;
  }): Promise<EmbeddedWalletProvider>;
  /**
   * Retrieve this users embedded Solana wallet.
   * If the wallet has never been used on this device recover.
   *
   * @returns EmbeddedSolanaWalletProvider
   */
  getSolanaProvider(account: LinkedAccountSolanaEmbeddedWallet, entropyId: string, entropyIdVerifier: EntropyIdVerifier, recoveryPassword?: string, recoveryAccessToken?: string, recoverySecretOverride?: string,
  /**
   * A function that will get called anytime the secure context throws an error that
   * indicates recover is required (i.e. on-demand recovery)
   *
   * @example
   * const provider = await getEthereumProvider({
   *   onNeedsRecovery: async ({recoveryMethod, onRecovered}) => {
   *     await promptRecovery({recoveryMethod})
   *     onRecovered();
   *   },
   * })
   */
  onNeedsRecovery?: OnNeedsRecovery): Promise<EmbeddedSolanaWalletProvider>;
  /**
   * Add or change the recovery method used to recover an embedded wallet.
   *
   * @param password New recovery password
   * @param currentPassword Current recovery password used to recover the embedded wallet
   * @returns User the user object with the updated embedded wallet.
   * @returns EmbeddedWalletProvider implementing EIP1193Provider if the input wallet is an Ethereum wallet.
   */
  setRecovery(setRecoveryInput: SetRecoveryInput): Promise<SetRecoveryOutput>;
  /**
   * @returns URL to load in the embedded wallet iframe
   */
  getURL(): string;
  /**
   * @deprecated Require higher level SDKs to pass in the chain configuration
   */
  get chains(): NonEmptyArray<Chain>;
  /**
   * Handles messages from the embedded wallet secure contexts
   *
   * @example
   * const onMessage = async (e: WebViewMessageEvent) => {
   *   const {data} = e.nativeEvent;
   *   client.embeddedWallet.onMessage(JSON.parse(data));
   * }
   */
  onMessage(event: PrivyResponseEvent): void;
  reload(): void;
  /** Call when the app backgrounds. The next operation will re-verify WebView responsiveness before proceeding. */
  onBackground(): void;
  ping(timeoutMs: number): Promise<boolean>;
}
//#endregion
//#region src/client/MfaPromises.d.ts
declare class MfaPromises extends EventEmitter<{
  mfaRequired: [];
}> {
  /**
   * This is the root promise for MFA flows. It is resolved or rejected when MFA is complete.
   */
  readonly rootPromise: MfaPromise;
  /**
   * This is the promise for MFA attempts. It is resolved or rejected for every attempt to verify MFA.
   */
  readonly submitPromise: MfaSubmitPromise;
}
//#endregion
//#region src/client/UserApi.d.ts
declare class UserApi {
  private readonly _embedded;
  private readonly _isMultiUserModeEnabled;
  /**
   * Get the logged in user.
   */
  get(): Promise<{
    user: import("@privy-io/api-types").User;
  }>;
  acceptTerms(): Promise<{
    user: import("@privy-io/api-types").User;
  }>;
  /**
   * @experimental
   *
   * Switches the active user to a saved local session and refreshes that user.
   */
  switchActiveUser(o: {
    userId: string;
  }): Promise<{
    user: import("@privy-io/api-types").User;
  }>;
}
//#endregion
//#region src/config/types.d.ts
type CreateOnLogin = 'off' | 'users-without-wallets' | 'all-users';
type EmbeddedWalletConfig = {
  createOnLogin: CreateOnLogin;
};
type LoginOptions = {
  embedded?: {
    ethereum?: EmbeddedWalletConfig;
    solana?: EmbeddedWalletConfig;
  };
};
//#endregion
//#region src/client/auth/CustomProviderApi.d.ts
declare class CustomProviderApi {
  /**
   * Logs a user in via a custom JWT from another (non-Privy) service
   *
   * @param token The JWT from the non-Privy service
   */
  syncWithToken(token: string, opts?: LoginOptions, mode?: 'login-or-sign-up' | 'no-signup'): Promise<Omit<import("@privy-io/api-types").AuthenticatedUser, "session_update_action">>;
  /**
   * Links a custom JWT account to an existing logged-in user
   *
   * @param token The JWT from the non-Privy service
   */
  linkWithToken(token: string): Promise<{
    user: import("@privy-io/api-types").User;
    identity_token: string | undefined;
  }>;
}
//#endregion
//#region src/client/auth/EmailApi.d.ts
declare class EmailApi {
  /**
   * Sends a one time login code to a user's email address
   *
   * @param email The email address to send the one time login code
   * @param token A CAPTCHA token
   */
  sendCode(email: string, token?: string): Promise<{
    success: boolean;
  }>;
  /**
   * Logs a user in via an email address and one time code
   *
   * @param email The email address that the one time code was sent to
   * @param code The one time code
   * @param mode Optional Whether or not to block sign ups (only allow existing users to log in).
   */
  loginWithCode(email: string, code: string, mode?: 'login-or-sign-up' | 'no-signup', opts?: LoginOptions): Promise<Omit<import("@privy-io/api-types").AuthenticatedUser, "session_update_action">>;
  /**
   * Links an email address to an existing user
   *
   * @param email The email address that the one time code was sent to
   * @param code The one time code
   */
  linkWithCode(email: string, code: string): Promise<{
    user: import("@privy-io/api-types").User;
    identity_token: string | undefined;
  }>;
  /**
   * Updates an email address on an existing user
   *
   * @param input.oldEmailAddress The currently linked email address, that will be removed
   * @param input.newEmailAddress The email address the user will be updated to
   * @param input.code The one time code received on the `newEmailAddress`
   */
  updateEmail({ oldEmailAddress, newEmailAddress, code }: {
    oldEmailAddress: string;
    newEmailAddress: string;
    code: string;
  }): Promise<{
    user: import("@privy-io/api-types").User;
    identity_token: string | undefined;
  }>;
  unlink(email: string): Promise<{
    user: import("@privy-io/api-types").User;
    identity_token: string | undefined;
  }>;
}
//#endregion
//#region src/client/auth/FarcasterApi.d.ts
declare class FarcasterApi {
  /**
   * Begin a login / link flow with a farcaster.
   */
  initializeAuth({ relyingParty, redirectUrl, token }: {
    relyingParty?: string;
    redirectUrl?: string;
    token?: string;
  }): Promise<import("@privy-io/api-types").FarcasterConnectInitResponseBody>;
  /**
   * Get the status of a user's SIWF request.
   */
  getFarcasterStatus({ channel_token }: {
    channel_token: string;
  }): Promise<NonNullable<import("@privy-io/api-types").FarcasterConnectStatusCompletedResponseBody | import("@privy-io/api-types").FarcasterConnectStatusPendingResponseBody | undefined>>;
  /**
   * Authenticate with Privy via the Sign-In With Farcaster spec [FIP-11: Sign in with Farcaster](https://github.com/farcasterxyz/protocol/discussions/110).
   */
  authenticate({ channel_token, message, signature, fid, mode }: {
    channel_token: string;
    message: string;
    signature: string;
    fid: number;
    mode?: 'login-or-sign-up' | 'no-signup';
  }, opts?: LoginOptions): Promise<Omit<import("@privy-io/api-types").AuthenticatedUser, "session_update_action">>;
  /**
   * Link with Privy via the Sign-In With Farcaster spec [FIP-11: Sign in with Farcaster](https://github.com/farcasterxyz/protocol/discussions/110).
   */
  link({ channel_token, message, signature, fid }: {
    channel_token: string;
    message: string;
    signature: string;
    fid: number;
  }): Promise<{
    user: import("@privy-io/api-types").User;
    identity_token: string | undefined;
  }>;
  /**
   * Unlink with Privy via the Sign-In With Farcaster spec.
   */
  unlink({ fid }: {
    fid: number;
  }): Promise<{
    user: import("@privy-io/api-types").User;
    identity_token: string | undefined;
  }>;
}
//#endregion
//#region src/client/auth/FarcasterV2Api.d.ts
declare class FarcasterV2Api {
  /**
   * Begin a login / link flow with a farcaster.
   */
  initializeAuth(): Promise<import("@privy-io/api-types").FarcasterV2InitResponseBody>;
  /**
   * Authenticate