@coinbase/cdp-core 0.0.98 → 0.0.100

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

@@ -1,14 +1,50 @@
 import { SpendPermissionNetwork } from '@coinbase/cdp-api-client';
 import { SpendPermissionInput } from '../spend-permissions/types.js';
 import { EvmAddress, Hex } from '../types.js';
+/**
+ * Input for creating a spend permission.
+ * The permission owner is automatically detected from the current user.
+ */
 export type CreateSpendPermissionOptions = Omit<SpendPermissionInput, "account"> & {
+    /** The EVM Smart Account to create the spend permission for. */
     evmSmartAccount: EvmAddress;
+    /** The network to create the spend permission on. */
     network: SpendPermissionNetwork;
+    /**
+     * Whether to use the CDP Paymaster for the user operation.
+     *
+     * Only available on Base. Enabled by default on Base Sepolia.
+     */
     useCdpPaymaster?: boolean;
+    /** The URL of the paymaster to use for the user operation. */
     paymasterUrl?: string;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Result of createSpendPermission.
+ */
 export type CreateSpendPermissionResult = {
+    /** The user operation hash. */
     userOperationHash: Hex;
 };
+/**
+ * Creates a spend permission for the user's EVM Smart Account.
+ *
+ * @param options - The options for creating the spend permission.
+ * @example
+ * ```typescript lines
+ * const result = await createSpendPermission({
+ *   network: "base-sepolia",
+ *   spender: "0x5678...",
+ *   token: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", // ETH
+ *   allowance: "1000000000000000000", // 1 ETH in wei
+ *   period: 86400, // 24 hours
+ *   start: Math.floor(Date.now() / 1000),
+ *   end: Math.floor(Date.now() / 1000) + 86400 * 30, // 30 days from now
+ *   useCdpPaymaster: true
+ * });
+ * ```
+ * @returns The result of the spend permission creation.
+ */
 export declare const createSpendPermission: (options: CreateSpendPermissionOptions) => Promise<CreateSpendPermissionResult>;

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

@@ -0,0 +1,105 @@
+import { EvmSwapsNetwork } from '@coinbase/cdp-api-client';
+import { EvmAddress, Hex, SwapFees } from '../types.js';
+/** Request parameters for executing a token swap. */
+export type ExecuteSwapOptions = {
+    /** The network on which to perform the swap. */
+    network: EvmSwapsNetwork;
+    /** The 0x-prefixed contract address of the token to sell. */
+    fromToken: EvmAddress;
+    /** The 0x-prefixed contract address of the token to buy. */
+    toToken: EvmAddress;
+    /** The amount of fromToken to sell, in atomic units. */
+    fromAmount: string;
+    /** Maximum slippage in basis points (100 = 1%). Default is 100. */
+    slippageBps?: number;
+    /** The taker account address. If omitted, auto-selected from the signed-in user's accounts. */
+    account?: EvmAddress;
+    /** Whether to use the CDP Paymaster for gas sponsorship. Only applicable for smart accounts; ignored for EOA. Cannot be used together with `paymasterUrl`. */
+    useCdpPaymaster?: boolean;
+    /** Custom paymaster URL for gas sponsorship. Only applicable for smart accounts; ignored for EOA. Cannot be used together with `useCdpPaymaster`. */
+    paymasterUrl?: string;
+    /** Optional idempotency key for safe retries. */
+    idempotencyKey?: string;
+};
+type SwapResultBase = {
+    /** The taker address. */
+    account: EvmAddress;
+    /** The network. */
+    network: EvmSwapsNetwork;
+    /** The fromToken address. */
+    fromToken: string;
+    /** The toToken address. */
+    toToken: string;
+    /** Amount of fromToken sold, in atomic units. */
+    fromAmount: string;
+    /** Expected output from the quote, in atomic units. */
+    toAmount: string;
+    /** Minimum guaranteed output, in atomic units. */
+    minToAmount: string;
+    /** Fees as quoted at execute time, or null. */
+    fees: SwapFees | null;
+    /**
+     * The estimated total network cost of the swap.
+     *
+     * On chains where there is no L1 data cost, it is calculated as gas * gasPrice. On chains where there is an L1 data cost, it is calculated as gas * gasPrice + L1 data cost.
+     */
+    totalNetworkFee: string | null;
+};
+/**
+ * Result of a successful swap execution for an EOA account.
+ *
+ * @interface
+ */
+export type ExecuteEvmEoaSwapResult = SwapResultBase & {
+    /** Always "evm-eoa". */
+    type: "evm-eoa";
+    /** The submitted transaction hash. */
+    transactionHash: Hex;
+};
+/**
+ * Result of a successful swap execution for a smart account.
+ *
+ * @interface
+ */
+export type ExecuteEvmSmartSwapResult = SwapResultBase & {
+    /** Always "evm-smart". */
+    type: "evm-smart";
+    /** The user operation hash. */
+    userOpHash: Hex;
+};
+/**
+ * Result of a successful swap execution, discriminated by account type.
+ *
+ * @see {@link ExecuteEvmEoaSwapResult}
+ * @see {@link ExecuteEvmSmartSwapResult}
+ */
+export type ExecuteSwapResult = ExecuteEvmEoaSwapResult | ExecuteEvmSmartSwapResult;
+/**
+ * Executes a token swap on behalf of the signed-in user.
+ * The backend atomically quotes, signs Permit2 (if needed), simulates, and submits the transaction.
+ * Returns immediately with a transaction hash (EOA) or user operation hash (smart account).
+ *
+ * @param options - The swap execution parameters.
+ * @returns A discriminated union result with the transaction/operation hash and swap details.
+ * @throws An {@link InputValidationError} if parameters are invalid.
+ * @throws A {@link SwapError} for known failures (insufficient liquidity/balance/allowance, simulation failure).
+ * @throws An {@link APIError} for auth, network, or server errors.
+ * @example
+ * ```typescript
+ * const result = await executeSwap({
+ *   network: "base",
+ *   fromToken: "0x4200000000000000000000000000000000000006",
+ *   toToken: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+ *   fromAmount: "100000000000000000",
+ *   slippageBps: 100,
+ * });
+ *
+ * if (result.type === "evm-eoa") {
+ *   console.log("Transaction hash:", result.transactionHash);
+ * } else {
+ *   console.log("User operation hash:", result.userOpHash);
+ * }
+ * ```
+ */
+export declare const executeSwap: (options: ExecuteSwapOptions) => Promise<ExecuteSwapResult>;
+export {};

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

@@ -1,2 +1,20 @@
 import { ExportEvmAccountOptions, ExportEvmAccountResult } from '../types.js';
+/**
+ * Exports an EVM account's private key.
+ *
+ * @param options - The options for the exporting.
+ * @param options.evmAccount - The EVM account to export. Found on the user object of the signed in user.
+ * @example
+ * ```typescript lines
+ * const result = await exportEvmAccount({
+ *   evmAccount: "0x1234..."
+ * });
+ * ```
+ * @returns The result of the export.
+ *
+ * @deprecated This function will be removed soon. Use `createEvmKeyExportIframe` instead for a more secure key export experience
+ * that never exposes the private key to your application's JavaScript context.
+ *
+ * @see {@link createEvmKeyExportIframe}
+ */
 export declare const exportEvmAccount: (options: ExportEvmAccountOptions) => Promise<ExportEvmAccountResult>;

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

@@ -1,2 +1,19 @@
 import { ExportSolanaAccountOptions, ExportSolanaAccountResult } from '../types.js';
+/**
+ * Exports the private key of a Solana account.
+ *
+ * @param options - The options for exporting the account.
+ * @example
+ * ```typescript lines
+ * const result = await exportSolanaAccount({
+ *   solanaAccount: "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM"
+ * });
+ * ```
+ * @returns The result of the export.
+ *
+ * @deprecated This function will be removed soon. Use `createSolanaKeyExportIframe` instead for a more secure key export experience
+ * that never exposes the private key to your application's JavaScript context.
+ *
+ * @see {@link createSolanaKeyExportIframe}
+ */
 export declare const exportSolanaAccount: (options: ExportSolanaAccountOptions) => Promise<ExportSolanaAccountResult>;

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

@@ -1,13 +1,40 @@
 import { EvmAddress } from '../types.js';
 import { PaymentRequirementsSelector, X402Config, wrapFetchWithPayment } from 'x402-fetch';
+/**
+ * Options for the fetchWithX402 function.
+ */
 export type FetchWithX402Options = {
+    /** The address of the account to use for the fetch function. */
     address?: EvmAddress | string;
+    /** The fetch function to use for the fetch function. */
     fetch?: typeof globalThis.fetch;
+    /** The maximum allowed payment amount in base units (defaults to 0.1 USDC) */
     maxValue?: bigint;
+    /** A function that selects the payment requirements from the response */
     paymentRequirementsSelector?: PaymentRequirementsSelector;
+    /** Optional configuration for X402 operations (e.g., custom RPC URLs) */
     config?: X402Config;
 };
+/**
+ * Return type for the fetchWithX402 function.
+ */
 export type FetchWithX402ReturnType = {
+    /** The wrapped fetch function with payment handling. */
     fetchWithPayment: ReturnType<typeof wrapFetchWithPayment>;
 };
+/**
+ * Hook that provides a wrapped fetch function with payment handling.
+ *
+ * @param options - Configuration object for the fetch function
+ * @param options.address - The address to use for the fetch function
+ * @returns A wrapped fetch function with payment handling
+ *
+ * @example
+ * ```tsx lines
+ * const { fetchWithPayment } = fetchWithX402();
+ * const response = await fetchWithPayment("https://x402-resource.com", {
+ *   method: "GET",
+ * });
+ * ```
+ */
 export declare function fetchWithX402(options?: FetchWithX402Options): FetchWithX402ReturnType;

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

@@ -1,3 +1,14 @@
+/**
+ * Gets the access token for the current user.
+ *
+ * @param options - The options for getting the token.
+ * @param options.forceRefresh - Whether to force a refresh of the token.
+ * @example
+ * ```typescript lines
+ * const accessToken = await getAccessToken();
+ * ```
+ * @returns The access token for the current user, or null if no user is signed in.
+ */
 export declare const getAccessToken: (options?: {
     forceRefresh: boolean;
 }) => Promise<string | null>;

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

@@ -1 +1,10 @@
+/**
+ * Gets the expiration time of the access token for the current user.
+ *
+ * @example
+ * ```typescript lines
+ * const accessTokenExpiration = await getAccessTokenExpiration();
+ * ```
+ * @returns The expiration time of the access token for the current user, or null if no user is signed in.
+ */
 export declare const getAccessTokenExpiration: () => Promise<number | null>;

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

@@ -1,2 +1,11 @@
 import { User } from '../types.js';
+/**
+ * Gets the currently signed-in user, if any.
+ *
+ * @example
+ * ```typescript lines
+ * const user = await getCurrentUser();
+ * ```
+ * @returns The currently signed-in user, or null if no user is signed in.
+ */
 export declare const getCurrentUser: () => Promise<User | null>;

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

@@ -1,2 +1,11 @@
 import { User } from '../types.js';
+/**
+ * Gets the currently signed-in user, if any.
+ *
+ * @example
+ * ```typescript lines
+ * const user = getCurrentUserSync();
+ * ```
+ * @returns The currently signed-in user, or null if no user is signed in.
+ */
 export declare const getCurrentUserSync: () => User | null;

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

@@ -1,5 +1,17 @@
 import { EvmEip7702DelegationOperation } from '@coinbase/cdp-api-client';
+/**
+ * Options for getting the status of an EIP-7702 delegation operation.
+ */
 export type GetEvmEip7702DelegationOperationOptions = {
+    /** The unique identifier for the delegation operation returned by createEvmEip7702Delegation. */
     delegationOperationId: string;
 };
+/**
+ * Returns the current status of an EIP-7702 delegation operation for an end user's EVM account.
+ * Use the delegationOperationId returned by createEvmEip7702Delegation to poll for operation completion.
+ *
+ * @param options - Options containing the delegation operation ID.
+ * @returns The delegation operation status (PENDING, SUBMITTED, COMPLETED, or FAILED).
+ * @throws Error if the user is not signed in.
+ */
 export declare function getEvmEip7702DelegationOperation(options: GetEvmEip7702DelegationOperationOptions): Promise<EvmEip7702DelegationOperation>;

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

@@ -1,3 +1,20 @@
 import { MfaConfig } from '@coinbase/cdp-api-client';
+/**
+ * Result of getMfaConfig.
+ */
 export type GetMfaConfigResult = MfaConfig;
+/**
+ * Gets the MFA configuration for the current project.
+ * This endpoint returns information about whether MFA is enabled for the project
+ * and the configuration for TOTP authentication.
+ *
+ * @example
+ * ```typescript lines
+ * const result = await getMfaConfig();
+ * if (result?.totpConfig?.enabled) {
+ *   console.log("TOTP MFA is enabled for this project");
+ * }
+ * ```
+ * @returns The MFA configuration for the project.
+ */
 export declare const getMfaConfig: () => Promise<GetMfaConfigResult>;

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

@@ -1,3 +1,16 @@
 import { ProjectConfig } from '@coinbase/cdp-api-client';
+/**
+ * Result of getProjectConfig.
+ */
 export type GetProjectConfigResult = ProjectConfig;
+/**
+ * Gets the project configuration for the current project.
+ *
+ * @example
+ * ```typescript lines
+ * const result = await getProjectConfig();
+ * console.log("Project name:", result.name);
+ * ```
+ * @returns The project configuration.
+ */
 export declare const getProjectConfig: () => Promise<GetProjectConfigResult>;

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

@@ -0,0 +1,85 @@
+import { EvmSwapsNetwork } from '@coinbase/cdp-api-client';
+import { EvmAddress, SwapFees, SwapIssuesAllowance, SwapIssuesBalance } from '../types.js';
+/**
+ * Potential issues discovered during preflight checks that could prevent the swap from being executed successfully. Null if no issues were detected.
+ */
+export type SwapIssues = {
+    /**
+     * Details of the allowance that the `taker` must set in order to execute the swap successfully. Null if no allowance is required.
+     */
+    allowance: SwapIssuesAllowance | null;
+    /**
+     * Details of the `fromToken` balance that the `taker` must hold. Null if the `taker` has a sufficient balance.
+     */
+    balance: SwapIssuesBalance | null;
+};
+/** Request parameters for getting an indicative swap price. */
+export type GetSwapPriceOptions = {
+    /** The network on which to perform the swap. */
+    network: EvmSwapsNetwork;
+    /** The 0x-prefixed contract address of the token to sell. */
+    fromToken: EvmAddress;
+    /** The 0x-prefixed contract address of the token to buy. */
+    toToken: EvmAddress;
+    /** The amount of fromToken to sell, in atomic units. */
+    fromAmount: string;
+    /** Maximum slippage in basis points (100 = 1%). Default is 100. */
+    slippageBps?: number;
+    /** The taker account address. If omitted, auto-selected from the signed-in user's accounts. */
+    account?: EvmAddress;
+};
+/** Returned when liquidity is available for the requested swap. */
+export type GetSwapPriceResult = {
+    /** Always true when this type is returned. */
+    liquidityAvailable: true;
+    /** The network. */
+    network: EvmSwapsNetwork;
+    /** The fromToken address. */
+    fromToken: string;
+    /** The fromAmount in atomic units. */
+    fromAmount: string;
+    /** The toToken address. */
+    toToken: string;
+    /** Expected output at current market price, in atomic units. */
+    toAmount: string;
+    /** Minimum output after slippage, in atomic units. */
+    minToAmount: string;
+    /** Fees to be deducted in this transaction, or null. */
+    fees: SwapFees | null;
+    /** Preflight issues (e.g. insufficient allowance or balance) that may prevent execution, or null. */
+    issues: SwapIssues | null;
+    /**
+     * The estimated total network cost of the swap.
+     *
+     * On chains where there is no L1 data cost, it is calculated as gas * gasPrice. On chains where there is an L1 data cost, it is calculated as gas * gasPrice + L1 data cost.
+     */
+    totalNetworkFee: string | null;
+};
+/** Returned when no swap route exists for the pair/amount. */
+export type SwapUnavailableResult = {
+    /** Always false when this type is returned. */
+    liquidityAvailable: false;
+};
+/**
+ * Gets a non-binding indicative price for a token swap.
+ * Read-only operation — does not modify any on-chain state.
+ *
+ * @param options - The swap price request parameters.
+ * @returns Price estimate if liquidity is available, otherwise `{ liquidityAvailable: false }`.
+ * @throws An {@link InputValidationError} if parameters are invalid.
+ * @throws An Error if the response is missing required fields when liquidity is available.
+ * @example
+ * ```typescript
+ * const price = await getSwapPrice({
+ *   network: "base",
+ *   fromToken: "0x4200000000000000000000000000000000000006",
+ *   toToken: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+ *   fromAmount: "100000000000000000",
+ * });
+ *
+ * if (price.liquidityAvailable) {
+ *   console.log("Expected output:", price.toAmount);
+ * }
+ * ```
+ */
+export declare const getSwapPrice: (options: GetSwapPriceOptions) => Promise<GetSwapPriceResult | SwapUnavailableResult>;

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

@@ -1,2 +1,20 @@
 import { GetUserOperationOptions, GetUserOperationResult } from '../types.js';
+/**
+ * Gets a user operation by its hash.
+ *
+ * @param options - The options for getting the user operation.
+ * @param options.userOperationHash - The user operation hash.
+ * @param options.evmSmartAccount - The EVM Smart Account that sent the user operation.
+ * @param options.network - The network the user operation was sent on.
+ * @example
+ * ```typescript lines
+ * const result = await getUserOperation({
+ *   userOperationHash: "0x123...",
+ *   evmSmartAccount: "0xabc...",
+ *   network: "base-sepolia"
+ * });
+ * console.log("User Operation Status:", result.transactionHash);
+ * ```
+ * @returns The user operation details.
+ */
 export declare const getUserOperation: (options: GetUserOperationOptions) => Promise<GetUserOperationResult>;

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

@@ -1,2 +1,13 @@
 import { Config } from '../types.js';
+/**
+ * Initializes the core package. Must be called before using any other functions.
+ *
+ * @param config - The configuration for the core package.
+ * @example
+ * ```typescript lines
+ * await initialize({
+ *   projectId: "your-project-id", // Your project ID from the CDP Portal
+ * });
+ * ```
+ */
 export declare const initialize: (config: Config) => Promise<void>;

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

@@ -1,21 +1,82 @@
+/**
+ * Request parameters for initiating TOTP MFA enrollment.
+ */
 export type InitiateTotpMfaOptions = {
+    /** The MFA method to use. */
     mfaMethod: "totp";
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Request parameters for initiating SMS MFA enrollment.
+ */
 export type InitiateSmsMfaOptions = {
+    /** The MFA method to use. */
     mfaMethod: "sms";
+    /**
+     * Phone number in E.164 format (e.g., +14155552671).
+     * You can use any phone number for SMS MFA, even if it differs from your SMS authentication phone number.
+     */
     phoneNumber: string;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Request parameters for initiating MFA operations.
+ */
 export type InitiateMfaOptions = InitiateTotpMfaOptions | InitiateSmsMfaOptions;
+/**
+ * Result of TOTP MFA enrollment initiation.
+ */
 export type InitiateTotpMfaResult = {
+    /** The MFA method that was initiated. */
     method: "totp";
+    /** The otpauth:// URL for the authenticator app (for QR code generation). */
     authUrl: string;
+    /** The base32-encoded TOTP secret (for manual entry). */
     secret: string;
 };
+/**
+ * Result of SMS MFA enrollment initiation.
+ */
 export type InitiateSmsMfaResult = {
+    /** The MFA method that was initiated. */
     method: "sms";
+    /** Indicates SMS was sent successfully. */
     success: boolean;
 };
+/**
+ * Result of initiateMfaEnrollment.
+ */
 export type InitiateMfaEnrollmentResult = InitiateTotpMfaResult | InitiateSmsMfaResult;
+/**
+ * Initiates MFA enrollment for an end user.
+ *
+ * For TOTP, this generates a TOTP secret and returns an otpauth:// URL that can be scanned
+ * with an authenticator app like Google Authenticator. The secret must be verified within
+ * 5 minutes by calling submitMfaEnrollment.
+ *
+ * For SMS, this sends a 6-digit OTP code to the provided phone number. The OTP code must
+ * be verified within 5 minutes. You can use any phone number for SMS MFA, even if it differs
+ * from your SMS authentication phone number.
+ *
+ * @param options - The options for initiating MFA enrollment.
+ * @example
+ * ```typescript lines
+ * // TOTP enrollment
+ * const totpResult = await initiateMfaEnrollment({ mfaMethod: "totp" });
+ * // Display totpResult.authUrl as QR code or provide totpResult.secret for manual entry
+ * console.log("Scan this QR code:", totpResult.authUrl);
+ * console.log("Or enter this secret manually:", totpResult.secret);
+ *
+ * // SMS enrollment
+ * const smsResult = await initiateMfaEnrollment({
+ *   mfaMethod: "sms",
+ *   phoneNumber: "+14155552671"
+ * });
+ * console.log("SMS sent:", smsResult.success);
+ * // User receives SMS with 6-digit code
+ * ```
+ * @returns The result containing enrollment details specific to the method.
+ */
 export declare const initiateMfaEnrollment: (options: InitiateMfaOptions) => Promise<InitiateMfaEnrollmentResult>;

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

@@ -1,6 +1,33 @@
 import { MfaMethod } from '@coinbase/cdp-api-client';
+/**
+ * Request parameters for initiating MFA verification.
+ */
 export type InitiateMfaVerificationOptions = {
+    /** The MFA method to verify ("totp" or "sms"). */
     mfaMethod: MfaMethod;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Initiates an MFA verification flow for operations requiring MFA.
+ * This endpoint should be called when a user attempts a sensitive operation
+ * (like transaction signing) but doesn't have a valid MFA-verified session.
+ *
+ * For TOTP, this prepares a verification session.
+ * For SMS, this sends a 6-digit OTP code to the user's enrolled phone number.
+ *
+ * @param options - The options for initiating MFA verification.
+ * @param options.mfaMethod - The MFA method to verify ("totp" or "sms").
+ * @example
+ * ```typescript lines
+ * // TOTP verification
+ * await initiateMfaVerification({ mfaMethod: "totp" });
+ * // Prompt user for code from authenticator app
+ *
+ * // SMS verification
+ * await initiateMfaVerification({ mfaMethod: "sms" });
+ * // SMS sent to user's phone - prompt for code
+ * ```
+ * @returns A promise that resolves if MFA initiation is successful.
+ */
 export declare const initiateMfaVerification: (options: InitiateMfaVerificationOptions) => Promise<void>;

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

@@ -1 +1,13 @@
+/**
+ * Returns whether the user is currently signed in.
+ *
+ * @example
+ * ```typescript lines
+ * const signedIn = await isSignedIn();
+ * if (signedIn) {
+ *   console.log("User is signed in");
+ * }
+ * ```
+ * @returns Whether the user is currently signed in.
+ */
 export declare const isSignedIn: () => Promise<boolean>;

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

@@ -1,3 +1,10 @@
+/**
+ * Links an Apple account to the current user.
+ *
+ * @param options - Optional options for the link operation.
+ * @param options.idempotencyKey - Optional idempotency key for safe retries.
+ * @returns The result of the link Apple initiation.
+ */
 export declare function linkApple(options?: {
     idempotencyKey?: string;
 }): Promise<void>;

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

@@ -1,3 +1,11 @@
+/**
+ * Links an email account to the current user.
+ *
+ * @param email - The email address to link.
+ * @param options - Optional options for the link operation.
+ * @param options.idempotencyKey - Optional idempotency key for safe retries.
+ * @returns The result of the link email initiation.
+ */
 export declare function linkEmail(email: string, options?: {
     idempotencyKey?: string;
 }): Promise<{

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

@@ -1 +1,6 @@
+/**
+ * Links a Google account to the current user.
+ *
+ * @returns The result of the link Google initiation.
+ */
 export declare function linkGoogle(): Promise<void>;

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

@@ -1,4 +1,12 @@
 import { OAuth2ProviderType } from '@coinbase/cdp-api-client';
+/**
+ * Links an OAuth account to the current user.
+ *
+ * @param providerType - The OAuth provider type (e.g., "google", "apple", "x", "telegram").
+ * @param options - Optional options for the link operation.
+ * @param options.idempotencyKey - Optional idempotency key for safe retries.
+ * @returns The result of the link OAuth initiation.
+ */
 export declare function linkOAuth(providerType: OAuth2ProviderType, options?: {
     idempotencyKey?: string;
 }): Promise<void>;

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

@@ -1,3 +1,11 @@
+/**
+ * Links a SMS account to the current user.
+ *
+ * @param phoneNumber - The phone number to link.
+ * @param options - Optional options for the link operation.
+ * @param options.idempotencyKey - Optional idempotency key for safe retries.
+ * @returns The result of the link SMS initiation.
+ */
 export declare function linkSms(phoneNumber: string, options?: {
     idempotencyKey?: string;
 }): Promise<{