@rhinestone/1auth 0.1.1 → 0.4.0

package/dist/{client-B-HGKKaJ.d.ts → client-DKuPEx83.d.ts}

@@ -10,8 +10,8 @@ interface ThemeConfig {
 interface PasskeyProviderConfig {
     /** Base URL of the auth API. Defaults to https://passkey.1auth.box */
     providerUrl?: string;
-    /** Client identifier for this application */
-    clientId: string;
+    /** Client identifier for this application (optional for development) */
+    clientId?: string;
     /** Optional redirect URL for redirect flow */
     redirectUrl?: string;
     /** Optional URL of the dialog UI. Defaults to providerUrl */
@@ -25,6 +25,7 @@ interface LoginOptions {
 interface LoginResult {
     success: boolean;
     username?: string;
+    address?: string;
     user?: {
         id: string;
         username: string;
@@ -40,6 +41,25 @@ interface RegisterOptions {
 interface RegisterResult {
     success: boolean;
     username?: string;
+    address?: string;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Result of the connect modal (lightweight connection without passkey auth)
+ */
+interface ConnectResult {
+    success: boolean;
+    /** Username of the connected account */
+    username?: string;
+    /** Account address */
+    address?: string;
+    /** Whether this was auto-connected (user had auto-connect enabled) */
+    autoConnected?: boolean;
+    /** Action to take when connection was not successful */
+    action?: "switch" | "cancel";
     error?: {
         code: string;
         message: string;
@@ -77,7 +97,7 @@ interface AuthenticateResult {
     signature?: WebAuthnSignature;
     /**
      * The hash that was actually signed (so apps can verify server-side).
-     * Computed as: keccak256("\x19Passkey Signed Message:\n" + len + challenge)
+     * Computed as: keccak256("\x19Ethereum Signed Message:\n" + len + challenge) (EIP-191)
      */
     signedHash?: `0x${string}`;
     error?: {
@@ -89,8 +109,10 @@ interface AuthenticateResult {
  * Options for signMessage
  */
 interface SignMessageOptions {
-    /** Username of the signer */
-    username: string;
+    /** Username of the signer (required if accountAddress is not provided) */
+    username?: string;
+    /** Account address of the signer (alternative to username) */
+    accountAddress?: string;
     /** Human-readable message to sign */
     message: string;
     /** Optional custom challenge (defaults to message hash) */
@@ -112,8 +134,8 @@ interface SignMessageResult {
     /** The message that was signed */
     signedMessage?: string;
     /**
-     * The hash that was actually signed (with domain separator).
-     * Computed as: keccak256("\x19Passkey Signed Message:\n" + len + message)
+     * The hash that was actually signed (EIP-191 format).
+     * Computed as: keccak256("\x19Ethereum Signed Message:\n" + len + message)
      * Use hashMessage() from the SDK to verify this matches your original message.
      */
     signedHash?: `0x${string}`;
@@ -125,12 +147,26 @@ interface SignMessageResult {
         message: string;
     };
 }
+interface ClearSignData {
+    decoded: boolean;
+    verified: boolean;
+    functionName?: string;
+    intent?: string;
+    args?: Array<{
+        name: string;
+        type: string;
+        value: string;
+        label?: string;
+    }>;
+    selector?: string;
+}
 interface TransactionAction {
-    type: 'send' | 'receive' | 'approve' | 'swap' | 'mint' | 'custom';
+    type: 'send' | 'receive' | 'approve' | 'swap' | 'mint' | 'custom' | 'module_install';
     label: string;
     sublabel?: string;
     amount?: string;
     icon?: string;
+    clearSign?: ClearSignData;
 }
 interface TransactionFees {
     estimated: string;
@@ -186,8 +222,14 @@ interface PasskeyCredentials {
 interface SigningSuccess {
     success: true;
     requestId?: string;
-    signature: WebAuthnSignature;
+    /** WebAuthn signature - present for message/typedData signing */
+    signature?: WebAuthnSignature;
+    /** Array of signatures for multi-origin cross-chain intents (one per source chain) */
+    originSignatures?: WebAuthnSignature[];
+    /** Credentials of the passkey used for signing - present for message/typedData signing */
     passkey?: PasskeyCredentials;
+    /** Intent ID - present for intent signing (after execute in dialog) */
+    intentId?: string;
 }
 type SigningErrorCode = "USER_REJECTED" | "EXPIRED" | "INVALID_REQUEST" | "NETWORK_ERROR" | "POPUP_BLOCKED" | "SIGNING_FAILED" | "UNKNOWN";
 interface EmbedOptions {
@@ -242,21 +284,21 @@ interface IntentCall {
 interface IntentTokenRequest {
     /** Token contract address */
     token: string;
-    /** Amount (as string for serialization) */
-    amount: string;
+    /** Amount in base units (use parseUnits for decimals) */
+    amount: bigint;
 }
 /**
  * A signed intent request from a backend.
  * This provides XSS protection by ensuring calls were constructed server-side.
  */
-interface MerchantSignedIntent {
+interface DeveloperSignedIntent {
     /** Developer ID (clientId). Mapped to merchantId for the API. */
     developerId?: string;
     /** Wire field used by the API (same value as developerId) */
     merchantId?: string;
     /** Target chain ID */
     targetChain: number;
-    /** Calls to execute (signed by merchant) */
+    /** Calls to execute (signed by developer) */
     calls: IntentCall[];
     /** Username of the signer */
     username?: string;
@@ -273,6 +315,8 @@ interface MerchantSignedIntent {
     /** Optional token requests */
     tokenRequests?: IntentTokenRequest[];
 }
+/** @deprecated Use DeveloperSignedIntent instead */
+type MerchantSignedIntent = DeveloperSignedIntent;
 type IntentSigner = (params: {
     username: string;
     accountAddress?: string;
@@ -280,13 +324,15 @@ type IntentSigner = (params: {
     calls: IntentCall[];
     tokenRequests?: IntentTokenRequest[];
     sourceAssets?: string[];
-}) => Promise<MerchantSignedIntent>;
+}) => Promise<DeveloperSignedIntent>;
 /**
  * Options for sendIntent
  */
 interface SendIntentOptions {
     /** Username of the signer (for unsigned requests) */
     username?: string;
+    /** Account address of the signer (alternative to username for unsigned requests) */
+    accountAddress?: string;
     /** Target chain ID (for unsigned requests) */
     targetChain?: number;
     /** Calls to execute on the target chain (for unsigned requests) */
@@ -299,13 +345,19 @@ interface SendIntentOptions {
      * Example: ['USDC'] or ['0x...'] to only use USDC as input.
      */
     sourceAssets?: string[];
+    /**
+     * Source chain ID for the assets.
+     * When specified with sourceAssets containing addresses, tells orchestrator
+     * which chain to look for those tokens on.
+     */
+    sourceChainId?: number;
     /** When to close the dialog and return success. Defaults to "preconfirmed" */
     closeOn?: CloseOnStatus;
     /**
-     * Pre-signed intent from merchant backend (XSS protected)
+     * Pre-signed intent from developer backend (XSS protected)
      * If provided, username/targetChain/calls/tokenRequests are ignored
      */
-    signedIntent?: MerchantSignedIntent;
+    signedIntent?: DeveloperSignedIntent;
     /**
      * Wait for a transaction hash before resolving.
      * Defaults to false to preserve existing behavior.
@@ -339,7 +391,7 @@ interface IntentQuote {
 /**
  * Status of an intent (local states)
  */
-type IntentStatus = "pending" | "quoted" | "signed" | "submitted" | "completed" | "failed" | "expired";
+type IntentStatus = "pending" | "quoted" | "signed" | "submitted" | "claimed" | "preconfirmed" | "filled" | "completed" | "failed" | "expired" | "unknown";
 /**
  * Orchestrator status (from Rhinestone)
  * These are the statuses we can receive when polling
@@ -377,13 +429,27 @@ interface SendIntentResult {
  * Prepare intent response from auth service
  */
 interface PrepareIntentResponse {
-    intentId: string;
     quote: IntentQuote;
     transaction: TransactionDetails;
     challenge: string;
     expiresAt: string;
     /** Account address for the sign dialog to detect self-transfer vs external send */
     accountAddress?: string;
+    /** Serialized PreparedTransactionData from orchestrator - needed for execute */
+    intentOp: string;
+    /** User ID for creating intent record on execute */
+    userId: string;
+    /** Target chain ID */
+    targetChain: number;
+    /** JSON stringified calls */
+    calls: string;
+    /** Origin message hashes for multi-source cross-chain intents */
+    originMessages?: Array<{
+        chainId: number;
+        messageHash: string;
+    }>;
+    /** Serialized DigestResult from module SDK (EIP-712 wrapped challenge + merkle proofs) */
+    digestResult?: string;
 }
 /**
  * Execute intent response from auth service
@@ -394,6 +460,8 @@ interface ExecuteIntentResponse {
     operationId?: string;
     status: IntentStatus;
     transactionHash?: string;
+    /** Transaction result data needed for waiting via POST /api/intent/wait */
+    transactionResult?: unknown;
     error?: {
         code: string;
         message: string;
@@ -407,8 +475,8 @@ interface SendSwapOptions {
     username: string;
     /** Target chain ID where swap executes */
     targetChain: number;
-    /** Token to swap from (address or supported symbol like 'ETH', 'USDC') */
-    fromToken: string;
+    /** Token to swap from (address or supported symbol like 'ETH', 'USDC'). Omit to let the orchestrator pick. */
+    fromToken?: string;
     /** Token to swap to (address or supported symbol) */
     toToken: string;
     /** Amount to swap in human-readable format (e.g., "0.1") */
@@ -420,6 +488,11 @@ interface SendSwapOptions {
      * This constrains which tokens the orchestrator can use as input.
      */
     sourceAssets?: string[];
+    /**
+     * Source chain ID for the assets. When specified, the orchestrator will only
+     * look for source assets on this specific chain.
+     */
+    sourceChainId?: number;
     /** When to close the dialog. Defaults to "preconfirmed" */
     closeOn?: CloseOnStatus;
     /** Wait for a transaction hash before resolving. */
@@ -433,8 +506,8 @@ interface SendSwapOptions {
  * Quote information from DEX aggregator
  */
 interface SwapQuote {
-    /** Token being sold */
-    fromToken: string;
+    /** Token being sold (undefined when orchestrator picks) */
+    fromToken?: string;
     /** Token being bought */
     toToken: string;
     /** Amount of fromToken being sold */
@@ -487,8 +560,10 @@ type EIP712Types = {
  * Options for signTypedData
  */
 interface SignTypedDataOptions {
-    /** Username of the signer */
-    username: string;
+    /** Username of the signer (required if accountAddress is not provided) */
+    username?: string;
+    /** Account address of the signer (alternative to username) */
+    accountAddress?: string;
     /** EIP-712 domain parameters */
     domain: EIP712Domain;
     /** Type definitions for all types used in the message */
@@ -519,6 +594,218 @@ interface SignTypedDataResult {
         message: string;
     };
 }
+/**
+ * Options for querying intent history
+ */
+interface IntentHistoryOptions {
+    /** Maximum number of intents to return (default: 50, max: 100) */
+    limit?: number;
+    /** Number of intents to skip for pagination */
+    offset?: number;
+    /** Filter by intent status */
+    status?: IntentStatus;
+    /** Filter by creation date (ISO string) - intents created on or after this date */
+    from?: string;
+    /** Filter by creation date (ISO string) - intents created on or before this date */
+    to?: string;
+}
+/**
+ * Single intent item in history response
+ */
+interface IntentHistoryItem {
+    /** Intent identifier (orchestrator's ID, used as primary key) */
+    intentId: string;
+    /** Current status of the intent */
+    status: IntentStatus;
+    /** Transaction hash (if completed) */
+    transactionHash?: string;
+    /** Target chain ID */
+    targetChain: number;
+    /** Calls that were executed */
+    calls: IntentCall[];
+    /** When the intent was created (ISO string) */
+    createdAt: string;
+    /** When the intent was last updated (ISO string) */
+    updatedAt: string;
+}
+/**
+ * Result of getIntentHistory
+ */
+interface IntentHistoryResult {
+    /** List of intents */
+    intents: IntentHistoryItem[];
+    /** Total count of matching intents */
+    total: number;
+    /** Whether there are more intents beyond this page */
+    hasMore: boolean;
+}
+/**
+ * A single intent within a batch
+ */
+interface BatchIntentItem {
+    /** Target chain ID */
+    targetChain: number;
+    /** Calls to execute on the target chain */
+    calls?: IntentCall[];
+    /** Optional token requests */
+    tokenRequests?: IntentTokenRequest[];
+    /** Constrain which tokens can be used as input */
+    sourceAssets?: string[];
+    /** Source chain ID for the assets */
+    sourceChainId?: number;
+    /** Install an ERC-7579 module instead of executing calls */
+    moduleInstall?: {
+        moduleType: "validator" | "executor" | "fallback" | "hook";
+        moduleAddress: string;
+        initData?: string;
+    };
+}
+/**
+ * Options for sendBatchIntent
+ */
+interface SendBatchIntentOptions {
+    /** Username of the signer */
+    username?: string;
+    /** Account address of the signer (alternative to username) */
+    accountAddress?: string;
+    /** Array of intents to execute as a batch */
+    intents: BatchIntentItem[];
+    /** When to close the dialog for each intent. Defaults to "preconfirmed" */
+    closeOn?: CloseOnStatus;
+}
+/**
+ * Result for a single intent within a batch
+ */
+interface BatchIntentItemResult {
+    /** Index in the original batch */
+    index: number;
+    /** Whether this intent succeeded */
+    success: boolean;
+    /** Intent ID from orchestrator */
+    intentId: string;
+    /** Current status */
+    status: IntentStatus;
+    /** Error details if failed */
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Result of sendBatchIntent
+ */
+interface SendBatchIntentResult {
+    /** Whether ALL intents succeeded */
+    success: boolean;
+    /** Per-intent results */
+    results: BatchIntentItemResult[];
+    /** Count of successful intents */
+    successCount: number;
+    /** Count of failed intents */
+    failureCount: number;
+    /** Top-level error message when batch-prepare itself fails */
+    error?: string;
+}
+/**
+ * Prepared intent data within a batch response
+ */
+interface PreparedBatchIntent {
+    /** Index in the original batch */
+    index: number;
+    /** Quote from orchestrator */
+    quote: IntentQuote;
+    /** Decoded transaction details for UI */
+    transaction: TransactionDetails;
+    /** Serialized PreparedTransactionData from orchestrator */
+    intentOp: string;
+    /** Expiry for this specific intent */
+    expiresAt: string;
+    /** Target chain ID */
+    targetChain: number;
+    /** JSON stringified calls */
+    calls: string;
+    /** Origin message hashes for this intent */
+    originMessages: Array<{
+        chainId: number;
+        messageHash: string;
+    }>;
+}
+/**
+ * Prepare batch intent response from auth service
+ */
+interface PrepareBatchIntentResponse {
+    /** Per-intent prepared data (successful quotes only) */
+    intents: PreparedBatchIntent[];
+    /** Intents that failed to get quotes (unsupported chains, etc.) */
+    failedIntents?: Array<{
+        index: number;
+        targetChain: number;
+        error: string;
+    }>;
+    /** Shared challenge (merkle root of ALL origin hashes across ALL intents) */
+    challenge: string;
+    /** User ID */
+    userId: string;
+    /** Account address */
+    accountAddress?: string;
+    /** Global expiry (earliest of all intent expiries) */
+    expiresAt: string;
+}
+/** Fields available for consent sharing */
+type ConsentField = "email" | "deviceNames";
+/** Shared data returned from consent */
+interface ConsentData {
+    email?: string;
+    deviceNames?: string[];
+}
+/** Options for checkConsent (read-only, no dialog) */
+interface CheckConsentOptions {
+    /** Username of the account (required if accountAddress not provided) */
+    username?: string;
+    /** Account address (alternative to username) */
+    accountAddress?: string;
+    /** Fields to check */
+    fields: ConsentField[];
+    /** Override clientId from SDK config */
+    clientId?: string;
+}
+/** Result of checkConsent */
+interface CheckConsentResult {
+    /** Whether consent has been granted for ALL requested fields */
+    hasConsent: boolean;
+    /** Shared data (present when hasConsent is true) */
+    data?: ConsentData;
+    /** When consent was granted (ISO timestamp) */
+    grantedAt?: string;
+}
+/** Options for requestConsent (opens dialog if needed) */
+interface RequestConsentOptions {
+    /** Username of the account (required if accountAddress not provided) */
+    username?: string;
+    /** Account address (alternative to username) */
+    accountAddress?: string;
+    /** Fields to request access to */
+    fields: ConsentField[];
+    /** Override clientId from SDK config */
+    clientId?: string;
+    /** Theme configuration */
+    theme?: ThemeConfig;
+}
+/** Result of requestConsent */
+interface RequestConsentResult {
+    success: boolean;
+    /** Shared data (present when success is true) */
+    data?: ConsentData;
+    /** When consent was granted (ISO timestamp) */
+    grantedAt?: string;
+    /** Whether data came from an existing grant (no dialog shown) */
+    cached?: boolean;
+    /** Error details */
+    error?: {
+        code: "USER_REJECTED" | "USER_CANCELLED" | "INVALID_REQUEST" | "NETWORK_ERROR" | "UNKNOWN";
+        message: string;
+    };
+}
 
 declare class OneAuthClient {
     private config;
@@ -549,7 +836,7 @@ declare class OneAuthClient {
     /**
      * Get the configured client ID
      */
-    getClientId(): string;
+    getClientId(): string | undefined;
     private waitForTransactionHash;
     /**
      * Open the auth dialog (sign in + sign up).
@@ -559,6 +846,66 @@ declare class OneAuthClient {
         theme?: ThemeConfig;
         oauthEnabled?: boolean;
     }): Promise<LoginResult | RegisterResult>;
+    /**
+     * Open the connect dialog (lightweight connection without passkey auth).
+     *
+     * This method shows a simple connection confirmation dialog that doesn't
+     * require a passkey signature. Users can optionally enable "auto-connect"
+     * to skip this dialog in the future.
+     *
+     * If the user has never connected before, this will return action: "switch"
+     * to indicate that the full auth modal should be opened instead.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.connectWithModal();
+     *
+     * if (result.success) {
+     *   console.log('Connected as:', result.username);
+     * } else if (result.action === 'switch') {
+     *   // User needs to sign in first
+     *   const authResult = await client.authWithModal();
+     * }
+     * ```
+     */
+    connectWithModal(options?: {
+        theme?: ThemeConfig;
+    }): Promise<ConnectResult>;
+    /**
+     * Check if a user has already granted consent for the requested fields.
+     * This is a read-only check — no dialog is shown.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.checkConsent({
+     *   username: "alice",
+     *   fields: ["email"],
+     * });
+     * if (result.hasConsent) {
+     *   console.log(result.data?.email);
+     * }
+     * ```
+     */
+    checkConsent(options: CheckConsentOptions): Promise<CheckConsentResult>;
+    /**
+     * Request consent from the user to share their data.
+     *
+     * First checks if consent was already granted (returns cached data immediately).
+     * If not, opens the consent dialog where the user can review and approve sharing.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.requestConsent({
+     *   username: "alice",
+     *   fields: ["email", "deviceNames"],
+     * });
+     * if (result.success) {
+     *   console.log(result.data?.email);
+     *   console.log(result.cached); // true if no dialog was shown
+     * }
+     * ```
+     */
+    requestConsent(options: RequestConsentOptions): Promise<RequestConsentResult>;
     /**
      * Authenticate a user with an optional challenge to sign.
      *
@@ -595,7 +942,7 @@ declare class OneAuthClient {
         theme?: ThemeConfig;
     }): Promise<AuthenticateResult>;
     /**
-     * Show signing in a modal overlay (Porto-style iframe dialog)
+     * Show signing in a modal overlay (iframe dialog)
      */
     signWithModal(options: SigningRequestOptions & {
         theme?: ThemeConfig;
@@ -630,6 +977,34 @@ declare class OneAuthClient {
      * ```
      */
     sendIntent(options: SendIntentOptions): Promise<SendIntentResult>;
+    /**
+     * Send a batch of intents for multi-chain execution with a single passkey tap.
+     *
+     * This method prepares multiple intents, shows a paginated review,
+     * and signs all intents with a single passkey tap via a shared merkle tree.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.sendBatchIntent({
+     *   username: 'alice',
+     *   intents: [
+     *     {
+     *       targetChain: 8453, // Base
+     *       calls: [{ to: '0x...', data: '0x...', label: 'Swap on Base' }],
+     *     },
+     *     {
+     *       targetChain: 42161, // Arbitrum
+     *       calls: [{ to: '0x...', data: '0x...', label: 'Mint on Arbitrum' }],
+     *     },
+     *   ],
+     * });
+     *
+     * if (result.success) {
+     *   console.log(`${result.successCount} intents submitted`);
+     * }
+     * ```
+     */
+    sendBatchIntent(options: SendBatchIntentOptions): Promise<SendBatchIntentResult>;
     /**
      * Send transaction status to the dialog iframe
      */
@@ -642,10 +1017,37 @@ declare class OneAuthClient {
      * Wait for signing result (simplified - no requestId matching)
      */
     private waitForSigningResponse;
+    /**
+     * Wait for signing result with auto-refresh support
+     * This method handles both signing results and quote refresh requests from the dialog
+     */
+    private waitForSigningWithRefresh;
     /**
      * Wait for the dialog to be closed
      */
     private waitForDialogClose;
+    /**
+     * Inject a preconnect link tag to pre-warm DNS + TLS for a given URL.
+     */
+    private injectPreconnect;
+    /**
+     * Wait for the dialog iframe to signal ready without sending init data.
+     * Returns a sendInit function the caller uses once prepare data is available.
+     */
+    private waitForDialogReadyDeferred;
+    /**
+     * Prepare an intent by calling the orchestrator for a quote.
+     * Returns the prepare response and the origin tier from the response header.
+     */
+    private prepareIntent;
+    /**
+     * Prepare a batch intent by calling the orchestrator for quotes on all intents.
+     */
+    private prepareBatchIntent;
+    /**
+     * Send a prepare error message to the dialog iframe.
+     */
+    private sendPrepareError;
     /**
      * Poll for intent status
      *
@@ -653,6 +1055,26 @@ declare class OneAuthClient {
      * that hasn't completed yet.
      */
     getIntentStatus(intentId: string): Promise<SendIntentResult>;
+    /**
+     * Get the history of intents for the authenticated user.
+     *
+     * Requires an active session (user must be logged in).
+     *
+     * @example
+     * ```typescript
+     * // Get recent intents
+     * const history = await client.getIntentHistory({ limit: 10 });
+     *
+     * // Filter by status
+     * const pending = await client.getIntentHistory({ status: 'pending' });
+     *
+     * // Filter by date range
+     * const lastWeek = await client.getIntentHistory({
+     *   from: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString(),
+     * });
+     * ```
+     */
+    getIntentHistory(options?: IntentHistoryOptions): Promise<IntentHistoryResult>;
     /**
      * Send a swap intent through the Rhinestone orchestrator
      *
@@ -771,15 +1193,28 @@ declare class OneAuthClient {
     getPasskeys(username: string): Promise<PasskeyCredential[]>;
     private createSigningRequest;
     private openPopup;
+    /**
+     * Wait for the dialog iframe to signal ready, then send init data.
+     * Also handles early close (X button, escape, backdrop) during the ready phase.
+     * Returns true if dialog is ready, false if it was closed before becoming ready.
+     */
+    private waitForDialogReady;
     /**
      * Create a modal dialog with an iframe inside.
      */
     private createModalDialog;
     private waitForModalAuthResponse;
+    /**
+     * Open a popup for auth and wait for the result.
+     * Used when iframe mode fails (e.g., due to password manager interference).
+     */
+    private waitForPopupAuthResponse;
     private waitForAuthenticateResponse;
+    private waitForConnectResponse;
+    private waitForConsentResponse;
     private waitForModalSigningResponse;
     private waitForPopupResponse;
     private fetchSigningResult;
 }
 
-export { type AuthenticateOptions as A, type BalanceRequirement as B, type CreateSigningRequestResponse as C, type PrepareIntentResponse as D, type EmbedOptions as E, type ExecuteIntentResponse as F, type SendSwapOptions as G, type SendSwapResult as H, type IntentSigner as I, type SwapQuote as J, type ThemeConfig as K, type LoginOptions as L, type MerchantSignedIntent as M, OneAuthClient as O, type PasskeyProviderConfig as P, type RegisterOptions as R, type SendIntentResult as S, type TransactionAction as T, type UserPasskeysResponse as U, type WebAuthnSignature as W, type IntentCall as a, type SigningRequestOptions as b, type SigningResult as c, type SigningSuccess as d, type SigningError as e, type SigningErrorCode as f, type SigningRequestStatus as g, type PasskeyCredential as h, type RegisterResult as i, type LoginResult as j, type AuthenticateResult as k, type SignMessageOptions as l, type SignMessageResult as m, type SignTypedDataOptions as n, type SignTypedDataResult as o, type EIP712Domain as p, type EIP712Types as q, type EIP712TypeField as r, type TransactionFees as s, type TransactionDetails as t, type IntentTokenRequest as u, type SendIntentOptions as v, type IntentQuote as w, type IntentStatus as x, type OrchestratorStatus as y, type CloseOnStatus as z };
+export { type CheckConsentOptions as $, type AuthenticateOptions as A, type BalanceRequirement as B, type CreateSigningRequestResponse as C, type DeveloperSignedIntent as D, type EmbedOptions as E, type CloseOnStatus as F, type PrepareIntentResponse as G, type ExecuteIntentResponse as H, type IntentSigner as I, type IntentHistoryOptions as J, type IntentHistoryItem as K, type LoginOptions as L, type MerchantSignedIntent as M, type IntentHistoryResult as N, OneAuthClient as O, type PasskeyProviderConfig as P, type SendSwapOptions as Q, type RegisterOptions as R, type SendIntentResult as S, type TransactionAction as T, type UserPasskeysResponse as U, type SendSwapResult as V, type WebAuthnSignature as W, type SwapQuote as X, type ThemeConfig as Y, type ConsentField as Z, type ConsentData as _, type IntentCall as a, type CheckConsentResult as a0, type RequestConsentOptions as a1, type RequestConsentResult as a2, type BatchIntentItem as a3, type SendBatchIntentOptions as a4, type SendBatchIntentResult as a5, type BatchIntentItemResult as a6, type PreparedBatchIntent as a7, type PrepareBatchIntentResponse as a8, type SigningRequestOptions as b, type SigningResult as c, type SigningSuccess as d, type SigningError as e, type SigningErrorCode as f, type SigningRequestStatus as g, type PasskeyCredential as h, type RegisterResult as i, type LoginResult as j, type ConnectResult as k, type AuthenticateResult as l, type SignMessageOptions as m, type SignMessageResult as n, type SignTypedDataOptions as o, type SignTypedDataResult as p, type EIP712Domain as q, type EIP712Types as r, type EIP712TypeField as s, type TransactionFees as t, type TransactionDetails as u, type IntentTokenRequest as v, type SendIntentOptions as w, type IntentQuote as x, type IntentStatus as y, type OrchestratorStatus as z };