@coinbase/cdp-core 0.0.98 → 0.0.99

package/dist/web-types/actions/sendSolanaUsdc.d.ts

@@ -1,15 +1,75 @@
 import { SolanaAddress } from '../types.js';
+/**
+ * The Solana network to send USDC on.
+ */
 export type SendSolanaUsdcNetwork = "solana" | "solana-devnet";
+/** Request parameters for sending Solana USDC. */
 export type SendSolanaUsdcOptions = {
+    /** The Solana account to send USDC from. */
     solanaAccount: SolanaAddress;
+    /** The recipient address (base58 encoded). */
     to: SolanaAddress;
+    /** The amount of USDC to send in human-readable format (e.g., "1.50" for 1.5 USDC). */
     amount: string;
+    /** The network to send USDC on. */
     network: SendSolanaUsdcNetwork;
+    /**
+     * Whether to automatically create an Associated Token Account (ATA) for the recipient if it doesn't exist.
+     *
+     * @default false
+     *
+     * **Important**: Creating an ATA requires ~0.002 SOL (~$0.20) for rent exemption, which the sender pays.
+     *
+     * - Set to `true` if you want to ensure the transaction succeeds by creating the recipient's ATA if needed
+     * - Set to `false` (default) to only send if the recipient already has a USDC token account
+     *
+     * If `false` and the recipient doesn't have an ATA, the transaction will fail with a clear error message.
+     */
     createRecipientAta?: boolean;
+    /** Whether transaction fees should be sponsored by CDP. When true, CDP sponsors the transaction fee. */
     useCdpSponsor?: boolean;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/** Result of sendSolanaUsdc. */
 export type SendSolanaUsdcResult = {
+    /** The transaction signature. */
     transactionSignature: string;
 };
+/**
+ * Sends USDC on the Solana network.
+ *
+ * @param options - The options for sending USDC.
+ * @param options.solanaAccount - The Solana account to send USDC from. Found on the user object of the signed in user.
+ * @param options.to - The recipient address (base58 encoded).
+ * @param options.amount - The amount of USDC to send in human-readable format (e.g., "1.50" for 1.5 USDC).
+ * @param options.network - The network to send USDC on.
+ * @param options.createRecipientAta - Whether to automatically create an Associated Token Account (ATA) for the recipient if it doesn't exist. Defaults to false.
+ * @param options.useCdpSponsor - Whether transaction fees should be sponsored by CDP. When true, CDP sponsors the transaction fee.
+ * @example
+ * ```typescript
+ * const user = await getCurrentUser();
+ * const solanaAccount = user?.solanaAccountObjects[0]?.address;
+ *
+ * // Send to recipient with existing USDC account (default behavior)
+ * const result = await sendSolanaUsdc({
+ *   solanaAccount,
+ *   to: "ExXhNkgYf6efh7YyqDRVxPZuzafobao1A74drUdp8trd",
+ *   amount: "10.00",
+ *   network: "solana-devnet",
+ * });
+ *
+ * // Or explicitly create recipient's ATA if needed (~0.002 SOL cost)
+ * const resultWithAta = await sendSolanaUsdc({
+ *   solanaAccount,
+ *   to: "ExXhNkgYf6efh7YyqDRVxPZuzafobao1A74drUdp8trd",
+ *   amount: "10.00",
+ *   network: "solana-devnet",
+ *   createRecipientAta: true, // Sender pays for recipient's ATA creation
+ * });
+ *
+ * console.log("Transaction Signature:", result.transactionSignature);
+ * ```
+ * @returns The result of sending USDC.
+ */
 export declare const sendSolanaUsdc: (options: SendSolanaUsdcOptions) => Promise<SendSolanaUsdcResult>;

package/dist/web-types/actions/sendUsdc.d.ts

@@ -1,35 +1,71 @@
 import { SendSolanaUsdcNetwork } from './sendSolanaUsdc.js';
 import { EvmAddress, SolanaAddress, SendEvmUsdcNetwork, Hex } from '../types.js';
+/**
+ * The network to send USDC on - supports both EVM and Solana networks.
+ */
 export type SendUsdcNetwork = SendEvmUsdcNetwork | SendSolanaUsdcNetwork;
+/**
+ * Request parameters for sending USDC.
+ * Uses discriminated unions to prevent invalid parameter combinations at compile-time.
+ */
 export type SendUsdcOptions = {
+    /** Explicitly sending from an EVM address (EOA or Smart Account). */
     from: EvmAddress;
+    /** Recipient EVM address. */
     to: EvmAddress;
+    /** The amount of USDC to send (e.g., "1.50"). */
     amount: string;
+    /** EVM network to send on. */
     network: SendEvmUsdcNetwork;
+    /** Whether to use CDP Paymaster to sponsor gas fees (Smart Accounts only). */
     useCdpPaymaster?: boolean;
+    /** Optional custom Paymaster URL (Smart Accounts only). */
     paymasterUrl?: string;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 } | {
+    /** Explicitly sending from a Solana address. */
     from: SolanaAddress;
+    /** Recipient Solana address. */
     to: SolanaAddress;
+    /** The amount of USDC to send (e.g., "1.50"). */
     amount: string;
+    /** Solana network to send on. */
     network: SendSolanaUsdcNetwork;
+    /** Whether to create recipient's ATA if needed (~0.002 SOL cost). */
     createRecipientAta?: boolean;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 } | {
+    /**
+     * Auto-select mode for EVM - sender address will be automatically selected if exactly one account exists.
+     */
     to: EvmAddress;
+    /** The amount of USDC to send (e.g., "1.50"). */
     amount: string;
+    /** EVM network to send on. */
     network: SendEvmUsdcNetwork;
+    /** Whether to use CDP Paymaster (only used if Smart Account is selected). */
     useCdpPaymaster?: boolean;
+    /** Optional custom Paymaster URL (only used if Smart Account is selected). */
     paymasterUrl?: string;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 } | {
+    /**
+     * Auto-select mode for Solana - sender address will be automatically selected if exactly one account exists.
+     */
     to: SolanaAddress;
+    /** The amount of USDC to send (e.g., "1.50"). */
     amount: string;
+    /** Solana network to send on. */
     network: SendSolanaUsdcNetwork;
+    /** Whether to create recipient's ATA if needed (~0.002 SOL cost). */
     createRecipientAta?: boolean;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/** Result of sendUsdc - discriminated union based on account type. */
 export type SendUsdcResult = {
     type: "evm-eoa";
     transactionHash: Hex;
@@ -46,4 +82,47 @@ export type SendUsdcResult = {
     from: SolanaAddress;
     network: SendSolanaUsdcNetwork;
 };
+/**
+ * Sends USDC on EVM or Solana networks with automatic address type detection.
+ * Automatically determines if the sender is an EOA, Smart Account, or Solana account
+ * and routes to the appropriate sending function.
+ *
+ * If `from` is not provided, automatically selects the address only when there is exactly
+ * one account to avoid ambiguity. If multiple accounts exist, explicit selection is required.
+ *
+ * @param options - The options for sending USDC. See {@link SendUsdcOptions} for all available parameters.
+ *
+ * @example
+ * ```typescript
+ * // Simplest usage - auto-selects sender when user has exactly one account
+ * const result = await sendUsdc({
+ *   to: "0x1234567890123456789012345678901234567890",
+ *   amount: "10.00",
+ *   network: "base-sepolia",
+ * });
+ *
+ * // Send from Smart Account with gas sponsorship
+ * const smartResult = await sendUsdc({
+ *   from: user.evmSmartAccountObjects[0].address,
+ *   to: "0x1234567890123456789012345678901234567890",
+ *   amount: "10.00",
+ *   network: "base",
+ *   useCdpPaymaster: true,
+ * });
+ * // Result: { type: "evm-smart", userOpHash: "0x..." }
+ *
+ * // Send from Solana account
+ * const solanaResult = await sendUsdc({
+ *   from: user.solanaAccountObjects[0].address,
+ *   to: "ExXhNkgYf6efh7YyqDRVxPZuzafobao1A74drUdp8trd",
+ *   amount: "10.00",
+ *   network: "solana-devnet",
+ *   createRecipientAta: true,
+ * });
+ * // Result: { type: "solana", transactionSignature: "..." }
+ * ```
+ *
+ * @returns A discriminated union result indicating the account type and transaction identifier.
+ * @throws If addresses are invalid, mismatched types, user doesn't own the sender account, or no accounts available.
+ */
 export declare const sendUsdc: (options: SendUsdcOptions) => Promise<SendUsdcResult>;

package/dist/web-types/actions/sendUserOperation.d.ts

@@ -1,2 +1,31 @@
 import { SendUserOperationOptions, SendUserOperationResult } from '../types.js';
+/**
+ * Sends a user operation from a smart account.
+ *
+ * @param options - The options for sending the user operation.
+ * @param options.evmSmartAccount - The EVM Smart Account to send the user operation with.
+ * @param options.network - The network to send the user operation on.
+ * @param options.calls - The calls to make from the user operation.
+ * @param options.paymasterUrl - The URL of the paymaster to use for the user operation.
+ * Get your free Base paymaster URL [from the CDP Portal](https://portal.cdp.coinbase.com/products/node).
+ * @param options.dataSuffix - Optional hex-encoded data suffix to append to the user operation callData for attribution (ERC-8021).
+ * @returns Promise that resolves to the user operation hash.
+ * @example
+ * ```typescript lines
+ * const user = await getCurrentUser();
+ * const smartAccount = user?.evmSmartAccountObjects[0]?.address;
+ *
+ * const result = await sendUserOperation({
+ *   evmSmartAccount: smartAccount,
+ *   network: "base-sepolia",
+ *   calls: [{
+ *     to: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+ *     value: 0n,
+ *     data: "0x",
+ *   }],
+ *   dataSuffix: "0x62617365617070070080218021802180218021802180218021", // ERC-8021 attribution
+ * });
+ * console.log("User Operation Hash:", result.userOperationHash);
+ * ```
+ */
 export declare const sendUserOperation: (options: SendUserOperationOptions) => Promise<SendUserOperationResult>;

package/dist/web-types/actions/signEvmHash.d.ts

@@ -1,2 +1,17 @@
 import { SignEvmHashOptions, SignEvmHashResult } from '../types.js';
+/**
+ * Signs a hash with an EVM account.
+ *
+ * @param options - The options for the signing.
+ * @param options.evmAccount - The EVM account to sign the hash with. Found on the user object of the signed in user.
+ * @param options.hash - The hash to sign.
+ * @example
+ * ```typescript lines
+ * const result = await signEvmHash({
+ *   evmAccount: "0x1234...",
+ *   hash: "0xabcd..." // 32-byte hex string to sign
+ * });
+ * ```
+ * @returns The result of the signing.
+ */
 export declare const signEvmHash: (options: SignEvmHashOptions) => Promise<SignEvmHashResult>;

package/dist/web-types/actions/signEvmMessage.d.ts

@@ -1,2 +1,21 @@
 import { SignEvmMessageOptions, SignEvmHashResult } from '../types.js';
+/**
+ * Signs an EVM message.
+ *
+ * @param options - The options for the signing.
+ * @param options.evmAccount - The EVM account to sign the message with. Found on the user object of the signed in user.
+ * @param options.message - The message to sign.
+ * @example
+ * ```typescript lines
+ * const user = await getCurrentUser();
+ * const evmAccount = user?.evmAccountObjects[0]?.address;
+ *
+ * const result = await signEvmMessage({
+ *   evmAccount,
+ *   message: "Hello World" // Message to sign
+ * });
+ *
+ * ```
+ * @returns The result of the signing.
+ */
 export declare const signEvmMessage: (options: SignEvmMessageOptions) => Promise<SignEvmHashResult>;

package/dist/web-types/actions/signEvmTransaction.d.ts

@@ -1,2 +1,29 @@
 import { SignEvmTransactionOptions, SignEvmTransactionResult } from '../types.js';
+/**
+ * Signs a hash with an EVM account.
+ *
+ * @param options - The options for the signing.
+ * @param options.evmAccount - The EVM account to sign the transaction with. Found on the user object of the signed in user.
+ * @param options.transaction - The transaction to sign.
+ * @example
+ * ```typescript lines
+ * const user = await getCurrentUser();
+ * const evmAccount = user?.evmAccountObjects[0]?.address;
+ *
+ * const result = await signEvmTransaction({
+ *   evmAccount,
+ *   transaction: {
+ *     to: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+ *     value: 100000000000000n, // 0.0001 ETH in wei
+ *     nonce: 0,
+ *     gas: 21000n,
+ *     maxFeePerGas: 30000000000n,
+ *     maxPriorityFeePerGas: 1000000000n,
+ *     chainId: 84532, // Base Sepolia
+ *     type: "eip1559",
+ *   }
+ * });
+ * ```
+ * @returns The result of the signing.
+ */
 export declare const signEvmTransaction: (options: SignEvmTransactionOptions) => Promise<SignEvmTransactionResult>;

package/dist/web-types/actions/signEvmTypedData.d.ts

@@ -1,2 +1,52 @@
 import { SignEvmTypedDataOptions, SignEvmTypedDataResult } from '../types.js';
+/**
+ * Signs EIP-712 typed data with an EVM account.
+ *
+ * @param options - The options for the signing.
+ * @param options.evmAccount - The EVM account to sign the typed data with. Found on the user object of the signed in user.
+ * @param options.typedData - The typed data to sign.
+ * @example
+ * ```typescript lines
+ * const user = await getCurrentUser();
+ * const evmAccount = user?.evmAccountObjects[0]?.address;
+ *
+ * const result = await signEvmTypedData({
+ *   evmAccount,
+ *   typedData: {
+ *     domain: {
+ *       name: "USDC",
+ *       version: "2",
+ *       chainId: 84532,
+ *       verifyingContract: "0x036CbD53842c5426634e7929541eC2318f3dCF7e", // Base Sepolia USDC
+ *     },
+ *     types: {
+ *       EIP712Domain: [
+ *         { name: "name", type: "string" },
+ *         { name: "version", type: "string" },
+ *         { name: "chainId", type: "uint256" },
+ *         { name: "verifyingContract", type: "address" },
+ *       ],
+ *       TransferWithAuthorization: [
+ *         { name: "from", type: "address" },
+ *         { name: "to", type: "address" },
+ *         { name: "value", type: "uint256" },
+ *         { name: "validAfter", type: "uint256" },
+ *         { name: "validBefore", type: "uint256" },
+ *         { name: "nonce", type: "bytes32" },
+ *       ],
+ *     },
+ *     primaryType: "TransferWithAuthorization",
+ *     message: {
+ *       from: evmAccount,
+ *       to: "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB",
+ *       value: "1000000", // 1 USDC (6 decimals)
+ *       validAfter: 0, // Valid immediately
+ *       validBefore: 2524604400, // Valid until 2050
+ *       nonce: 0
+ *     },
+ *   },
+ * });
+ * ```
+ * @returns The result of the signing.
+ */
 export declare const signEvmTypedData: (options: SignEvmTypedDataOptions) => Promise<SignEvmTypedDataResult>;

package/dist/web-types/actions/signInWithEmail.d.ts

@@ -1,2 +1,14 @@
 import { SignInWithEmailOptions, SignInWithEmailResult } from '../types.js';
+/**
+ * Initiates the sign in flow with an email.
+ *
+ * @param options - The options for the sign in.
+ * @example
+ * ```typescript lines
+ * const result = await signInWithEmail({
+ *   email: "user@example.com"
+ * });
+ * ```
+ * @returns The result of the sign in.
+ */
 export declare const signInWithEmail: (options: SignInWithEmailOptions) => Promise<SignInWithEmailResult>;

package/dist/web-types/actions/signInWithOAuth.d.ts

@@ -1,4 +1,44 @@
 import { OAuth2ProviderType } from '@coinbase/cdp-api-client';
+/**
+ * Initiates the sign in flow with an OAuth provider (Google, Apple, Telegram, and X are currently supported).
+ * In a web application, this will redirect the user to the OAuth provider's sign in page.
+ * This sign in method is not yet supported on mobile.
+ *
+ * @param providerType - The type of OAuth provider to sign in with.
+ * @param options - Optional options for the sign in.
+ * @param options.idempotencyKey - Optional idempotency key for safe retries.
+ * @returns The result of the sign in.
+ *
+ * @example
+ * ```typescript lines
+ * // Google
+ * try {
+ *  void signInWithOAuth("google");
+ * } catch (error) {
+ *   console.error("Failed to sign in with Google:", error);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript lines
+ * // Apple
+ * try {
+ *  void signInWithOAuth("apple");
+ * } catch (error) {
+ *  console.error("Failed to sign in with Apple:", error);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript lines
+ * // X
+ * try {
+ *  void signInWithOAuth("x");
+ * } catch (error) {
+ *  console.error("Failed to sign in with X:", error);
+ * }
+ * ```
+ */
 export declare const signInWithOAuth: (providerType: OAuth2ProviderType, options?: {
     idempotencyKey?: string;
 }) => Promise<void>;

package/dist/web-types/actions/signInWithSms.d.ts

@@ -1,2 +1,14 @@
 import { SignInWithSmsOptions, SignInWithSmsResult } from '../types.js';
+/**
+ * Initiates the sign in flow with a phone number via SMS.
+ *
+ * @param options - The options for the sign in.
+ * @example
+ * ```typescript lines
+ * const result = await signInWithSms({
+ *   phoneNumber: "+14155552671"
+ * });
+ * ```
+ * @returns The result of the sign in.
+ */
 export declare const signInWithSms: (options: SignInWithSmsOptions) => Promise<SignInWithSmsResult>;

package/dist/web-types/actions/signOut.d.ts

@@ -1 +1,9 @@
+/**
+ * Signs out the end user, clearing all authentication state.
+ *
+ * @example
+ * ```typescript lines
+ * await signOut();
+ * ```
+ */
 export declare const signOut: () => Promise<void>;

package/dist/web-types/actions/signSolanaMessage.d.ts

@@ -1,2 +1,22 @@
 import { SignSolanaMessageOptions, SignSolanaMessageResult } from '../types.js';
+/**
+ * Signs a message with a Solana account.
+ *
+ * @param options - The options for the signing.
+ * @param options.solanaAccount - The Solana account to sign the message with. Found on the user object of the signed in user.
+ * @param options.message - The message to sign (base64 encoded).
+ * @example
+ * ```typescript lines
+ * const user = await getCurrentUser();
+ * const solanaAccount = user?.solanaAccountObjects[0]?.address;
+ *
+ * const message = Buffer.from("Hello, Solana!", "utf8").toString("base64");
+ * const result = await signSolanaMessage({
+ *   solanaAccount,
+ *   message // Base64 encoded message to sign
+ * });
+ *
+ * ```
+ * @returns The result of the signing.
+ */
 export declare const signSolanaMessage: (options: SignSolanaMessageOptions) => Promise<SignSolanaMessageResult>;

package/dist/web-types/actions/signSolanaTransaction.d.ts

@@ -1,2 +1,20 @@
 import { SignSolanaTransactionOptions, SignSolanaTransactionResult } from '../types.js';
+/**
+ * Signs a Solana transaction.
+ *
+ * @param options - The options for the signing.
+ * @param options.solanaAccount - The Solana account to sign the transaction with. Found on the user object of the signed in user.
+ * @param options.transaction - The base64 encoded transaction to sign.
+ * @example
+ * ```typescript lines
+ * const user = await getCurrentUser();
+ * const solanaAccount = user?.solanaAccountObjects[0]?.address;
+ *
+ * const result = await signSolanaTransaction({
+ *   solanaAccount,
+ *   transaction: "base64-encoded-transaction"
+ * });
+ * ```
+ * @returns The result of the signing.
+ */
 export declare const signSolanaTransaction: (options: SignSolanaTransactionOptions) => Promise<SignSolanaTransactionResult>;

package/dist/web-types/actions/submitMfaEnrollment.d.ts

@@ -1,11 +1,48 @@
 import { MfaMethod } from '@coinbase/cdp-api-client';
 import { User } from '../types.js';
+/**
+ * Request parameters for submitMfaEnrollment.
+ */
 export type SubmitMfaEnrollmentOptions = {
     mfaMethod: MfaMethod;
+    /** The 6-digit MFA code from the authenticator app (TOTP) or from SMS. */
     mfaCode: string;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Result of submitMfaEnrollment.
+ */
 export type SubmitMfaEnrollmentResult = {
+    /** The updated user with MFA enrollment. */
     user: User;
 };
+/**
+ * Submits an MFA code to complete the enrollment process.
+ * On success, the MFA configuration is persisted to the end user.
+ *
+ * For TOTP, this validates the code from the user's authenticator app.
+ * For SMS, this validates the code received via text message.
+ *
+ * @param options - The options for the submission.
+ * @param options.mfaMethod - The MFA method being enrolled ("totp" or "sms").
+ * @param options.mfaCode - The 6-digit MFA code from the authenticator app (TOTP) or from SMS.
+ * @example
+ * ```typescript lines
+ * // TOTP enrollment
+ * const totpResult = await submitMfaEnrollment({
+ *   mfaMethod: "totp",
+ *   mfaCode: "123456"
+ * });
+ *
+ * // SMS enrollment
+ * const smsResult = await submitMfaEnrollment({
+ *   mfaMethod: "sms",
+ *   mfaCode: "654321"
+ * });
+ *
+ * console.log("MFA enrolled for user:", smsResult.user.userId);
+ * ```
+ * @returns The result containing the updated user.
+ */
 export declare const submitMfaEnrollment: (options: SubmitMfaEnrollmentOptions) => Promise<SubmitMfaEnrollmentResult>;

package/dist/web-types/actions/submitMfaVerification.d.ts

@@ -1,7 +1,37 @@
 import { MfaMethod } from '@coinbase/cdp-api-client';
+/**
+ * Request parameters for submitMfaVerification.
+ */
 export type SubmitMfaVerificationOptions = {
     mfaMethod: MfaMethod;
+    /** The 6-digit MFA code from the authenticator app (TOTP) or from SMS. */
     mfaCode: string;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Submits an MFA code to complete the verification process.
+ *
+ * After successful verification, any pending operation that was waiting for MFA
+ * will automatically continue.
+ *
+ * @param options - The options for the verification.
+ * @param options.mfaMethod - The MFA method being verified ("totp" or "sms").
+ * @param options.mfaCode - The 6-digit MFA code from the authenticator app (TOTP) or from SMS.
+ * @example
+ * ```typescript lines
+ * // TOTP verification
+ * await submitMfaVerification({
+ *   mfaMethod: "totp",
+ *   mfaCode: "123456"
+ * });
+ *
+ * // SMS verification
+ * await submitMfaVerification({
+ *   mfaMethod: "sms",
+ *   mfaCode: "654321"
+ * });
+ * ```
+ * @returns A promise that resolves if MFA verification is successful.
+ */
 export declare const submitMfaVerification: (options: SubmitMfaVerificationOptions) => Promise<void>;

package/dist/web-types/actions/verifyEmailOTP.d.ts

@@ -1,2 +1,15 @@
 import { VerifyEmailOTPOptions, VerifyEmailOTPResult } from '../types.js';
+/**
+ * Verifies the one-time password (OTP) for the sign in flow with an email.
+ *
+ * @param options - The options for the verification.
+ * @example
+ * ```typescript lines
+ * const result = await verifyEmailOTP({
+ *   flowId: "flow-id-from-signInWithEmail",
+ *   otp: "123456" // The OTP received in email
+ * });
+ * ```
+ * @returns The result of the verification.
+ */
 export declare const verifyEmailOTP: (options: VerifyEmailOTPOptions) => Promise<VerifyEmailOTPResult>;

package/dist/web-types/actions/verifyOAuth.d.ts

@@ -1,2 +1,38 @@
 import { VerifyOAuthOptions, VerifyOAuthResult } from '../types.js';
+/**
+ * Verifies the OAuth code for the sign in flow with a OAuth provider.
+ *
+ * @param options - The options for the verification.
+ * @returns The result of the verification.
+ *
+ * @example
+ * ```typescript lines
+ * // Google
+ * const result = await verifyOAuth({
+ *   flowId: "flow-id-from-signInWithGoogle",
+ *   code: "123456", // The OAuth code received from the OAuth provider
+ *   providerType: "google",
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript lines
+ * // Apple
+ * const result = await verifyOAuth({
+ *   flowId: "flow-id-from-signInWithApple",
+ *   code: "123456", // The OAuth code received from the OAuth provider
+ *   providerType: "apple",
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript lines
+ * // X
+ * const result = await verifyOAuth({
+ *   flowId: "flow-id-from-signInWithX",
+ *   code: "123456", // The OAuth code received from the OAuth provider
+ *   providerType: "x",
+ * });
+ * ```
+ */
 export declare const verifyOAuth: (options: VerifyOAuthOptions) => Promise<VerifyOAuthResult>;

package/dist/web-types/actions/verifySmsOTP.d.ts

@@ -1,2 +1,15 @@
 import { VerifySmsOTPOptions, VerifySmsOTPResult } from '../types.js';
+/**
+ * Verifies the one-time password (OTP) for the sign in flow with a phone number via SMS.
+ *
+ * @param options - The options for the verification.
+ * @example
+ * ```typescript lines
+ * const result = await verifySmsOTP({
+ *   flowId: "flow-id-from-signInWithSms",
+ *   otp: "123456" // The OTP received in SMS
+ * });
+ * ```
+ * @returns The result of the verification.
+ */
 export declare const verifySmsOTP: (options: VerifySmsOTPOptions) => Promise<VerifySmsOTPResult>;

package/dist/web-types/actions/verifyTelegramOAuth.d.ts

@@ -1,2 +1,8 @@
 import { VerifyOAuthResult, VerifyTelegramOAuthOptions } from '../types.js';
+/**
+ * Verifies a Telegram OAuth authentication by calling the verifyOAuthEndUserIdentity endpoint.
+ *
+ * @param options - The options containing the flowId and Telegram auth data from the popup.
+ * @returns The result of the verification.
+ */
 export declare const verifyTelegramOAuth: (options: VerifyTelegramOAuthOptions) => Promise<VerifyOAuthResult>;