@zendfi/sdk 0.8.4 → 1.0.1

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { C as CreateAgentApiKeyRequest, A as AgentApiKey, b as CreateAgentSessionRequest, c as AgentSession, d as AgentPaymentRequest, e as AgentPaymentResponse, f as AgentAnalytics, g as CreatePaymentIntentRequest, P as PaymentIntent, h as ConfirmPaymentIntentRequest, i as PaymentIntentEvent, j as PPPFactor, k as PricingSuggestionRequest, l as PricingSuggestion, E as EnableAutonomyRequest, m as EnableAutonomyResponse, n as AutonomyStatus, S as SmartPaymentRequest, o as SmartPaymentResponse, Z as ZendFiConfig, p as CreatePaymentRequest, q as Payment, L as ListPaymentsRequest, r as PaginatedResponse, s as CreateSubscriptionPlanRequest, t as SubscriptionPlan, u as CreateSubscriptionRequest, v as Subscription, w as CreatePaymentLinkRequest, x as PaymentLink, y as CreateInstallmentPlanRequest, I as InstallmentPlan, z as CreateEscrowRequest, B as Escrow, D as ApproveEscrowRequest, R as RefundEscrowRequest, F as DisputeEscrowRequest, G as CreateInvoiceRequest, H as Invoice, V as VerifyWebhookRequest, J as WebhookPayload, K as ApiKeyMode } from './webhook-handler-CdtQHVU5.mjs';
-export { X as AgentKeyId, at as ApiKeyScope, az as AutonomousDelegate, Q as Brand, aw as CaptureMethod, aF as CreateDeviceBoundSessionKeyRequest, aG as CreateDeviceBoundSessionKeyResponse, aq as CreateInstallmentPlanResponse, aC as CreateSessionKeyRequest, aD as CreateSessionKeyResponse, af as Currency, ae as Environment, a0 as EscrowId, ak as EscrowStatus, a1 as InstallmentPlanId, aj as InstallmentPlanStatus, ap as InstallmentScheduleItem, a3 as IntentId, _ as InvoiceId, as as InvoiceLineItem, al as InvoiceStatus, aJ as LinkedSessionInfo, Y as MerchantId, ay as PPPConfig, T as PaymentId, av as PaymentIntentStatus, a2 as PaymentLinkCode, ah as PaymentStatus, ag as PaymentToken, ar as ReleaseCondition, aA as RevokeAutonomyRequest, aK as SecurityStatus, U as SessionId, aE as SessionKeyInstructions, aP as SessionKeyListResponse, aH as SessionKeySecurityInfo, aQ as SessionKeyStats, aI as SessionKeyStatus, au as SessionLimits, aB as SmartPaymentStatus, ao as SplitRecipient, am as SplitStatus, aN as SubmitSignedTransactionRequest, aO as SubmitTransactionResponse, $ as SubscriptionId, ai as SubscriptionStatus, aL as TopUpSessionKeyRequest, aM as TopUpSessionKeyResponse, ax as UserProfile, an as WebhookEvent, O as WebhookEventHandler, W as WebhookHandlerConfig, a as WebhookHandlers, N as WebhookResult, a6 as asAgentKeyId, aa as asEscrowId, ab as asInstallmentPlanId, ad as asIntentId, a8 as asInvoiceId, a7 as asMerchantId, a4 as asPaymentId, ac as asPaymentLinkCode, a5 as asSessionId, a9 as asSubscriptionId, M as processWebhook } from './webhook-handler-CdtQHVU5.mjs';
-import { Keypair, Transaction } from '@solana/web3.js';
+import { Z as ZendFiConfig, C as CreatePaymentRequest, P as Payment, b as CreateSubscriptionPlanRequest, S as SubscriptionPlan, c as CreateSubscriptionRequest, d as Subscription, e as CreatePaymentLinkRequest, f as PaymentLink, g as CreateInstallmentPlanRequest, I as InstallmentPlan, h as CreateInvoiceRequest, i as Invoice, V as VerifyWebhookRequest, j as WebhookPayload, A as ApiKeyMode } from './webhook-handler-61UWBtDI.mjs';
+export { B as Brand, R as CreateInstallmentPlanResponse, y as Currency, E as Environment, q as InstallmentPlanId, G as InstallmentPlanStatus, Q as InstallmentScheduleItem, n as InvoiceId, T as InvoiceLineItem, H as InvoiceStatus, N as ListPaymentsRequest, M as MerchantId, O as PaginatedResponse, m as PaymentId, r as PaymentLinkCode, D as PaymentStatus, z as PaymentToken, L as SplitRecipient, J as SplitStatus, o as SubscriptionId, F as SubscriptionStatus, K as WebhookEvent, l as WebhookEventHandler, W as WebhookHandlerConfig, a as WebhookHandlers, k as WebhookResult, w as asInstallmentPlanId, u as asInvoiceId, t as asMerchantId, s as asPaymentId, x as asPaymentLinkCode, v as asSubscriptionId, p as processWebhook } from './webhook-handler-61UWBtDI.mjs';
+export { ConnectedWallet, DevTools, MockWallet, PerformanceMonitor, PollingOptions, TestSessionKey, TransactionMonitor, TransactionPoller, TransactionStatus, WalletConnector, createWalletHook } from './helpers/index.mjs';
 
 /**
  * Request/Response Interceptor System
@@ -59,3316 +59,663 @@ interface Interceptors {
 }
 
 /**
- * Agent API - Manage agent API keys and sessions
- *
- * @example
- * ```typescript
- * // Create an agent API key
- * const agentKey = await zendfi.agent.createKey({
- *   name: 'Shopping Assistant',
- *   agent_id: 'shopping-assistant-v1',
- *   scopes: ['create_payments', 'read_analytics'],
- *   rate_limit_per_hour: 1000,
- * });
- *
- * // Create an agent session with spending limits
- * const session = await zendfi.agent.createSession({
- *   agent_id: 'shopping-assistant-v1',
- *   user_wallet: 'Hx7B...abc',
- *   limits: {
- *     max_per_transaction: 100,
- *     max_per_day: 500,
- *   },
- *   duration_hours: 24,
- * });
- * ```
+ * ZendFi SDK Client.
+ * Zero-config TypeScript SDK for crypto payments
  */
-
-type RequestFn$5 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
-declare class AgentAPI {
-    private request;
-    constructor(request: RequestFn$5);
+declare class ZendFiClient {
+    private config;
+    readonly interceptors: Interceptors;
+    constructor(options?: Partial<ZendFiConfig>);
     /**
-     * Create a new agent API key with scoped permissions
-     *
-     * Agent keys (prefixed with `zai_`) have limited permissions compared to
-     * merchant keys. This enables safe delegation to AI agents.
-     *
-     * @param request - Agent key configuration
-     * @returns The created agent key (full_key only returned on creation!)
-     *
-     * @example
-     * ```typescript
-     * const agentKey = await zendfi.agent.createKey({
-     *   name: 'Shopping Assistant',
-     *   agent_id: 'shopping-assistant-v1',
-     *   scopes: ['create_payments'],
-     *   rate_limit_per_hour: 500,
-     * });
-     *
-     * // IMPORTANT: Save the full_key now - it won't be shown again!
-     * console.log(agentKey.full_key); // => "zai_test_abc123..."
-     * ```
+     * Create a new payment
      */
-    createKey(request: CreateAgentApiKeyRequest): Promise<AgentApiKey>;
+    createPayment(request: CreatePaymentRequest): Promise<Payment>;
     /**
-     * List all agent API keys for the merchant
-     *
-     * @returns Array of agent API keys (without full_key for security)
-     *
-     * @example
-     * ```typescript
-     * const keys = await zendfi.agent.listKeys();
-     * keys.forEach(key => {
-     *   console.log(`${key.name}: ${key.key_prefix}*** (${key.scopes.join(', ')})`);
-     * });
-     * ```
+     * Get payment by ID
      */
-    listKeys(): Promise<AgentApiKey[]>;
+    getPayment(paymentId: string): Promise<Payment>;
     /**
-     * Revoke an agent API key
-     *
-     * Once revoked, the key cannot be used for any API calls.
-     * This action is irreversible.
-     *
-     * @param keyId - UUID of the agent key to revoke
-     *
-     * @example
-     * ```typescript
-     * await zendfi.agent.revokeKey('ak_123...');
-     * console.log('Agent key revoked');
-     * ```
+     * Create a subscription plan
      */
-    revokeKey(keyId: string): Promise<void>;
+    createSubscriptionPlan(request: CreateSubscriptionPlanRequest): Promise<SubscriptionPlan>;
     /**
-     * Create an agent session with spending limits
-     *
-     * Sessions provide time-bounded authorization for agents to make payments
-     * on behalf of users, with configurable spending limits.
-     *
-     * @param request - Session configuration
-     * @returns The created session with token
-     *
-     * @example
-     * ```typescript
-     * const session = await zendfi.agent.createSession({
-     *   agent_id: 'shopping-assistant-v1',
-     *   agent_name: 'Shopping Assistant',
-     *   user_wallet: 'Hx7B...abc',
-     *   limits: {
-     *     max_per_transaction: 100,
-     *     max_per_day: 500,
-     *     require_approval_above: 50,
-     *   },
-     *   duration_hours: 24,
-     * });
-     *
-     * // Use session_token for subsequent API calls
-     * console.log(session.session_token); // => "zai_session_..."
-     * ```
+     * Get subscription plan by ID
      */
-    createSession(request: CreateAgentSessionRequest): Promise<AgentSession>;
+    getSubscriptionPlan(planId: string): Promise<SubscriptionPlan>;
     /**
-     * List all agent sessions
-     *
-     * @returns Array of agent sessions (both active and expired)
-     *
-     * @example
-     * ```typescript
-     * const sessions = await zendfi.agent.listSessions();
-     * const activeSessions = sessions.filter(s => s.is_active);
-     * console.log(`${activeSessions.length} active sessions`);
-     * ```
+     * Create a subscription
      */
-    listSessions(): Promise<AgentSession[]>;
+    createSubscription(request: CreateSubscriptionRequest): Promise<Subscription>;
     /**
-     * Get a specific agent session by ID
-     *
-     * @param sessionId - UUID of the session
-     * @returns The session details with remaining limits
-     *
-     * @example
-     * ```typescript
-     * const session = await zendfi.agent.getSession('sess_123...');
-     * console.log(`Remaining today: $${session.remaining_today}`);
-     * console.log(`Expires: ${session.expires_at}`);
-     * ```
+     * Get subscription by ID
      */
-    getSession(sessionId: string): Promise<AgentSession>;
+    getSubscription(subscriptionId: string): Promise<Subscription>;
     /**
-     * Revoke an agent session
-     *
-     * Immediately invalidates the session, preventing any further payments.
-     * This action is irreversible.
-     *
-     * @param sessionId - UUID of the session to revoke
-     *
-     * @example
-     * ```typescript
-     * await zendfi.agent.revokeSession('sess_123...');
-     * console.log('Session revoked - agent can no longer make payments');
-     * ```
+     * Cancel a subscription
      */
-    revokeSession(sessionId: string): Promise<void>;
+    cancelSubscription(subscriptionId: string): Promise<Subscription>;
     /**
-     * Execute a payment using an agent session
-     *
-     * This is the primary method for AI agents to make payments. It uses the
-     * session token to enforce spending limits and automatically routes the
-     * payment through the optimal path.
-     *
-     * The session token comes from `createSession()` and enforces:
-     * - Per-transaction limits
-     * - Daily limits
-     * - Weekly limits
-     * - Monthly limits
-     *
-     * @param request - Payment request with session token
-     * @returns Payment result with status and receipt
-     *
-     * @example
-     * ```typescript
-     * // Create a session first
-     * const session = await zendfi.agent.createSession({
-     *   agent_id: 'shopping-bot',
-     *   user_wallet: 'Hx7B...abc',
-     *   limits: {
-     *     max_per_transaction: 50,
-     *     max_per_day: 200,
-     *   },
-     *   duration_hours: 24,
-     * });
-     *
-     * // Make payments within the session limits
-     * const payment = await zendfi.agent.pay({
-     *   session_token: session.session_token,
-     *   amount: 29.99,
-     *   description: 'Premium widget',
-     *   auto_gasless: true,
-     * });
-     *
-     * if (payment.requires_signature) {
-     *   // Device-bound: user must sign
-     *   console.log('Sign and submit to:', payment.submit_url);
-     * } else {
-     *   // Auto-signed: payment complete
-     *   console.log('Payment confirmed:', payment.transaction_signature);
-     * }
-     * ```
+     * Create a payment link (shareable checkout URL)
      */
-    pay(request: AgentPaymentRequest): Promise<AgentPaymentResponse>;
+    createPaymentLink(request: CreatePaymentLinkRequest): Promise<PaymentLink>;
     /**
-     * Get analytics for all agent activity
-     *
-     * @returns Comprehensive analytics including payments, success rate, and PPP savings
-     *
-     * @example
-     * ```typescript
-     * const analytics = await zendfi.agent.getAnalytics();
-     * console.log(`Total volume: $${analytics.total_volume_usd}`);
-     * console.log(`Success rate: ${(analytics.success_rate * 100).toFixed(1)}%`);
-     * console.log(`PPP savings: $${analytics.ppp_savings_usd}`);
-     * ```
+     * Get payment link by link code
      */
-    getAnalytics(): Promise<AgentAnalytics>;
-}
-
-/**
- * Payment Intents API - Two-phase payment flow
- *
- * Payment Intents provide a modern checkout experience with:
- * - Create intent first (reserves amount)
- * - Confirm when ready (completes payment)
- * - Cancel if needed (releases hold)
- *
- * @example
- * ```typescript
- * // Step 1: Create intent when user starts checkout
- * const intent = await zendfi.intents.create({
- *   amount: 99.99,
- *   description: 'Premium subscription',
- * });
- *
- * // Step 2: Show payment form, collect wallet
- * // ...
- *
- * // Step 3: Confirm when user clicks "Pay"
- * const confirmed = await zendfi.intents.confirm(intent.id, {
- *   client_secret: intent.client_secret,
- *   customer_wallet: userWallet,
- * });
- * ```
- */
-
-type RequestFn$4 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
-interface ListIntentsOptions {
-    /** Filter by status */
-    status?: string;
-    /** Maximum results to return */
-    limit?: number;
-    /** Pagination offset */
-    offset?: number;
-}
-declare class PaymentIntentsAPI {
-    private request;
-    constructor(request: RequestFn$4);
+    getPaymentLink(linkCode: string): Promise<PaymentLink>;
     /**
-     * Create a payment intent
-     *
-     * This is step 1 of the two-phase payment flow. The intent reserves
-     * the payment amount and provides a client_secret for confirmation.
-     *
-     * @param request - Payment intent configuration
-     * @returns The created payment intent with client_secret
-     *
-     * @example
-     * ```typescript
-     * const intent = await zendfi.intents.create({
-     *   amount: 49.99,
-     *   description: 'Pro Plan - Monthly',
-     *   capture_method: 'automatic', // or 'manual' for auth-only
-     *   expires_in_seconds: 3600, // 1 hour
-     * });
-     *
-     * // Store intent.id and pass intent.client_secret to frontend
-     * console.log(`Intent created: ${intent.id}`);
-     * console.log(`Status: ${intent.status}`); // "requires_payment"
-     * ```
+     * List all payment links for the authenticated merchant
      */
-    create(request: CreatePaymentIntentRequest): Promise<PaymentIntent>;
+    listPaymentLinks(): Promise<PaymentLink[]>;
     /**
-     * Get a payment intent by ID
-     *
-     * @param intentId - UUID of the payment intent
-     * @returns The payment intent details
-     *
-     * @example
-     * ```typescript
-     * const intent = await zendfi.intents.get('pi_123...');
-     * console.log(`Status: ${intent.status}`);
-     * if (intent.payment_id) {
-     *   console.log(`Payment: ${intent.payment_id}`);
-     * }
-     * ```
+     * Create an installment plan
+     * Split a purchase into multiple scheduled payments
      */
-    get(intentId: string): Promise<PaymentIntent>;
+    createInstallmentPlan(request: CreateInstallmentPlanRequest): Promise<InstallmentPlan>;
     /**
-     * List payment intents
-     *
-     * @param options - Filter and pagination options
-     * @returns Array of payment intents
-     *
-     * @example
-     * ```typescript
-     * // Get recent pending intents
-     * const intents = await zendfi.intents.list({
-     *   status: 'requires_payment',
-     *   limit: 20,
-     * });
-     * ```
+     * Get installment plan by ID
      */
-    list(options?: ListIntentsOptions): Promise<PaymentIntent[]>;
+    getInstallmentPlan(planId: string): Promise<InstallmentPlan>;
     /**
-     * Confirm a payment intent
-     *
-     * This is step 2 of the two-phase payment flow. Confirmation triggers
-     * the actual payment using the customer's wallet.
-     *
-     * @param intentId - UUID of the payment intent
-     * @param request - Confirmation details including customer wallet
-     * @returns The confirmed payment intent with payment_id
-     *
-     * @example
-     * ```typescript
-     * const confirmed = await zendfi.intents.confirm('pi_123...', {
-     *   client_secret: 'pi_secret_abc...',
-     *   customer_wallet: 'Hx7B...abc',
-     *   auto_gasless: true,
-     * });
-     *
-     * if (confirmed.status === 'succeeded') {
-     *   console.log(`Payment complete: ${confirmed.payment_id}`);
-     * }
-     * ```
+     * List all installment plans for merchant
      */
-    confirm(intentId: string, request: ConfirmPaymentIntentRequest): Promise<PaymentIntent>;
+    listInstallmentPlans(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<InstallmentPlan[]>;
     /**
-     * Cancel a payment intent
-     *
-     * Canceling releases any hold on the payment amount. Cannot cancel
-     * intents that are already processing or succeeded.
-     *
-     * @param intentId - UUID of the payment intent
-     * @returns The canceled payment intent
-     *
-     * @example
-     * ```typescript
-     * const canceled = await zendfi.intents.cancel('pi_123...');
-     * console.log(`Status: ${canceled.status}`); // "canceled"
-     * ```
+     * List installment plans for a specific customer
      */
-    cancel(intentId: string): Promise<PaymentIntent>;
+    listCustomerInstallmentPlans(customerWallet: string): Promise<InstallmentPlan[]>;
     /**
-     * Get events for a payment intent
-     *
-     * Events track the full lifecycle of the intent, including creation,
-     * confirmation attempts, and status changes.
-     *
-     * @param intentId - UUID of the payment intent
-     * @returns Array of events in chronological order
-     *
-     * @example
-     * ```typescript
-     * const events = await zendfi.intents.getEvents('pi_123...');
-     * events.forEach(event => {
-     *   console.log(`${event.created_at}: ${event.event_type}`);
-     * });
-     * ```
+     * Cancel an installment plan
      */
-    getEvents(intentId: string): Promise<PaymentIntentEvent[]>;
-}
-
-/**
- * Pricing API - Purchasing Power Parity (PPP) and AI-powered pricing
- *
- * Enable global reach with geo-aware pricing that automatically adjusts
- * prices based on the customer's location and purchasing power.
- *
- * @example
- * ```typescript
- * // Get PPP factor for Brazil
- * const factor = await zendfi.pricing.getPPPFactor('BR');
- * console.log(`Brazil: ${factor.adjustment_percentage}% discount suggested`);
- *
- * // Apply PPP to a product price
- * const basePrice = 100;
- * const localPrice = basePrice * factor.ppp_factor;
- * console.log(`$${basePrice} → $${localPrice.toFixed(2)} for Brazilian customers`);
- * ```
- */
-
-type RequestFn$3 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
-declare class PricingAPI {
-    private request;
-    constructor(request: RequestFn$3);
+    cancelInstallmentPlan(planId: string): Promise<{
+        message: string;
+        plan_id: string;
+    }>;
     /**
-     * Get PPP factor for a specific country
-     *
-     * Returns the purchasing power parity adjustment factor for the given
-     * country code. Use this to calculate localized pricing.
-     *
-     * @param countryCode - ISO 3166-1 alpha-2 country code (e.g., "BR", "IN", "NG")
-     * @returns PPP factor and suggested adjustment
-     *
-     * @example
-     * ```typescript
-     * const factor = await zendfi.pricing.getPPPFactor('BR');
-     * // {
-     * //   country_code: 'BR',
-     * //   country_name: 'Brazil',
-     * //   ppp_factor: 0.35,
-     * //   currency_code: 'BRL',
-     * //   adjustment_percentage: 35.0
-     * // }
-     *
-     * // Calculate localized price
-     * const usdPrice = 100;
-     * const localPrice = usdPrice * (1 - factor.adjustment_percentage / 100);
-     * console.log(`$${localPrice} for Brazilian customers`);
-     * ```
+     * Create an invoice
      */
-    getPPPFactor(countryCode: string): Promise<PPPFactor>;
+    createInvoice(request: CreateInvoiceRequest): Promise<Invoice>;
     /**
-     * List all available PPP factors
-     *
-     * Returns PPP factors for all supported countries. Useful for building
-     * pricing tables or pre-computing regional prices.
-     *
-     * @returns Array of PPP factors for all supported countries
-     *
-     * @example
-     * ```typescript
-     * const factors = await zendfi.pricing.listFactors();
-     *
-     * // Create pricing tiers
-     * const tiers = factors.map(f => ({
-     *   country: f.country_name,
-     *   price: (100 * f.ppp_factor).toFixed(2),
-     * }));
-     *
-     * console.table(tiers);
-     * ```
+     * Get invoice by ID
      */
-    listFactors(): Promise<PPPFactor[]>;
+    getInvoice(invoiceId: string): Promise<Invoice>;
     /**
-     * Get AI-powered pricing suggestion
-     *
-     * Returns an intelligent pricing recommendation based on the user's
-     * location, wallet history, and your pricing configuration.
-     *
-     * @param request - Pricing suggestion request with user context
-     * @returns AI-generated pricing suggestion with reasoning
-     *
-     * @example
-     * ```typescript
-     * const suggestion = await zendfi.pricing.getSuggestion({
-     *   agent_id: 'shopping-assistant',
-     *   base_price: 99.99,
-     *   user_profile: {
-     *     location_country: 'BR',
-     *     context: 'first-time',
-     *   },
-     *   ppp_config: {
-     *     enabled: true,
-     *     max_discount_percent: 50,
-     *     floor_price: 29.99,
-     *   },
-     * });
-     *
-     * console.log(`Suggested: $${suggestion.suggested_amount}`);
-     * console.log(`Reason: ${suggestion.reasoning}`);
-     * // => "Price adjusted for Brazilian purchasing power (35% PPP discount)
-     * //     plus 10% first-time customer discount"
-     * ```
+     * List all invoices for merchant
      */
-    getSuggestion(request: PricingSuggestionRequest): Promise<PricingSuggestion>;
+    listInvoices(): Promise<Invoice[]>;
     /**
-     * Calculate localized price for a given base price and country
-     *
-     * Convenience method that combines getPPPFactor with price calculation.
-     *
-     * @param basePrice - Original price in USD
-     * @param countryCode - ISO 3166-1 alpha-2 country code
-     * @returns Object with original and adjusted prices
-     *
-     * @example
-     * ```typescript
-     * const result = await zendfi.pricing.calculateLocalPrice(100, 'IN');
-     * console.log(`Original: $${result.original}`);
-     * console.log(`Local: $${result.adjusted}`);
-     * console.log(`Savings: $${result.savings} (${result.discount_percentage}%)`);
-     * ```
+     * Send invoice to customer via email
      */
-    calculateLocalPrice(basePrice: number, countryCode: string): Promise<{
-        original: number;
-        adjusted: number;
-        savings: number;
-        discount_percentage: number;
-        country: string;
-        ppp_factor: number;
+    sendInvoice(invoiceId: string): Promise<{
+        success: boolean;
+        invoice_id: string;
+        invoice_number: string;
+        sent_to: string;
+        payment_url: string;
+        status: string;
     }>;
-}
-
-/**
- * Autonomy API - Enable autonomous agent signing
- *
- * The Autonomy API enables AI agents to make payments without user interaction
- * for each transaction, while maintaining cryptographic security through:
- *
- * 1. **Delegation Signatures** - User signs a message authorizing the agent
- * 2. **Spending Limits** - Hard caps on total spending
- * 3. **Time Bounds** - Automatic expiration
- * 4. **Lit Protocol** (optional) - Threshold cryptography for key management
- *
- * @example
- * ```typescript
- * // Enable autonomous mode for a session key
- * const delegate = await zendfi.autonomy.enable({
- *   session_key_id: 'sk_123...',
- *   max_amount_usd: 100,
- *   duration_hours: 24,
- *   delegation_signature: signature, // Ed25519 sig from user
- * });
- *
- * // Agent can now make payments automatically
- * console.log(`Delegate active: $${delegate.max_amount_usd} limit`);
- * ```
- */
-
-type RequestFn$2 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
-declare class AutonomyAPI {
-    private request;
-    constructor(request: RequestFn$2);
     /**
-     * Enable autonomous signing for a session key
-     *
-     * This grants an AI agent the ability to sign transactions on behalf of
-     * the user, up to the specified spending limit and duration.
-     *
-     * **Prerequisites:**
-     * 1. Create a device-bound session key first
-     * 2. Generate a delegation signature (see `createDelegationMessage`)
-     * 3. Optionally encrypt keypair with Lit Protocol for true autonomy
+     * Verify webhook signature using HMAC-SHA256
      *
-     * @param sessionKeyId - UUID of the session key
-     * @param request - Autonomy configuration including delegation signature
-     * @returns The created autonomous delegate
+     * @param request - Webhook verification request containing payload, signature, and secret
+     * @returns true if signature is valid, false otherwise
      *
      * @example
      * ```typescript
-     * // The user must sign this exact message format
-     * const message = zendfi.autonomy.createDelegationMessage(
-     *   sessionKeyId, 100, '2024-12-10T00:00:00Z'
-     * );
-     *
-     * // Have user sign with their session key
-     * const signature = await signWithSessionKey(message, pin);
-     *
-     * // Enable autonomous mode
-     * const delegate = await zendfi.autonomy.enable(sessionKeyId, {
-     *   max_amount_usd: 100,
-     *   duration_hours: 24,
-     *   delegation_signature: signature,
+     * const isValid = zendfi.verifyWebhook({
+     *   payload: req.body,
+     *   signature: req.headers['x-zendfi-signature'],
+     *   secret: process.env.ZENDFI_WEBHOOK_SECRET
      * });
      *
-     * console.log(`Delegate ID: ${delegate.delegate_id}`);
-     * console.log(`Expires: ${delegate.expires_at}`);
+     * if (!isValid) {
+     *   return res.status(401).json({ error: 'Invalid signature' });
+     * }
      * ```
      */
-    enable(sessionKeyId: string, request: EnableAutonomyRequest): Promise<EnableAutonomyResponse>;
-    /**
-     * Revoke autonomous mode for a session key
-     *
-     * Immediately invalidates the autonomous delegate, preventing any further
-     * automatic payments. The session key itself remains valid for manual use.
-     *
-     * @param sessionKeyId - UUID of the session key
-     * @param reason - Optional reason for revocation (logged for audit)
-     *
-     * @example
-     * ```typescript
-     * await zendfi.autonomy.revoke('sk_123...', 'User requested revocation');
-     * console.log('Autonomous mode disabled');
-     * ```
-     */
-    revoke(sessionKeyId: string, reason?: string): Promise<void>;
-    /**
-     * Get autonomy status for a session key
-     *
-     * Returns whether autonomous mode is enabled and details about the
-     * active delegate including remaining spending allowance.
-     *
-     * @param sessionKeyId - UUID of the session key
-     * @returns Autonomy status with delegate details
-     *
-     * @example
-     * ```typescript
-     * const status = await zendfi.autonomy.getStatus('sk_123...');
-     *
-     * if (status.autonomous_mode_enabled && status.delegate) {
-     *   console.log(`Remaining: $${status.delegate.remaining_usd}`);
-     *   console.log(`Expires: ${status.delegate.expires_at}`);
-     * } else {
-     *   console.log('Autonomous mode not enabled');
-     * }
-     * ```
-     */
-    getStatus(sessionKeyId: string): Promise<AutonomyStatus>;
-    /**
-     * Create the delegation message that needs to be signed
-     *
-     * This generates the exact message format required for the delegation
-     * signature. The user must sign this message with their session key.
-     *
-     * **Message format:**
-     * ```
-     * I authorize autonomous delegate for session {id} to spend up to ${amount} until {expiry}
-     * ```
-     *
-     * @param sessionKeyId - UUID of the session key
-     * @param maxAmountUsd - Maximum spending amount in USD
-     * @param expiresAt - ISO 8601 expiration timestamp
-     * @returns The message to be signed
-     *
-     * @example
-     * ```typescript
-     * const expiresAt = new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString();
-     * const message = zendfi.autonomy.createDelegationMessage(
-     *   'sk_123...',
-     *   100,
-     *   expiresAt
-     * );
-     * // => "I authorize autonomous delegate for session sk_123... to spend up to $100 until 2024-12-06T..."
-     *
-     * // Sign with nacl.sign.detached() or similar
-     * const signature = signMessage(message, keypair);
-     * ```
-     */
-    createDelegationMessage(sessionKeyId: string, maxAmountUsd: number, expiresAt: string): string;
-    /**
-     * Validate delegation signature parameters
-     *
-     * Helper method to check if autonomy parameters are valid before
-     * making the API call.
-     *
-     * @param request - The enable autonomy request to validate
-     * @throws Error if validation fails
-     *
-     * @example
-     * ```typescript
-     * try {
-     *   zendfi.autonomy.validateRequest(request);
-     *   const delegate = await zendfi.autonomy.enable(sessionKeyId, request);
-     * } catch (error) {
-     *   console.error('Invalid request:', error.message);
-     * }
-     * ```
-     */
-    validateRequest(request: EnableAutonomyRequest): void;
-    /**
-     * Get spending attestations for a delegate (audit trail)
-     *
-     * Returns all cryptographically signed attestations ZendFi created for
-     * this delegate. Each attestation contains:
-     * - The spending state at the time of payment
-     * - ZendFi's Ed25519 signature
-     * - Timestamp and nonce (for replay protection)
-     *
-     * These attestations can be independently verified using ZendFi's public key
-     * to confirm spending limit enforcement was applied correctly.
-     *
-     * @param delegateId - UUID of the autonomous delegate
-     * @returns Attestation audit response with all signed attestations
-     *
-     * @example
-     * ```typescript
-     * const audit = await zendfi.autonomy.getAttestations('delegate_123...');
-     *
-     * console.log(`Found ${audit.attestation_count} attestations`);
-     * console.log(`ZendFi public key: ${audit.zendfi_attestation_public_key}`);
-     *
-     * // Verify each attestation independently
-     * for (const signed of audit.attestations) {
-     *   console.log(`Payment ${signed.attestation.payment_id}:`);
-     *   console.log(`  Requested: $${signed.attestation.requested_usd}`);
-     *   console.log(`  Remaining after: $${signed.attestation.remaining_after_usd}`);
-     *   // Verify signature with nacl.sign.detached.verify()
-     * }
-     * ```
-     */
-    getAttestations(delegateId: string): Promise<AttestationAuditResponse>;
-}
-/** Spending attestation - ZendFi's signed commitment to spending state */
-interface SpendingAttestation {
-    delegate_id: string;
-    session_key_id: string;
-    merchant_id: string;
-    spent_usd: number;
-    limit_usd: number;
-    requested_usd: number;
-    remaining_after_usd: number;
-    timestamp_ms: number;
-    nonce: string;
-    payment_id: string;
-    version: number;
-}
-/** Signed attestation with ZendFi's cryptographic signature */
-interface SignedSpendingAttestation {
-    attestation: SpendingAttestation;
-    /** Base64-encoded Ed25519 signature */
-    signature: string;
-    /** Base58-encoded ZendFi public key */
-    signer_public_key: string;
-}
-/** Response from the attestation audit endpoint */
-interface AttestationAuditResponse {
-    delegate_id: string;
-    attestation_count: number;
-    attestations: SignedSpendingAttestation[];
-    /** ZendFi's attestation public key for independent verification */
-    zendfi_attestation_public_key: string | null;
-}
-
-/**
- * Smart Payments API - AI-powered payment routing
- *
- * Smart payments combine multiple features into a single intelligent API:
- * - Automatic PPP pricing adjustments
- * - Gasless transaction detection
- * - Instant settlement options
- * - Escrow integration
- * - Receipt generation
- *
- * @example
- * ```typescript
- * const result = await zendfi.payments.smart({
- *   agent_id: 'shopping-assistant',
- *   user_wallet: 'Hx7B...abc',
- *   amount_usd: 50,
- *   auto_detect_gasless: true,
- *   description: 'Premium subscription',
- * });
- *
- * console.log(`Payment: ${result.payment_id}`);
- * console.log(`Receipt: ${result.receipt_url}`);
- * ```
- */
-
-type RequestFn$1 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
-declare class SmartPaymentsAPI {
-    private request;
-    constructor(request: RequestFn$1);
-    /**
-     * Execute an AI-powered smart payment
-     *
-     * Smart payments analyze the context and automatically apply optimizations:
-     * - **PPP Pricing**: Auto-adjusts based on customer location
-     * - **Gasless**: Detects when user needs gas subsidization
-     * - **Instant Settlement**: Optional immediate merchant payout
-     * - **Escrow**: Optional fund holding for service delivery
-     *
-     * @param request - Smart payment request configuration
-     * @returns Payment result with status and receipt
-     *
-     * @example
-     * ```typescript
-     * // Basic smart payment
-     * const result = await zendfi.payments.smart({
-     *   agent_id: 'my-agent',
-     *   user_wallet: 'Hx7B...abc',
-     *   amount_usd: 99.99,
-     *   description: 'Annual Pro Plan',
-     * });
-     *
-     * // With all options
-     * const result = await zendfi.payments.smart({
-     *   agent_id: 'my-agent',
-     *   session_token: 'zai_session_...', // For limit enforcement
-     *   user_wallet: 'Hx7B...abc',
-     *   amount_usd: 99.99,
-     *   token: 'USDC',
-     *   auto_detect_gasless: true,
-     *   instant_settlement: true,
-     *   enable_escrow: false,
-     *   description: 'Annual Pro Plan',
-     *   product_details: {
-     *     name: 'Pro Plan',
-     *     sku: 'PRO-ANNUAL',
-     *   },
-     *   metadata: {
-     *     user_id: 'usr_123',
-     *   },
-     * });
-     *
-     * if (result.requires_signature) {
-     *   // Device-bound flow: need user to sign
-     *   console.log('Please sign:', result.unsigned_transaction);
-     *   console.log('Submit to:', result.submit_url);
-     * } else {
-     *   // Auto-signed (custodial or autonomous delegate)
-     *   console.log('Payment complete:', result.transaction_signature);
-     * }
-     * ```
-     */
-    execute(request: SmartPaymentRequest): Promise<SmartPaymentResponse>;
-    /**
-     * Submit a signed transaction from device-bound flow
-     *
-     * When a smart payment returns `requires_signature: true`, the client
-     * must sign the transaction and submit it here.
-     *
-     * @param paymentId - UUID of the payment
-     * @param signedTransaction - Base64 encoded signed transaction
-     * @returns Updated payment response
-     *
-     * @example
-     * ```typescript
-     * // After user signs the transaction
-     * const result = await zendfi.payments.submitSigned(
-     *   payment.payment_id,
-     *   signedTransaction
-     * );
-     *
-     * console.log(`Confirmed in ${result.confirmed_in_ms}ms`);
-     * ```
-     */
-    submitSigned(paymentId: string, signedTransaction: string): Promise<SmartPaymentResponse>;
-}
-
-/**
- * Session Keys API - Device-Bound Non-Custodial Session Keys
- *
- * TRUE non-custodial session keys where:
- * - Client generates keypair (backend NEVER sees private key)
- * - Client encrypts with PIN + device fingerprint (Argon2id + AES-256-GCM)
- * - Backend stores encrypted blob (cannot decrypt!)
- * - Client decrypts and signs for each payment
- *
- * This is the ONLY supported mode. Custodial session keys are deprecated.
- *
- * @example
- * ```typescript
- * // Create a session key with PIN encryption
- * const result = await zendfi.sessionKeys.create({
- *   userWallet: '7xKNH...',
- *   agentId: 'shopping-assistant-v1',
- *   agentName: 'AI Shopping Assistant',
- *   limitUSDC: 100,
- *   durationDays: 7,
- *   pin: '123456',
- *   generateRecoveryQR: true,
- * });
- *
- * console.log(`Session key: ${result.sessionKeyId}`);
- * console.log(`Works across all apps with agent: ${result.agentId}`);
- *
- * // Unlock for auto-signing (one-time PIN entry)
- * await zendfi.sessionKeys.unlock(result.sessionKeyId, '123456');
- *
- * // Make payments without PIN (instant!)
- * const payment = await zendfi.sessionKeys.makePayment({
- *   sessionKeyId: result.sessionKeyId,
- *   amount: 5.0,
- *   recipient: '8xYZA...',
- *   description: 'Coffee purchase',
- * });
- * ```
- *
- * @module aip/session-keys
- */
-type RequestFn = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
-interface CreateSessionKeyOptions {
-    /** User's main wallet address */
-    userWallet: string;
-    /** Agent identifier for cross-app compatibility (e.g., "shopping-assistant-v1") */
-    agentId: string;
-    /** Human-readable agent name (e.g., "AI Shopping Assistant") */
-    agentName?: string;
-    /** Spending limit in USDC */
-    limitUSDC: number;
-    /** Duration in days (1-30) */
-    durationDays: number;
-    /** 6-digit numeric PIN for encryption */
-    pin: string;
-    /** Generate recovery QR code (recommended) */
-    generateRecoveryQR?: boolean;
-    /** Enable Lit Protocol for true autonomous signing (default: true) */
-    enableLitProtocol?: boolean;
-    /** Lit Protocol network (default: 'datil-dev') */
-    litNetwork?: 'datil' | 'datil-dev' | 'datil-test';
-}
-interface SessionKeyResult {
-    /** UUID of the created session key */
-    sessionKeyId: string;
-    /** Agent identifier */
-    agentId: string;
-    /** Agent name (if provided) */
-    agentName?: string;
-    /** Session wallet public key */
-    sessionWallet: string;
-    /** Spending limit in USDC */
-    limitUsdc: number;
-    /** Expiration timestamp */
-    expiresAt: string;
-    /** Recovery QR code data (if generated) */
-    recoveryQR?: string;
-    /** True if this session key works across multiple apps with same agent_id */
-    crossAppCompatible: boolean;
-}
-interface MakePaymentOptions {
-    /** Session key ID to pay from */
-    sessionKeyId: string;
-    /** Payment amount in USD */
-    amount: number;
-    /** Recipient wallet address */
-    recipient: string;
-    /** Token to pay with (default: USDC) */
-    token?: string;
-    /** Payment description */
-    description?: string;
-    /** PIN (only required if session key not unlocked) */
-    pin?: string;
-    /** Whether to cache keypair for future payments (default: true) */
-    enableAutoSign?: boolean;
-}
-interface PaymentResult$1 {
-    paymentId: string;
-    signature: string;
-    status: string;
-}
-interface SessionKeyInfo {
-    sessionKeyId: string;
-    isActive: boolean;
-    isApproved: boolean;
-    limitUsdc: number;
-    usedAmountUsdc: number;
-    remainingUsdc: number;
-    expiresAt: string;
-    daysUntilExpiry: number;
-}
-declare class SessionKeysAPI {
-    private sessionKeys;
-    private sessionMetadata;
-    private requestFn;
-    private debugMode;
-    constructor(request: RequestFn);
-    /**
-     * Enable debug logging
-     */
-    private debug;
-    /**
-     * Create a new device-bound session key
-     *
-     * The keypair is generated client-side and encrypted with your PIN.
-     * The backend NEVER sees your private key.
-     *
-     * @param options - Session key configuration
-     * @returns Created session key info with optional recovery QR
-     *
-     * @example
-     * ```typescript
-     * const result = await zendfi.sessionKeys.create({
-     *   userWallet: '7xKNH...',
-     *   agentId: 'shopping-assistant-v1',
-     *   agentName: 'AI Shopping Assistant',
-     *   limitUSDC: 100,
-     *   durationDays: 7,
-     *   pin: '123456',
-     *   generateRecoveryQR: true,
-     * });
-     *
-     * console.log(`Session key: ${result.sessionKeyId}`);
-     * console.log(`Recovery QR: ${result.recoveryQR}`);
-     * ```
-     */
-    create(options: CreateSessionKeyOptions): Promise<SessionKeyResult>;
-    /**
-     * Load an existing session key from backend
-     *
-     * Fetches the encrypted session key and decrypts it with your PIN.
-     * Use this when resuming a session on the same device.
-     *
-     * @param sessionKeyId - UUID of the session key
-     * @param pin - PIN to decrypt the session key
-     *
-     * @example
-     * ```typescript
-     * // Resume session on same device
-     * await zendfi.sessionKeys.load('uuid-of-session-key', '123456');
-     *
-     * // Now you can make payments
-     * await zendfi.sessionKeys.makePayment({...});
-     * ```
-     */
-    load(sessionKeyId: string, pin: string): Promise<void>;
-    /**
-     * Unlock a session key for auto-signing
-     *
-     * After unlocking, payments can be made without entering PIN.
-     * The decrypted keypair is cached in memory with a TTL.
-     *
-     * @param sessionKeyId - UUID of the session key
-     * @param pin - PIN to decrypt the session key
-     * @param cacheTTL - How long to cache (default: 30 minutes)
-     *
-     * @example
-     * ```typescript
-     * // Unlock once
-     * await zendfi.sessionKeys.unlock('uuid', '123456');
-     *
-     * // Make payments instantly (no PIN!)
-     * await zendfi.sessionKeys.makePayment({...}); // Instant!
-     * await zendfi.sessionKeys.makePayment({...}); // Instant!
-     * ```
-     */
-    unlock(sessionKeyId: string, pin: string, cacheTTL?: number): Promise<void>;
-    /**
-     * Make a payment using a session key
-     *
-     * If the session key is unlocked (cached), no PIN is needed.
-     * Otherwise, you must provide the PIN.
-     *
-     * @param options - Payment configuration
-     * @returns Payment result with signature
-     *
-     * @example
-     * ```typescript
-     * // With unlocked session key (no PIN)
-     * const result = await zendfi.sessionKeys.makePayment({
-     *   sessionKeyId: 'uuid',
-     *   amount: 5.0,
-     *   recipient: '8xYZA...',
-     *   description: 'Coffee purchase',
-     * });
-     *
-     * // Or with PIN (one-time)
-     * const result = await zendfi.sessionKeys.makePayment({
-     *   sessionKeyId: 'uuid',
-     *   amount: 5.0,
-     *   recipient: '8xYZA...',
-     *   pin: '123456',
-     * });
-     * ```
-     */
-    makePayment(options: MakePaymentOptions): Promise<PaymentResult$1>;
-    /**
-     * Get session key status
-     *
-     * @param sessionKeyId - UUID of the session key
-     * @returns Current status including balance and expiry
-     */
-    getStatus(sessionKeyId: string): Promise<SessionKeyInfo>;
-    /**
-     * Revoke a session key
-     *
-     * Permanently deactivates the session key. Cannot be undone.
-     *
-     * @param sessionKeyId - UUID of the session key to revoke
-     */
-    revoke(sessionKeyId: string): Promise<void>;
-    /**
-     * Recover session key on new device
-     *
-     * Use this when moving to a new device with a recovery QR code.
-     *
-     * @param options - Recovery configuration
-     *
-     * @example
-     * ```typescript
-     * await zendfi.sessionKeys.recover({
-     *   sessionKeyId: 'uuid',
-     *   recoveryQR: '{"encryptedSessionKey":"..."}',
-     *   oldPin: '123456',
-     *   newPin: '654321',
-     * });
-     * ```
-     */
-    recover(options: {
-        sessionKeyId: string;
-        recoveryQR: string;
-        oldPin: string;
-        newPin: string;
-    }): Promise<void>;
-    /**
-     * Clear cached keypair for a session key
-     *
-     * Use this on logout or when session ends.
-     *
-     * @param sessionKeyId - UUID of the session key (or all if not specified)
-     */
-    clearCache(sessionKeyId?: string): void;
-    /**
-     * Check if a session key is cached (unlocked)
-     *
-     * @param sessionKeyId - UUID of the session key
-     * @returns True if keypair is cached and auto-signing is enabled
-     */
-    isCached(sessionKeyId: string): boolean;
-    /**
-     * Get time remaining until cache expires
-     *
-     * @param sessionKeyId - UUID of the session key
-     * @returns Milliseconds until cache expires
-     */
-    getCacheTimeRemaining(sessionKeyId: string): number;
-    /**
-     * Extend cache expiry time
-     *
-     * Useful to keep session active during user activity.
-     *
-     * @param sessionKeyId - UUID of the session key
-     * @param additionalTTL - Additional time in milliseconds
-     */
-    extendCache(sessionKeyId: string, additionalTTL: number): void;
-    /**
-     * Get all loaded session key IDs
-     *
-     * @returns Array of session key UUIDs currently loaded
-     */
-    getLoadedSessionKeys(): string[];
-}
-
-/**
- * ZendFi SDK Client.
- * AZero-config TypeScript SDK for crypto payments
- */
-declare class ZendFiClient {
-    private config;
-    readonly interceptors: Interceptors;
-    /**
-     * Agent API - Manage agent API keys and sessions
-     *
-     * @example
-     * ```typescript
-     * // Create an agent API key
-     * const agentKey = await zendfi.agent.createKey({
-     *   name: 'Shopping Assistant',
-     *   agent_id: 'shopping-assistant-v1',
-     *   scopes: ['create_payments'],
-     * });
-     *
-     * // Create an agent session
-     * const session = await zendfi.agent.createSession({
-     *   agent_id: 'shopping-assistant-v1',
-     *   user_wallet: 'Hx7B...abc',
-     *   limits: { max_per_day: 500 },
-     * });
-     * ```
-     */
-    readonly agent: AgentAPI;
-    /**
-     * Payment Intents API - Two-phase payment flow
-     *
-     * @example
-     * ```typescript
-     * // Create intent
-     * const intent = await zendfi.intents.create({ amount: 99.99 });
-     *
-     * // Confirm when ready
-     * await zendfi.intents.confirm(intent.id, {
-     *   client_secret: intent.client_secret,
-     *   customer_wallet: 'Hx7B...abc',
-     * });
-     * ```
-     */
-    readonly intents: PaymentIntentsAPI;
-    /**
-     * Pricing API - PPP and AI-powered pricing
-     *
-     * @example
-     * ```typescript
-     * // Get PPP factor for Brazil
-     * const factor = await zendfi.pricing.getPPPFactor('BR');
-     * const localPrice = 100 * factor.ppp_factor; // $35 for Brazil
-     *
-     * // Get AI pricing suggestion
-     * const suggestion = await zendfi.pricing.getSuggestion({
-     *   agent_id: 'my-agent',
-     *   base_price: 100,
-     *   user_profile: { location_country: 'BR' },
-     * });
-     * ```
-     */
-    readonly pricing: PricingAPI;
-    /**
-     * Autonomy API - Enable autonomous agent signing
-     *
-     * @example
-     * ```typescript
-     * // Enable autonomous mode for a session key
-     * const delegate = await zendfi.autonomy.enable(sessionKeyId, {
-     *   max_amount_usd: 100,
-     *   duration_hours: 24,
-     *   delegation_signature: signature,
-     * });
-     *
-     * // Check status
-     * const status = await zendfi.autonomy.getStatus(sessionKeyId);
-     * ```
-     */
-    readonly autonomy: AutonomyAPI;
-    /**
-     * Smart Payments API - AI-powered payment routing
-     *
-     * Create intelligent payments that automatically:
-     * - Apply PPP discounts based on user location
-     * - Use agent sessions when available
-     * - Route to optimal payment paths
-     *
-     * @example
-     * ```typescript
-     * const payment = await zendfi.smart.create({
-     *   amount_usd: 99.99,
-     *   wallet_address: 'Hx7B...abc',
-     *   merchant_id: 'merch_123',
-     *   country_code: 'BR', // Apply PPP
-     *   enable_ppp: true,
-     * });
-     *
-     * console.log(`Original: $${payment.original_amount_usd}`);
-     * console.log(`Final: $${payment.final_amount_usd}`);
-     * // Original: $99.99
-     * // Final: $64.99 (35% PPP discount applied)
-     * ```
-     */
-    readonly smart: SmartPaymentsAPI;
-    /**
-     * Session Keys API - On-chain funded session keys with PKP identity
-     *
-     * Session keys are pre-funded wallets with spending limits that enable
-     * AI agents to make autonomous payments without user signatures.
-     *
-     * The flow:
-     * 1. Create a session key (user approves spending limit)
-     * 2. User signs the approval transaction (one-time)
-     * 3. Agent can now make payments up to the limit
-     *
-     * @example
-     * ```typescript
-     * // Create session key
-     * const key = await zendfi.sessionKeys.create({
-     *   agent_id: 'shopping-bot',
-     *   user_wallet: 'Hx7B...abc',
-     *   max_amount: 100,
-     *   expiry_hours: 24,
-     * });
-     *
-     * // User signs the approval
-     * await zendfi.sessionKeys.submitApproval(key.session_key_id, {
-     *   signed_transaction: signedTx,
-     * });
-     *
-     * // Check status
-     * const status = await zendfi.sessionKeys.getStatus(key.session_key_id);
-     * console.log(`Remaining: $${status.remaining_amount}`);
-     * ```
-     */
-    readonly sessionKeys: SessionKeysAPI;
-    constructor(options?: Partial<ZendFiConfig>);
-    /**
-     * Create a new payment
-     */
-    createPayment(request: CreatePaymentRequest): Promise<Payment>;
-    /**
-     * Get payment by ID
-     */
-    getPayment(paymentId: string): Promise<Payment>;
-    /**
-     * List all payments with pagination
-     */
-    listPayments(request?: ListPaymentsRequest): Promise<PaginatedResponse<Payment>>;
-    /**
-     * Create a subscription plan
-     */
-    createSubscriptionPlan(request: CreateSubscriptionPlanRequest): Promise<SubscriptionPlan>;
-    /**
-     * Get subscription plan by ID
-     */
-    getSubscriptionPlan(planId: string): Promise<SubscriptionPlan>;
-    /**
-     * Create a subscription
-     */
-    createSubscription(request: CreateSubscriptionRequest): Promise<Subscription>;
-    /**
-     * Get subscription by ID
-     */
-    getSubscription(subscriptionId: string): Promise<Subscription>;
-    /**
-     * Cancel a subscription
-     */
-    cancelSubscription(subscriptionId: string): Promise<Subscription>;
-    /**
-     * Create a payment link (shareable checkout URL)
-     */
-    createPaymentLink(request: CreatePaymentLinkRequest): Promise<PaymentLink>;
-    /**
-     * Get payment link by link code
-     */
-    getPaymentLink(linkCode: string): Promise<PaymentLink>;
-    /**
-     * List all payment links for the authenticated merchant
-     */
-    listPaymentLinks(): Promise<PaymentLink[]>;
-    /**
-     * Create an installment plan
-     * Split a purchase into multiple scheduled payments
-     */
-    createInstallmentPlan(request: CreateInstallmentPlanRequest): Promise<InstallmentPlan>;
-    /**
-     * Get installment plan by ID
-     */
-    getInstallmentPlan(planId: string): Promise<InstallmentPlan>;
-    /**
-     * List all installment plans for merchant
-     */
-    listInstallmentPlans(params?: {
-        limit?: number;
-        offset?: number;
-    }): Promise<InstallmentPlan[]>;
-    /**
-     * List installment plans for a specific customer
-     */
-    listCustomerInstallmentPlans(customerWallet: string): Promise<InstallmentPlan[]>;
-    /**
-     * Cancel an installment plan
-     */
-    cancelInstallmentPlan(planId: string): Promise<{
-        message: string;
-        plan_id: string;
-    }>;
-    /**
-     * Create an escrow transaction
-     * Hold funds until conditions are met
-     */
-    createEscrow(request: CreateEscrowRequest): Promise<Escrow>;
-    /**
-     * Get escrow by ID
-     */
-    getEscrow(escrowId: string): Promise<Escrow>;
-    /**
-     * List all escrows for merchant
-     */
-    listEscrows(params?: {
-        limit?: number;
-        offset?: number;
-    }): Promise<Escrow[]>;
-    /**
-     * Approve escrow release to seller
-     */
-    approveEscrow(escrowId: string, request: ApproveEscrowRequest): Promise<{
-        status: string;
-        transaction_signature?: string;
-        message: string;
-    }>;
-    /**
-     * Refund escrow to buyer
-     */
-    refundEscrow(escrowId: string, request: RefundEscrowRequest): Promise<{
-        status: string;
-        transaction_signature: string;
-        message: string;
-        reason: string;
-    }>;
-    /**
-     * Raise a dispute for an escrow
-     */
-    disputeEscrow(escrowId: string, request: DisputeEscrowRequest): Promise<{
-        status: string;
-        message: string;
-        dispute_id: string;
-        created_at: string;
-    }>;
-    /**
-     * Create an invoice
-     */
-    createInvoice(request: CreateInvoiceRequest): Promise<Invoice>;
-    /**
-     * Get invoice by ID
-     */
-    getInvoice(invoiceId: string): Promise<Invoice>;
-    /**
-     * List all invoices for merchant
-     */
-    listInvoices(): Promise<Invoice[]>;
-    /**
-     * Send invoice to customer via email
-     */
-    sendInvoice(invoiceId: string): Promise<{
-        success: boolean;
-        invoice_id: string;
-        invoice_number: string;
-        sent_to: string;
-        payment_url: string;
-        status: string;
-    }>;
-    /**
-     * Execute an AI-powered smart payment
-     *
-     * Smart payments combine multiple features:
-     * - Automatic PPP pricing adjustments
-     * - Gasless transaction detection
-     * - Instant settlement options
-     * - Escrow integration
-     * - Receipt generation
-     *
-     * @param request - Smart payment configuration
-     * @returns Payment result with status and receipt
-     *
-     * @example
-     * ```typescript
-     * const result = await zendfi.smartPayment({
-     *   agent_id: 'shopping-assistant',
-     *   user_wallet: 'Hx7B...abc',
-     *   amount_usd: 50,
-     *   auto_detect_gasless: true,
-     *   description: 'Premium subscription',
-     * });
-     *
-     * if (result.requires_signature) {
-     *   // Device-bound flow: user needs to sign
-     *   console.log('Sign and submit:', result.submit_url);
-     * } else {
-     *   // Auto-signed
-     *   console.log('Payment complete:', result.transaction_signature);
-     * }
-     * ```
-     */
-    smartPayment(request: SmartPaymentRequest): Promise<SmartPaymentResponse>;
-    /**
-     * Submit a signed transaction for device-bound smart payment
-     *
-     * @param paymentId - UUID of the payment
-     * @param signedTransaction - Base64 encoded signed transaction
-     * @returns Updated payment response
-     */
-    submitSignedPayment(paymentId: string, signedTransaction: string): Promise<SmartPaymentResponse>;
-    /**
-     * Verify webhook signature using HMAC-SHA256
-     *
-     * @param request - Webhook verification request containing payload, signature, and secret
-     * @returns true if signature is valid, false otherwise
-     *
-     * @example
-     * ```typescript
-     * const isValid = zendfi.verifyWebhook({
-     *   payload: req.body,
-     *   signature: req.headers['x-zendfi-signature'],
-     *   secret: process.env.ZENDFI_WEBHOOK_SECRET
-     * });
-     *
-     * if (!isValid) {
-     *   return res.status(401).json({ error: 'Invalid signature' });
-     * }
-     * ```
-     */
-    verifyWebhook(request: VerifyWebhookRequest): boolean;
-    /**
-     * Compute HMAC-SHA256 signature
-     * Works in both Node.js and browser environments
-     */
-    private computeHmacSignature;
-    /**
-     * Timing-safe string comparison to prevent timing attacks
-     */
-    private timingSafeEqual;
-    /**
-     * Make an HTTP request with retry logic, interceptors, and debug logging
-     */
-    private request;
-}
-/**
- * Default singleton instance
- * Auto-configured from environment
- *
- * Note: This will throw if ZENDFI_API_KEY is not set.
- * For custom configuration, create your own instance:
- * const client = new ZendFiClient({ apiKey: '...' })
- */
-declare const zendfi: ZendFiClient;
-
-/**
- * Configuration loader and environment detector
- */
-declare class ConfigLoader {
-    /**
-     * Load configuration from various sources
-     */
-    static load(options?: Partial<ZendFiConfig>): Required<ZendFiConfig>;
-    /**
-     * Detect mode (test/live) from API key prefix
-     */
-    private static detectMode;
-    /**
-     * Detect environment based on various signals
-     */
-    private static detectEnvironment;
-    /**
-     * Load API key from various sources
-     */
-    private static loadApiKey;
-    /**
-     * Get base URL for API
-     * Note: Both test and live modes use the same API endpoint.
-     * The backend routes requests to devnet or mainnet based on API key prefix.
-     */
-    private static getBaseURL;
-    /**
-     * Load credentials from CLI config file (~/.zendfi/credentials.json)
-     */
-    private static loadCLICredentials;
-    /**
-     * Validate API key format
-     */
-    static validateApiKey(apiKey: string): void;
-}
-/**
- * Generate idempotency key
- */
-declare function generateIdempotencyKey(): string;
-/**
- * Sleep utility for retry backoff
- */
-declare function sleep(ms: number): Promise<void>;
-/**
- * Client-side rate limiter to prevent hitting API rate limits
- *
- * @example
- * ```typescript
- * const limiter = new RateLimiter({
- *   maxRequests: 100,
- *   windowMs: 60000, // 100 requests per minute
- * });
- *
- * if (limiter.canMakeRequest()) {
- *   limiter.recordRequest();
- *   await zendfi.createPayment({ amount: 50 });
- * } else {
- *   const waitTime = limiter.getTimeUntilReset();
- *   console.log(`Rate limited. Try again in ${waitTime}ms`);
- * }
- * ```
- */
-declare class RateLimiter {
-    private requests;
-    private maxRequests;
-    private windowMs;
-    constructor(options?: {
-        maxRequests?: number;
-        windowMs?: number;
-    });
-    /**
-     * Check if a request can be made without exceeding rate limit
-     */
-    canMakeRequest(): boolean;
-    /**
-     * Record a request timestamp
-     */
-    recordRequest(): void;
-    /**
-     * Get remaining requests in current window
-     */
-    getRemainingRequests(): number;
-    /**
-     * Get time in ms until the rate limit window resets
-     */
-    getTimeUntilReset(): number;
-    /**
-     * Get current rate limit status
-     */
-    getStatus(): {
-        remaining: number;
-        limit: number;
-        resetInMs: number;
-        isLimited: boolean;
-    };
-    /**
-     * Reset the rate limiter (useful for testing)
-     */
-    reset(): void;
-    private pruneOldRequests;
-}
-
-/**
- * Webhook Verification Helpers
- * Convenience functions for common frameworks
- */
-
-/**
- * Verify and parse webhook for Next.js API routes
- *
- * @example
- * ```typescript
- * // app/api/webhooks/zendfi/route.ts
- * import { verifyNextWebhook } from '@zendfi/sdk/webhooks';
- *
- * export async function POST(request: Request) {
- *   const webhook = await verifyNextWebhook(request);
- *
- *   if (!webhook) {
- *     return new Response('Invalid signature', { status: 401 });
- *   }
- *
- *   // Process webhook
- *   switch (webhook.event) {
- *     case 'payment.confirmed':
- *       // Handle payment
- *       break;
- *   }
- *
- *   return new Response('OK');
- * }
- * ```
- */
-declare function verifyNextWebhook(request: Request, secret?: string): Promise<WebhookPayload | null>;
-/**
- * Verify and parse webhook for Express.js
- *
- * @example
- * ```typescript
- * import { verifyExpressWebhook } from '@zendfi/sdk/webhooks';
- *
- * app.post('/webhooks/zendfi', async (req, res) => {
- *   const webhook = await verifyExpressWebhook(req);
- *
- *   if (!webhook) {
- *     return res.status(401).json({ error: 'Invalid signature' });
- *   }
- *
- *   // Process webhook
- *   console.log('Event:', webhook.event);
- *
- *   res.json({ received: true });
- * });
- * ```
- */
-declare function verifyExpressWebhook(request: any, secret?: string): Promise<WebhookPayload | null>;
-/**
- * Verify webhook signature manually
- * Use this for custom integrations
- *
- * @example
- * ```typescript
- * import { verifyWebhookSignature } from '@zendfi/sdk/webhooks';
- *
- * const isValid = verifyWebhookSignature(
- *   payloadString,
- *   signatureHeader,
- *   process.env.ZENDFI_WEBHOOK_SECRET
- * );
- * ```
- */
-declare function verifyWebhookSignature(payload: string, signature: string, secret: string): boolean;
-
-/**
- * ZendFi Embedded Checkout
- *
- * Embed the ZendFi checkout directly into your website/app
- * without redirecting to checkout.zendfi.tech
- *
- * @example
- * ```typescript
- * import { ZendFiEmbeddedCheckout } from '@zendfi/sdk';
- *
- * const checkout = new ZendFiEmbeddedCheckout({
- *   linkCode: 'abc123xyz',
- *   containerId: 'zendfi-checkout',
- *   mode: 'live',
- *   onSuccess: (payment) => {
- *     console.log('Payment successful!', payment);
- *   },
- *   onError: (error) => {
- *     console.error('Payment failed:', error);
- *   }
- * });
- *
- * checkout.mount();
- * ```
- */
-
-interface EmbeddedCheckoutConfig {
-    /** Payment link code or payment ID */
-    linkCode?: string;
-    paymentId?: string;
-    /** Container element ID where checkout will be mounted */
-    containerId: string;
-    /** API mode - 'test' for devnet, 'live' for mainnet */
-    mode?: ApiKeyMode;
-    /** API base URL (defaults to production) */
-    apiUrl?: string;
-    /** Callback when payment is successful */
-    onSuccess?: (payment: PaymentSuccessData) => void;
-    /** Callback when payment fails */
-    onError?: (error: CheckoutError) => void;
-    /** Callback when checkout is loaded */
-    onLoad?: () => void;
-    /** Custom theme overrides */
-    theme?: CheckoutTheme;
-    /** Enable custom amount (Pay What You Want) */
-    allowCustomAmount?: boolean;
-    /** Show/hide specific payment methods */
-    paymentMethods?: {
-        walletConnect?: boolean;
-        qrCode?: boolean;
-        solanaWallet?: boolean;
-    };
-}
-interface CheckoutTheme {
-    primaryColor?: string;
-    backgroundColor?: string;
-    borderRadius?: string;
-    fontFamily?: string;
-    textColor?: string;
-    buttonStyle?: 'solid' | 'outlined' | 'minimal';
-}
-interface PaymentSuccessData {
-    paymentId: string;
-    transactionSignature: string;
-    amount: number;
-    token: string;
-    merchantName: string;
-}
-interface CheckoutError {
-    code: string;
-    message: string;
-    details?: any;
-}
-/**
- * ZendFi Embedded Checkout Component
- *
- * Provides a fully-functional checkout experience that can be
- * embedded directly into any web application.
- */
-declare class ZendFiEmbeddedCheckout {
-    private config;
-    private container;
-    private checkoutData;
-    private pollInterval;
-    private mounted;
-    private paymentProcessed;
-    constructor(config: EmbeddedCheckoutConfig);
-    private getDefaultApiUrl;
-    /**
-     * Mount the checkout to the DOM
-     */
-    mount(): Promise<void>;
-    /**
-     * Unmount and cleanup
-     */
-    unmount(): void;
-    /**
-     * Fetch checkout data from API
-     */
-    private fetchCheckoutData;
-    /**
-     * Poll for payment confirmation
-     */
-    private startPaymentPolling;
-    /**
-     * Handle successful payment
-     */
-    private handlePaymentSuccess;
-    /**
-     * Handle payment failure
-     */
-    private handlePaymentFailure;
-    /**
-     * Handle payment expiration
-     */
-    private handlePaymentExpired;
-    /**
-     * Render loading state
-     */
-    private renderLoading;
-    /**
-     * Render the main checkout UI
-     */
-    private render;
-    /**
-     * Render header section
-     */
-    private renderHeader;
-    /**
-     * Render payment information
-     */
-    private renderPaymentInfo;
-    /**
-     * Render custom amount input (Pay What You Want)
-     */
-    private renderCustomAmountInput;
-    /**
-     * Render payment methods
-     */
-    private renderPaymentMethods;
-    /**
-     * Render QR code payment method
-     */
-    private renderQRCodeMethod;
-    /**
-     * Render browser wallet method
-     */
-    private renderWalletMethod;
-    /**
-     * Render WalletConnect method
-     */
-    private renderWalletConnectMethod;
-    /**
-     * Render footer
-     */
-    private renderFooter;
-    /**
-     * Render success state
-     */
-    private renderSuccess;
-    /**
-     * Render error state
-     */
-    private renderError;
-    /**
-     * Attach event listeners to interactive elements
-     */
-    private attachEventListeners;
-    /**
-     * Handle wallet connection and payment
-     */
-    private handleWalletConnect;
-    /**
-     * Handle mobile wallet connection via Solana Pay deep link
-     */
-    private handleWalletConnectScan;
-    /**
-     * Generate QR code on canvas using QRious library
-     */
-    private generateQRCode;
-    /**
-     * Inject custom styles
-     */
-    private injectStyles;
-    /**
-     * Load external dependencies (QR code library, Solana web3.js)
-     */
-    private loadDependencies;
-    /**
-     * Load external script
-     */
-    private loadScript;
-    /**
-     * Get computed theme with defaults
-     */
-    private getComputedTheme;
-    /**
-     * Style helpers
-     */
-    private getCheckoutContainerStyles;
-    private getLoadingStyles;
-    private getSpinnerStyles;
-    private getSuccessStyles;
-    private getErrorStyles;
-}
-
-/**
- * ZendFi SDK Error Classes
- *
- * Custom error types with helpful messages, error codes, and documentation links
- */
-type ZendFiErrorType = 'authentication_error' | 'payment_error' | 'validation_error' | 'network_error' | 'rate_limit_error' | 'api_error' | 'webhook_error' | 'unknown_error';
-interface ZendFiErrorData {
-    code: string;
-    message: string;
-    type: ZendFiErrorType;
-    suggestion?: string;
-    statusCode?: number;
-    response?: unknown;
-}
-/**
- * Base ZendFi Error class with enhanced developer experience
- */
-declare class ZendFiError extends Error {
-    readonly code: string;
-    readonly type: ZendFiErrorType;
-    readonly suggestion?: string;
-    readonly docs_url: string;
-    readonly statusCode?: number;
-    readonly response?: unknown;
-    constructor(data: ZendFiErrorData);
-    /**
-     * Format error for display
-     */
-    toString(): string;
-    /**
-     * Convert error to JSON
-     */
-    toJSON(): Record<string, unknown>;
-}
-/**
- * Authentication errors
- */
-declare class AuthenticationError extends ZendFiError {
-    constructor(message: string, code?: string, suggestion?: string);
-}
-/**
- * Payment processing errors
- */
-declare class PaymentError extends ZendFiError {
-    constructor(message: string, code?: string, suggestion?: string);
-}
-/**
- * Validation errors
- */
-declare class ValidationError extends ZendFiError {
-    constructor(message: string, code?: string, suggestion?: string);
-}
-/**
- * Network/connection errors
- */
-declare class NetworkError extends ZendFiError {
-    constructor(message: string, code?: string, suggestion?: string);
-}
-/**
- * Rate limit errors
- */
-declare class RateLimitError extends ZendFiError {
-    constructor(message: string, retryAfter?: number);
-}
-/**
- * Generic API errors
- */
-declare class ApiError extends ZendFiError {
-    constructor(message: string, code: string, statusCode: number, response?: unknown);
-}
-/**
- * Webhook verification errors
- */
-declare class WebhookError extends ZendFiError {
-    constructor(message: string, code?: string, suggestion?: string);
-}
-/**
- * Error factory - creates appropriate error based on response
- */
-declare function createZendFiError(statusCode: number, responseBody: any, message?: string): ZendFiError;
-/**
- * Common error codes and their messages
- */
-declare const ERROR_CODES: {
-    readonly INVALID_API_KEY: "invalid_api_key";
-    readonly API_KEY_EXPIRED: "api_key_expired";
-    readonly API_KEY_REVOKED: "api_key_revoked";
-    readonly INSUFFICIENT_BALANCE: "insufficient_balance";
-    readonly PAYMENT_DECLINED: "payment_declined";
-    readonly PAYMENT_EXPIRED: "payment_expired";
-    readonly INVALID_AMOUNT: "invalid_amount";
-    readonly INVALID_CURRENCY: "invalid_currency";
-    readonly MISSING_REQUIRED_FIELD: "missing_required_field";
-    readonly INVALID_PARAMETER: "invalid_parameter";
-    readonly NETWORK_ERROR: "network_error";
-    readonly TIMEOUT: "timeout";
-    readonly RATE_LIMIT_EXCEEDED: "rate_limit_exceeded";
-    readonly WEBHOOK_SIGNATURE_INVALID: "webhook_signature_invalid";
-    readonly WEBHOOK_TIMESTAMP_TOO_OLD: "webhook_timestamp_too_old";
-};
-/**
- * Helper to check if error is a ZendFi error
- */
-declare function isZendFiError(error: unknown): error is ZendFiError;
-
-/**
- * Device-Bound Session Keys - Client-Side Cryptography
- *
- * This module provides TRUE non-custodial session keys where:
- * - Client generates keypair (backend NEVER sees private key)
- * - Client encrypts with PIN + device fingerprint
- * - Backend stores encrypted blob (cannot decrypt!)
- * - Client decrypts for each payment
- *
- * Security: Argon2id key derivation + AES-256-GCM encryption
- *
- * @module device-bound-crypto
- */
-
-interface DeviceFingerprint {
-    /** SHA-256 hash of device attributes */
-    fingerprint: string;
-    /** Timestamp when fingerprint was generated */
-    generatedAt: number;
-    /** Raw components (for debugging) */
-    components: {
-        canvas?: string;
-        webgl?: string;
-        audio?: string;
-        screen?: string;
-        timezone?: string;
-        languages?: string;
-        platform?: string;
-        hardwareConcurrency?: string;
-    };
-}
-interface EncryptedSessionKey {
-    /** Base64 encoded encrypted private key */
-    encryptedData: string;
-    /** Base64 encoded nonce (12 bytes) */
-    nonce: string;
-    /** Solana public key (base58) */
-    publicKey: string;
-    /** Device fingerprint hash */
-    deviceFingerprint: string;
-    /** Encryption algorithm version */
-    version: 'argon2id-aes256gcm-v1';
-}
-interface RecoveryQR {
-    /** Base64 encoded encrypted session key */
-    encryptedSessionKey: string;
-    /** Base64 encoded nonce */
-    nonce: string;
-    /** Public key */
-    publicKey: string;
-    /** Recovery QR version */
-    version: string;
-    /** Timestamp */
-    createdAt: number;
-}
-interface DeviceBoundSessionKeyOptions {
-    /** 6-digit numeric PIN */
-    pin: string;
-    /** Spending limit in USD */
-    limitUSDC: number;
-    /** Duration in days */
-    durationDays: number;
-    /** User's wallet address */
-    userWallet: string;
-    /** Generate recovery QR (recommended) */
-    generateRecoveryQR?: boolean;
-}
-declare class DeviceFingerprintGenerator {
-    /**
-     * Generate a unique device fingerprint
-     * Combines multiple browser attributes for uniqueness
-     */
-    static generate(): Promise<DeviceFingerprint>;
-    /**
-     * Graceful fallback fingerprint generation
-     * Works in headless browsers, SSR, and restricted environments
-     */
-    private static generateFallbackFingerprint;
-    private static getCanvasFingerprint;
-    private static getWebGLFingerprint;
-    private static getAudioFingerprint;
-    private static sha256;
-}
-declare class SessionKeyCrypto {
-    /**
-     * Encrypt a Solana keypair with PIN + device fingerprint
-     * Uses Argon2id for key derivation and AES-256-GCM for encryption
-     */
-    static encrypt(keypair: Keypair, pin: string, deviceFingerprint: string): Promise<EncryptedSessionKey>;
-    /**
-     * Decrypt an encrypted session key with PIN + device fingerprint
-     */
-    static decrypt(encrypted: EncryptedSessionKey, pin: string, deviceFingerprint: string): Promise<Keypair>;
-    /**
-     * Derive encryption key from PIN + device fingerprint using Argon2id
-     *
-     * Argon2id parameters (OWASP recommended):
-     * - Memory: 64MB (65536 KB)
-     * - Iterations: 3
-     * - Parallelism: 4
-     * - Salt: device fingerprint
-     */
-    private static deriveKey;
-    /**
-     * Generate random nonce for AES-GCM (12 bytes)
-     */
-    private static generateNonce;
-    /**
-     * Encrypt with AES-256-GCM
-     */
-    private static aesEncrypt;
-    /**
-     * Decrypt with AES-256-GCM
-     */
-    private static aesDecrypt;
-}
-declare class RecoveryQRGenerator {
-    /**
-     * Generate recovery QR data
-     * This allows users to recover their session key on a new device
-     */
-    static generate(encrypted: EncryptedSessionKey): RecoveryQR;
-    /**
-     * Encode recovery QR as JSON string
-     */
-    static encode(recoveryQR: RecoveryQR): string;
-    /**
-     * Decode recovery QR from JSON string
-     */
-    static decode(qrData: string): RecoveryQR;
-    /**
-     * Re-encrypt session key for new device
-     */
-    static reEncryptForNewDevice(recoveryQR: RecoveryQR, oldPin: string, oldDeviceFingerprint: string, newPin: string, newDeviceFingerprint: string): Promise<EncryptedSessionKey>;
-}
-declare class DeviceBoundSessionKey {
-    private encrypted;
-    private deviceFingerprint;
-    private sessionKeyId;
-    private recoveryQR;
-    private originalKeypair;
-    private cachedKeypair;
-    private cacheExpiry;
-    private readonly DEFAULT_CACHE_TTL_MS;
-    /**
-     * Create a new device-bound session key
-     */
-    static create(options: DeviceBoundSessionKeyOptions): Promise<DeviceBoundSessionKey>;
-    /**
-     * Get the original keypair (only available immediately after creation)
-     * Used for Lit Protocol encryption during session creation
-     * @internal
-     */
-    getKeypair(): Keypair;
-    /**
-     * Get encrypted data for backend storage
-     */
-    getEncryptedData(): EncryptedSessionKey;
-    /**
-     * Get device fingerprint
-     */
-    getDeviceFingerprint(): string;
-    /**
-     * Get public key
-     */
-    getPublicKey(): string;
-    /**
-     * Get recovery QR data (if generated)
-     */
-    getRecoveryQR(): RecoveryQR | null;
-    /**
-     * Decrypt and sign a transaction
-     *
-     * @param transaction - The transaction to sign
-     * @param pin - User's PIN (required only if keypair not cached)
-     * @param cacheKeypair - Whether to cache the decrypted keypair for future use (default: true)
-     * @param cacheTTL - Cache time-to-live in milliseconds (default: 30 minutes)
-     *
-     * @example
-     * ```typescript
-     * // First payment: requires PIN, caches keypair
-     * await sessionKey.signTransaction(tx1, '123456', true);
-     *
-     * // Subsequent payments: uses cached keypair, no PIN needed!
-     * await sessionKey.signTransaction(tx2, '', false); // PIN ignored if cached
-     *
-     * // Clear cache when done
-     * sessionKey.clearCache();
-     * ```
-     */
-    signTransaction(transaction: Transaction, pin?: string, cacheKeypair?: boolean, cacheTTL?: number): Promise<Transaction>;
-    /**
-     * Check if keypair is cached and valid
-     */
-    isCached(): boolean;
-    /**
-     * Manually cache a keypair
-     * Called internally after PIN decryption
-     */
-    private cacheKeypair;
-    /**
-     * Clear cached keypair
-     * Should be called when user logs out or session ends
-     *
-     * @example
-     * ```typescript
-     * // Clear cache on logout
-     * sessionKey.clearCache();
-     *
-     * // Or clear automatically on tab close
-     * window.addEventListener('beforeunload', () => {
-     *   sessionKey.clearCache();
-     * });
-     * ```
-     */
-    clearCache(): void;
-    /**
-     * Decrypt and cache keypair without signing a transaction
-     * Useful for pre-warming the cache before user makes payments
-     *
-     * @example
-     * ```typescript
-     * // After session key creation, decrypt and cache
-     * await sessionKey.unlockWithPin('123456');
-     *
-     * // Now all subsequent payments are instant (no PIN)
-     * await sessionKey.signTransaction(tx1, '', false); // Instant!
-     * await sessionKey.signTransaction(tx2, '', false); // Instant!
-     * ```
-     */
-    unlockWithPin(pin: string, cacheTTL?: number): Promise<void>;
-    /**
-     * Get time remaining until cache expires (in milliseconds)
-     * Returns 0 if not cached
-     */
-    getCacheTimeRemaining(): number;
-    /**
-     * Extend cache expiry time
-     * Useful to keep session active during user activity
-     *
-     * @example
-     * ```typescript
-     * // Extend cache by 15 minutes on each payment
-     * await sessionKey.signTransaction(tx, '');
-     * sessionKey.extendCache(15 * 60 * 1000);
-     * ```
-     */
-    extendCache(additionalTTL: number): void;
-    /**
-     * Set session key ID after backend creation
-     */
-    setSessionKeyId(id: string): void;
-    /**
-     * Get session key ID
-     */
-    getSessionKeyId(): string;
-}
-
-/**
- * Lit Protocol PKP Session Identity Module
- *
- * ⚠️ STATUS: EXPERIMENTAL / AUDIT TRAIL ONLY
- *
- * This module provides client-side integration with Lit Protocol for
- * on-chain session identity. When a session has `mint_pkp: true`,
- * a PKP (Programmable Key Pair) is minted to create a blockchain-verified
- * session identity for audit and compliance purposes.
- *
- * ## Current Limitations
- *
- * **PKP Cannot Sign Solana Transactions**: Due to ECDSA vs Ed25519
- * incompatibility, PKPs cannot directly sign Solana transactions.
- * The PKP serves as an IDENTITY ANCHOR and AUDIT TRAIL only.
- *
- * **Spending Limits Are Server-Side**: All spending limit enforcement
- * happens in the backend via `validate_session_and_check_limits()`.
- * The PKP does NOT enforce spending limits cryptographically.
- *
- * ## What PKP Provides
- *
- * 1. **On-chain Identity**: Verifiable session identity on Lit Protocol
- * 2. **Audit Trail**: Immutable record of session creation
- * 3. **Future Extensibility**: Foundation for cross-chain identity
- *
- * ## Future Roadmap
- *
- * - Cross-chain identity verification
- * - Solana Ed25519 support in Lit Actions (pending Lit Protocol update)
- * - Decentralized spending limit enforcement
- *
- * @example
- * ```typescript
- * import { LitCryptoSigner, requiresLitSigning } from '@zendfi/sdk';
- *
- * // Check if session has PKP identity
- * if (session.mint_pkp) {
- *   console.log('Session has on-chain identity:', session.pkp_address);
- *   // Note: This is for audit purposes only, not for signing
- * }
- *
- * // Spending limits are enforced server-side automatically
- * // No client-side PKP interaction needed for payments
- * ```
- *
- * @module lit-crypto-signer
- * @experimental
- */
-declare const SPENDING_LIMIT_ACTION_CID = "QmXXunoMeNhXhnr4onzBuvnMzDqH8rf1qdM94RKXayypX3";
-type LitNetwork = 'datil' | 'datil-test' | 'datil-dev';
-interface LitCryptoSignerConfig {
-    network?: LitNetwork;
-    apiEndpoint?: string;
-    apiKey?: string;
-    debug?: boolean;
-}
-interface SignPaymentParams {
-    sessionId: string;
-    amountUsd: number;
-    transactionToSign: string;
-    pkpPublicKey: string;
-    merchantId?: string;
-    sessionSigs?: any;
-}
-interface SignPaymentResult {
-    success: boolean;
-    signature?: string;
-    publicKey?: string;
-    recid?: number;
-    sessionId?: string;
-    amountUsd?: number;
-    remainingBudget?: number;
-    cryptoEnforced: boolean;
-    error?: string;
-    code?: string;
-    currentSpent?: number;
-    limit?: number;
-    remaining?: number;
-}
-declare class LitCryptoSigner {
-    private config;
-    private litNodeClient;
-    private connected;
-    constructor(config?: LitCryptoSignerConfig);
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    signPayment(params: SignPaymentParams): Promise<SignPaymentResult>;
-    private getSessionSigs;
-    private log;
-}
-/**
- * Helper function to check if a session has PKP identity
- * @deprecated Spending limits are enforced server-side. This checks for audit trail only.
- */
-declare function requiresLitSigning(session: {
-    crypto_enforced?: boolean;
-    mint_pkp?: boolean;
-}): boolean;
-declare function encodeTransactionForLit(transaction: Uint8Array | Buffer): string;
-declare function decodeSignatureFromLit(result: SignPaymentResult): Uint8Array | null;
-
-/**
- * Session Key Cache Manager
- * Optional caching utility for session key keypairs
- *
- * @example
- * ```typescript
- * import { SessionKeyCache } from '@zendfi/sdk/helpers';
- *
- * const cache = new SessionKeyCache({
- *   storage: 'localStorage',
- *   ttl: 3600000, // 1 hour
- *   autoRefresh: true,
- * });
- *
- * // Get cached or decrypt
- * const keypair = await cache.getCached(sessionKeyId, async () => {
- *   return await SessionKeyCrypto.decrypt(encrypted, pin, fingerprint);
- * });
- *
- * // Invalidate on logout
- * await cache.clear();
- * ```
- */
-interface CachedKeypair {
-    keypair: any;
-    expiry: number;
-    sessionKeyId: string;
-    deviceFingerprint?: string;
-}
-interface SessionKeyCacheConfig {
-    /** Storage backend */
-    storage?: 'memory' | 'localStorage' | 'indexedDB' | CustomStorageAdapter;
-    /** Time-to-live in milliseconds (default: 30 minutes) */
-    ttl?: number;
-    /** Auto-refresh before expiry (default: false) */
-    autoRefresh?: boolean;
-    /** Namespace for storage keys (default: 'zendfi_cache') */
-    namespace?: string;
-    /** Enable debug logging (default: false) */
-    debug?: boolean;
-}
-interface CustomStorageAdapter {
-    get(key: string): Promise<string | null>;
-    set(key: string, value: string): Promise<void>;
-    remove(key: string): Promise<void>;
-    clear(): Promise<void>;
-}
-/**
- * Session Key Cache Manager
- * Provides flexible caching with multiple storage backends
- */
-declare class SessionKeyCache {
-    private memoryCache;
-    private config;
-    private refreshTimers;
-    constructor(config?: SessionKeyCacheConfig);
-    /**
-     * Get cached keypair or decrypt and cache
-     */
-    getCached(sessionKeyId: string, decryptFn: () => Promise<any>, options?: {
-        deviceFingerprint?: string;
-    }): Promise<any>;
-    /**
-     * Decrypt keypair and cache it
-     */
-    private decryptAndCache;
-    /**
-     * Invalidate cached keypair
-     */
-    invalidate(sessionKeyId: string): Promise<void>;
-    /**
-     * Clear all cached keypairs
-     */
-    clear(): Promise<void>;
-    /**
-     * Get cache statistics
-     */
-    getStats(): {
-        size: number;
-        entries: Array<{
-            sessionKeyId: string;
-            expiresIn: number;
-        }>;
-    };
-    /**
-     * Check if a session key is cached and valid
-     */
-    isCached(sessionKeyId: string): boolean;
-    /**
-     * Update TTL for a cached session key
-     */
-    extendTTL(sessionKeyId: string, additionalMs: number): Promise<boolean>;
-    private getFromStorage;
-    private setInStorage;
-    private removeFromStorage;
-    private clearStorage;
-    private getFromIndexedDB;
-    private setInIndexedDB;
-    private removeFromIndexedDB;
-    private clearIndexedDB;
-    private serializeKeypair;
-    private deserializeKeypair;
-    private setupAutoRefresh;
-    private getStorageKey;
-    private log;
-}
-/**
- * Pre-configured cache instances for common use cases
- */
-declare const QuickCaches: {
-    /** Memory-only cache (30 minutes) */
-    memory: () => SessionKeyCache;
-    /** Persistent cache (1 hour, survives reload) */
-    persistent: () => SessionKeyCache;
-    /** Long-term cache (24 hours, IndexedDB) */
-    longTerm: () => SessionKeyCache;
-    /** Secure cache (5 minutes, memory-only) */
-    secure: () => SessionKeyCache;
-};
-
-/**
- * AI Intent Parser & Adapters
- * Parse natural language into payment intents
- *
- * @example
- * ```typescript
- * import { PaymentIntentParser, GeminiAdapter } from '@zendfi/sdk/helpers';
- *
- * // Parse AI response
- * const intent = PaymentIntentParser.parse(aiResponse);
- * if (intent?.action === 'payment') {
- *   await zendfi.smartPayments.execute({
- *     amount_usd: intent.amount,
- *     description: intent.description,
- *   });
- * }
- *
- * // Or use adapters
- * const gemini = new GeminiAdapter(apiKey);
- * const { text, intent } = await gemini.chat('Buy coffee for $5');
- * ```
- */
-interface ParsedIntent {
-    action: 'payment' | 'create_session' | 'check_balance' | 'check_status' | 'topup' | 'revoke' | 'enable_autonomy' | 'chat_only';
-    amount?: number;
-    description?: string;
-    confidence: number;
-    rawText: string;
-    metadata?: Record<string, any>;
-}
-interface AICapabilities {
-    createPayment?: boolean;
-    createSessionKey?: boolean;
-    checkBalance?: boolean;
-    checkStatus?: boolean;
-    topUpSession?: boolean;
-    revokeSession?: boolean;
-    enableAutonomy?: boolean;
-}
-/**
- * Payment Intent Parser
- * Extract payment information from natural language
- */
-declare class PaymentIntentParser {
-    /**
-     * Parse natural language into structured intent
-     */
-    static parse(text: string): ParsedIntent | null;
-    /**
-     * Generate system prompt for AI models
-     */
-    static generateSystemPrompt(capabilities?: AICapabilities): string;
-    private static containsPaymentKeywords;
-    private static containsSessionKeywords;
-    private static containsStatusKeywords;
-    private static containsTopUpKeywords;
-    private static containsRevokeKeywords;
-    private static containsAutonomyKeywords;
-    private static extractAmount;
-    private static extractDescription;
-}
-interface AIResponse {
-    text: string;
-    intent: ParsedIntent | null;
-    raw?: any;
-}
-/**
- * OpenAI GPT Adapter
- */
-declare class OpenAIAdapter {
-    private apiKey;
-    private model;
-    private capabilities?;
-    constructor(apiKey: string, model?: string, capabilities?: AICapabilities | undefined);
-    chat(message: string, conversationHistory?: Array<{
-        role: string;
-        content: string;
-    }>): Promise<AIResponse>;
-}
-/**
- * Anthropic Claude Adapter
- */
-declare class AnthropicAdapter {
-    private apiKey;
-    private model;
-    private capabilities?;
-    constructor(apiKey: string, model?: string, capabilities?: AICapabilities | undefined);
-    chat(message: string, conversationHistory?: Array<{
-        role: string;
-        content: string;
-    }>): Promise<AIResponse>;
-}
-/**
- * Google Gemini Adapter
- */
-declare class GeminiAdapter {
-    private apiKey;
-    private model;
-    private capabilities?;
-    constructor(apiKey: string, model?: string, capabilities?: AICapabilities | undefined);
-    chat(message: string): Promise<AIResponse>;
-}
-
-/**
- * Wallet Connector
- * Simplifies integration with Solana wallets (Phantom, Solflare, Backpack, etc.)
- *
- * @example
- * ```typescript
- * import { WalletConnector } from '@zendfi/sdk/helpers';
- *
- * // Auto-detect and connect
- * const wallet = await WalletConnector.detectAndConnect();
- * console.log(`Connected: ${wallet.address}`);
- * console.log(`Provider: ${wallet.provider}`);
- *
- * // Sign transaction
- * const result = await wallet.signTransaction(transaction);
- *
- * // Disconnect
- * await wallet.disconnect();
- * ```
- */
-interface ConnectedWallet {
-    address: string;
-    provider: 'phantom' | 'solflare' | 'backpack' | 'coinbase' | 'trust' | 'unknown';
-    publicKey: any;
-    signTransaction: (tx: any) => Promise<any>;
-    signAllTransactions: (txs: any[]) => Promise<any[]>;
-    signMessage: (message: Uint8Array) => Promise<{
-        signature: Uint8Array;
-    }>;
-    disconnect: () => Promise<void>;
-    isConnected: () => boolean;
-    raw: any;
-}
-interface WalletConnectorConfig {
-    /** Preferred wallet provider (if multiple detected) */
-    preferredProvider?: 'phantom' | 'solflare' | 'backpack' | 'coinbase' | 'trust';
-    /** Auto-connect on page load if previously connected */
-    autoConnect?: boolean;
-    /** Show connection UI if no wallet detected */
-    showInstallPrompt?: boolean;
-    /** Network (mainnet-beta, devnet, testnet) */
-    network?: string;
-}
-/**
- * Wallet Connector
- * Detects and connects to Solana wallets
- */
-declare class WalletConnector {
-    private static connectedWallet;
-    /**
-     * Detect and connect to a Solana wallet
-     */
-    static detectAndConnect(config?: WalletConnectorConfig): Promise<ConnectedWallet>;
-    /**
-     * Detect available Solana wallets
-     */
-    static detectWallets(): Array<'phantom' | 'solflare' | 'backpack' | 'coinbase' | 'trust'>;
-    /**
-     * Connect to a specific wallet provider
-     */
-    static connectToProvider(provider: 'phantom' | 'solflare' | 'backpack' | 'coinbase' | 'trust'): Promise<ConnectedWallet>;
-    /**
-     * Sign and submit a transaction
-     */
-    static signAndSubmit(transaction: any, wallet: ConnectedWallet, connection: any): Promise<{
-        signature: string;
-    }>;
-    /**
-     * Get current connected wallet
-     */
-    static getConnectedWallet(): ConnectedWallet | null;
-    /**
-     * Disconnect current wallet
-     */
-    static disconnect(): Promise<void>;
-    /**
-     * Listen for wallet connection changes
-     */
-    static onAccountChange(callback: (publicKey: any) => void): () => void;
-    /**
-     * Listen for wallet disconnection
-     */
-    static onDisconnect(callback: () => void): () => void;
+    verifyWebhook(request: VerifyWebhookRequest): boolean;
     /**
-     * Show install prompt UI
+     * Compute HMAC-SHA256 signature
+     * Works in both Node.js and browser environments
      */
-    private static showInstallPrompt;
+    private computeHmacSignature;
     /**
-     * Check if wallet is installed
+     * Timing-safe string comparison to prevent timing attacks
      */
-    static isWalletInstalled(provider: 'phantom' | 'solflare' | 'backpack' | 'coinbase' | 'trust'): boolean;
+    private timingSafeEqual;
     /**
-     * Get wallet download URL
+     * Make an HTTP request with retry logic, interceptors, and debug logging
      */
-    static getWalletUrl(provider: 'phantom' | 'solflare' | 'backpack' | 'coinbase' | 'trust'): string;
+    private request;
 }
 /**
- * React Hook for Wallet Connection (optional)
- * Export as separate module to avoid forcing React dependency
- */
-declare function createWalletHook(): () => {
-    wallet: any;
-    connecting: any;
-    error: any;
-    connect: (config?: WalletConnectorConfig) => Promise<void>;
-    disconnect: () => Promise<void>;
-    isConnected: boolean;
-};
-
-/**
- * Security Utilities
- * PIN validation, rate limiting, and security best practices
- *
- * @example
- * ```typescript
- * import { PINValidator, PINRateLimiter } from '@zendfi/sdk/helpers';
- *
- * // Validate PIN
- * const validation = PINValidator.validate(pin);
- * if (!validation.valid) {
- *   console.error(validation.errors);
- * }
+ * Default singleton instance
+ * Auto-configured from environment
  *
- * // Rate limit PIN attempts
- * const limiter = new PINRateLimiter();
- * const attempt = await limiter.checkAttempt(sessionKeyId);
- * if (!attempt.allowed) {
- *   console.log(`Locked out for ${attempt.lockoutSeconds}s`);
- * }
- * ```
+ * Note: This will throw if ZENDFI_API_KEY is not set.
+ * For custom configuration, create your own instance:
+ * const client = new ZendFiClient({ apiKey: '...' })
  */
-interface PINValidationResult {
-    valid: boolean;
-    strength: 'weak' | 'medium' | 'strong';
-    errors: string[];
-    suggestions: string[];
-}
+declare const zendfi: ZendFiClient;
+
 /**
- * PIN Validator
- * Validates PIN security and strength
+ * Configuration loader and environment detector
  */
-declare class PINValidator {
+declare class ConfigLoader {
     /**
-     * Validate PIN strength and format
+     * Load configuration from various sources
      */
-    static validate(pin: string): PINValidationResult;
+    static load(options?: Partial<ZendFiConfig>): Required<ZendFiConfig>;
     /**
-     * Check PIN strength (0-100 score)
+     * Detect mode (test/live) from API key prefix
      */
-    static strengthScore(pin: string): number;
+    private static detectMode;
     /**
-     * Generate a secure random PIN
+     * Detect environment based on various signals
      */
-    static generateSecureRandom(length?: number): string;
+    private static detectEnvironment;
     /**
-     * Check for weak patterns
+     * Load API key from various sources
      */
-    private static isWeakPattern;
+    private static loadApiKey;
     /**
-     * Check if PIN is sequential
+     * Get base URL for API
+     * Note: Both test and live modes use the same API endpoint.
+     * The backend routes requests to devnet or mainnet based on API key prefix.
      */
-    private static isSequential;
+    private static getBaseURL;
     /**
-     * Check if PIN has repeated digits
+     * Load credentials from CLI config file (~/.zendfi/credentials.json)
      */
-    private static hasRepeatedDigits;
+    private static loadCLICredentials;
     /**
-     * Hash PIN for storage (if needed)
-     * Note: For device-bound keys, the PIN is used for key derivation, not storage
+     * Validate API key format
      */
-    static hashPIN(pin: string, salt?: string): Promise<string>;
+    static validateApiKey(apiKey: string): void;
 }
 /**
- * PIN Rate Limiter
- * Prevents brute-force attacks on PIN entry
+ * Generate idempotency key
+ */
+declare function generateIdempotencyKey(): string;
+/**
+ * Sleep utility for retry backoff
+ */
+declare function sleep(ms: number): Promise<void>;
+/**
+ * Client-side rate limiter to prevent hitting API rate limits
+ *
+ * @example
+ * ```typescript
+ * const limiter = new RateLimiter({
+ *   maxRequests: 100,
+ *   windowMs: 60000, // 100 requests per minute
+ * });
+ *
+ * if (limiter.canMakeRequest()) {
+ *   limiter.recordRequest();
+ *   await zendfi.createPayment({ amount: 50 });
+ * } else {
+ *   const waitTime = limiter.getTimeUntilReset();
+ *   console.log(`Rate limited. Try again in ${waitTime}ms`);
+ * }
+ * ```
  */
-declare class PINRateLimiter {
-    private attempts;
-    private locked;
-    private maxAttempts;
+declare class RateLimiter {
+    private requests;
+    private maxRequests;
     private windowMs;
-    private lockoutMs;
-    constructor(config?: {
-        maxAttempts?: number;
+    constructor(options?: {
+        maxRequests?: number;
         windowMs?: number;
-        lockoutMs?: number;
     });
     /**
-     * Check if attempt is allowed
-     */
-    checkAttempt(sessionKeyId: string): Promise<{
-        allowed: boolean;
-        remainingAttempts: number;
-        lockoutSeconds?: number;
-    }>;
-    /**
-     * Record a failed attempt
+     * Check if a request can be made without exceeding rate limit
      */
-    recordFailedAttempt(sessionKeyId: string): void;
+    canMakeRequest(): boolean;
     /**
-     * Record a successful attempt (clears history)
+     * Record a request timestamp
      */
-    recordSuccessfulAttempt(sessionKeyId: string): void;
+    recordRequest(): void;
     /**
-     * Get recent attempts within window
+     * Get remaining requests in current window
      */
-    private getRecentAttempts;
+    getRemainingRequests(): number;
     /**
-     * Clear all rate limit data
+     * Get time in ms until the rate limit window resets
      */
-    clear(): void;
+    getTimeUntilReset(): number;
     /**
-     * Check lockout status
+     * Get current rate limit status
      */
-    isLockedOut(sessionKeyId: string): boolean;
+    getStatus(): {
+        remaining: number;
+        limit: number;
+        resetInMs: number;
+        isLimited: boolean;
+    };
     /**
-     * Get remaining lockout time
+     * Reset the rate limiter (useful for testing)
      */
-    getRemainingLockoutTime(sessionKeyId: string): number;
+    reset(): void;
+    private pruneOldRequests;
 }
+
 /**
- * Secure Storage Helper
- * Utilities for secure data storage
+ * Webhook Verification Helpers
+ * Convenience functions for common frameworks
  */
-declare class SecureStorage {
-    /**
-     * Store data with encryption (basic)
-     * For production, consider using Web Crypto API with user-derived keys
-     */
-    static setEncrypted(key: string, value: string, secret: string): Promise<void>;
-    /**
-     * Retrieve encrypted data
-     */
-    static getEncrypted(key: string, secret: string): Promise<string | null>;
-    /**
-     * Encrypt string with AES-GCM
-     */
-    private static encrypt;
-    /**
-     * Decrypt AES-GCM ciphertext
-     */
-    private static decrypt;
-    /**
-     * Derive encryption key from secret
-     */
-    private static deriveKey;
-    /**
-     * Clear all secure storage
-     */
-    static clearAll(namespace?: string): void;
-}
 
 /**
- * Transaction Polling Utilities
- * Poll Solana transactions with exponential backoff
+ * Verify and parse webhook for Next.js API routes
  *
  * @example
  * ```typescript
- * import { TransactionPoller } from '@zendfi/sdk/helpers';
+ * // app/api/webhooks/zendfi/route.ts
+ * import { verifyNextWebhook } from '@zendfi/sdk/webhooks';
  *
- * // Wait for confirmation
- * const status = await TransactionPoller.waitForConfirmation(
- *   signature,
- *   { timeout: 60000, interval: 2000 }
- * );
+ * export async function POST(request: Request) {
+ *   const webhook = await verifyNextWebhook(request);
+ *
+ *   if (!webhook) {
+ *     return new Response('Invalid signature', { status: 401 });
+ *   }
+ *
+ *   // Process webhook
+ *   switch (webhook.event) {
+ *     case 'payment.confirmed':
+ *       // Handle payment
+ *       break;
+ *   }
  *
- * if (status.confirmed) {
- *   console.log(`Confirmed in slot ${status.slot}`);
+ *   return new Response('OK');
  * }
  * ```
  */
-interface TransactionStatus {
-    confirmed: boolean;
-    signature: string;
-    slot?: number;
-    blockTime?: number;
-    confirmations?: number;
-    error?: string;
-}
-interface PollingOptions {
-    /** Maximum time to wait in ms (default: 60000 = 1 minute) */
-    timeout?: number;
-    /** Initial polling interval in ms (default: 2000 = 2 seconds) */
-    interval?: number;
-    /** Maximum polling interval in ms (default: 10000 = 10 seconds) */
-    maxInterval?: number;
-    /** Maximum number of attempts (default: 30) */
-    maxAttempts?: number;
-    /** Commitment level (default: 'confirmed') */
-    commitment?: 'processed' | 'confirmed' | 'finalized';
-    /** RPC endpoint (optional, uses default if not provided) */
-    rpcUrl?: string;
-}
+declare function verifyNextWebhook(request: Request, secret?: string): Promise<WebhookPayload | null>;
 /**
- * Transaction Poller
- * Poll transaction status with smart backoff
+ * Verify and parse webhook for Express.js
+ *
+ * @example
+ * ```typescript
+ * import { verifyExpressWebhook } from '@zendfi/sdk/webhooks';
+ *
+ * app.post('/webhooks/zendfi', async (req, res) => {
+ *   const webhook = await verifyExpressWebhook(req);
+ *
+ *   if (!webhook) {
+ *     return res.status(401).json({ error: 'Invalid signature' });
+ *   }
+ *
+ *   // Process webhook
+ *   console.log('Event:', webhook.event);
+ *
+ *   res.json({ received: true });
+ * });
+ * ```
  */
-declare class TransactionPoller {
-    /**
-     * Wait for transaction confirmation
-     */
-    static waitForConfirmation(signature: string, options?: PollingOptions): Promise<TransactionStatus>;
-    /**
-     * Check transaction status via RPC
-     */
-    private static checkTransactionStatus;
-    /**
-     * Check if commitment level is reached
-     */
-    private static isCommitmentReached;
-    /**
-     * Get default RPC URL based on environment
-     */
-    private static getDefaultRpcUrl;
-    /**
-     * Poll multiple transactions in parallel
-     */
-    static waitForMultiple(signatures: string[], options?: PollingOptions): Promise<TransactionStatus[]>;
-    /**
-     * Get transaction details after confirmation
-     */
-    static getTransactionDetails(signature: string, rpcUrl?: string): Promise<any>;
-    /**
-     * Check if transaction exists on chain
-     */
-    static exists(signature: string, rpcUrl?: string): Promise<boolean>;
-    /**
-     * Get recent blockhash (useful for transaction building)
-     */
-    static getRecentBlockhash(rpcUrl?: string): Promise<{
-        blockhash: string;
-        lastValidBlockHeight: number;
-    }>;
-    /**
-     * Sleep utility
-     */
-    private static sleep;
-}
+declare function verifyExpressWebhook(request: any, secret?: string): Promise<WebhookPayload | null>;
 /**
- * Transaction Monitor
- * Monitor transaction status with callbacks
+ * Verify webhook signature manually
+ * Use this for custom integrations
+ *
+ * @example
+ * ```typescript
+ * import { verifyWebhookSignature } from '@zendfi/sdk/webhooks';
+ *
+ * const isValid = verifyWebhookSignature(
+ *   payloadString,
+ *   signatureHeader,
+ *   process.env.ZENDFI_WEBHOOK_SECRET
+ * );
+ * ```
  */
-declare class TransactionMonitor {
-    private monitors;
-    /**
-     * Start monitoring a transaction
-     */
-    monitor(signature: string, callbacks: {
-        onConfirmed?: (status: TransactionStatus) => void;
-        onFailed?: (status: TransactionStatus) => void;
-        onTimeout?: () => void;
-    }, options?: PollingOptions): void;
-    /**
-     * Stop monitoring a transaction
-     */
-    stopMonitoring(signature: string): void;
-    /**
-     * Stop all monitors
-     */
-    stopAll(): void;
-    /**
-     * Get active monitors
-     */
-    getActiveMonitors(): string[];
+declare function verifyWebhookSignature(payload: string, signature: string, secret: string): boolean;
+
+/**
+ * ZendFi Embedded Checkout
+ *
+ * Embed the ZendFi checkout directly into your website/app
+ * without redirecting to checkout.zendfi.tech
+ *
+ * @example
+ * ```typescript
+ * import { ZendFiEmbeddedCheckout } from '@zendfi/sdk';
+ *
+ * const checkout = new ZendFiEmbeddedCheckout({
+ *   linkCode: 'abc123xyz',
+ *   containerId: 'zendfi-checkout',
+ *   mode: 'live',
+ *   onSuccess: (payment) => {
+ *     console.log('Payment successful!', payment);
+ *   },
+ *   onError: (error) => {
+ *     console.error('Payment failed:', error);
+ *   }
+ * });
+ *
+ * checkout.mount();
+ * ```
+ */
+
+interface EmbeddedCheckoutConfig {
+    /** Payment link code or payment ID */
+    linkCode?: string;
+    paymentId?: string;
+    /** Container element ID where checkout will be mounted */
+    containerId: string;
+    /** API mode - 'test' for devnet, 'live' for mainnet */
+    mode?: ApiKeyMode;
+    /** API base URL (defaults to production) */
+    apiUrl?: string;
+    /** Callback when payment is successful */
+    onSuccess?: (payment: PaymentSuccessData) => void;
+    /** Callback when payment fails */
+    onError?: (error: CheckoutError) => void;
+    /** Callback when checkout is loaded */
+    onLoad?: () => void;
+    /** Custom theme overrides */
+    theme?: CheckoutTheme;
+    /** Enable custom amount (Pay What You Want) */
+    allowCustomAmount?: boolean;
+    /** Show/hide specific payment methods */
+    paymentMethods?: {
+        walletConnect?: boolean;
+        qrCode?: boolean;
+        solanaWallet?: boolean;
+        bank?: boolean;
+    };
+}
+interface CheckoutTheme {
+    primaryColor?: string;
+    backgroundColor?: string;
+    borderRadius?: string;
+    fontFamily?: string;
+    textColor?: string;
+    buttonStyle?: 'solid' | 'outlined' | 'minimal';
 }
-
-/**
- * Retry Strategy & Error Recovery
- * Smart retry logic with exponential backoff
- *
- * @example
- * ```typescript
- * import { RetryStrategy, ErrorRecovery } from '@zendfi/sdk/helpers';
- *
- * // Retry with exponential backoff
- * const result = await RetryStrategy.withRetry(
- *   () => zendfi.smartPayments.execute({ amount_usd: 50 }),
- *   { maxAttempts: 3, backoffMs: 1000 }
- * );
- *
- * // Auto-recover from common errors
- * const payment = await ErrorRecovery.recoverFromNetworkError(
- *   () => createPayment()
- * );
- * ```
- */
-interface RetryOptions {
-    /** Maximum number of retry attempts (default: 3) */
-    maxAttempts?: number;
-    /** Initial backoff delay in ms (default: 1000) */
-    backoffMs?: number;
-    /** Backoff multiplier (default: 2 for exponential) */
-    backoffMultiplier?: number;
-    /** Maximum backoff delay in ms (default: 30000) */
-    maxBackoffMs?: number;
-    /** Function to determine if error is retryable (default: all errors) */
-    shouldRetry?: (error: Error, attempt: number) => boolean;
-    /** Callback on each retry */
-    onRetry?: (error: Error, attempt: number, nextDelayMs: number) => void;
+interface PaymentSuccessData {
+    paymentId: string;
+    transactionSignature: string;
+    amount: number;
+    token: string;
+    merchantName: string;
+}
+interface CheckoutError {
+    code: string;
+    message: string;
+    details?: any;
 }
 /**
- * Retry Strategy
- * Implements smart retry logic with exponential backoff
+ * ZendFi Embedded Checkout Component
+ *
+ * Provides a fully-functional checkout experience that can be
+ * embedded directly into any web application.
  */
-declare class RetryStrategy {
-    /**
-     * Execute function with retry logic
-     */
-    static withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
-    /**
-     * Retry with linear backoff
-     */
-    static withLinearRetry<T>(fn: () => Promise<T>, maxAttempts?: number, delayMs?: number): Promise<T>;
-    /**
-     * Retry with custom backoff function
-     */
-    static withCustomBackoff<T>(fn: () => Promise<T>, backoffFn: (attempt: number) => number, maxAttempts?: number): Promise<T>;
+declare class ZendFiEmbeddedCheckout {
+    private config;
+    private container;
+    private checkoutData;
+    private pollInterval;
+    private mounted;
+    private paymentProcessed;
+    private bankPaymentState;
+    constructor(config: EmbeddedCheckoutConfig);
+    private getDefaultApiUrl;
     /**
-     * Check if error is retryable
+     * Mount the checkout to the DOM
      */
-    static isRetryableError(error: any): boolean;
-    private static sleep;
-}
-/**
- * Error Recovery
- * Auto-recovery strategies for common failure scenarios
- */
-declare class ErrorRecovery {
+    mount(): Promise<void>;
     /**
-     * Recover from network errors with retry
+     * Unmount and cleanup
      */
-    static recoverFromNetworkError<T>(fn: () => Promise<T>, maxAttempts?: number): Promise<T>;
+    unmount(): void;
     /**
-     * Recover from rate limit errors with exponential backoff
+     * Fetch checkout data from API
      */
-    static recoverFromRateLimit<T>(fn: () => Promise<T>, maxAttempts?: number): Promise<T>;
+    private fetchCheckoutData;
     /**
-     * Recover from Solana RPC errors (blockhash, etc.)
+     * Poll for payment confirmation
      */
-    static recoverFromRPCError<T>(fn: () => Promise<T>, maxAttempts?: number): Promise<T>;
+    private startPaymentPolling;
     /**
-     * Recover from timeout errors
+     * Handle successful payment
      */
-    static recoverFromTimeout<T>(fn: () => Promise<T>, timeoutMs?: number, maxAttempts?: number): Promise<T>;
+    private handlePaymentSuccess;
     /**
-     * Add timeout to async function
+     * Handle payment failure
      */
-    private static withTimeout;
+    private handlePaymentFailure;
     /**
-     * Circuit breaker pattern for repeated failures
+     * Handle payment expiration
      */
-    static createCircuitBreaker<T>(fn: () => Promise<T>, options?: {
-        failureThreshold?: number;
-        resetTimeoutMs?: number;
-        onStateChange?: (state: 'closed' | 'open' | 'half-open') => void;
-    }): () => Promise<T>;
+    private handlePaymentExpired;
     /**
-     * Fallback to alternative function on error
+     * Render loading state
      */
-    static withFallback<T>(primaryFn: () => Promise<T>, fallbackFn: () => Promise<T>, shouldFallback?: (error: Error) => boolean): Promise<T>;
+    private renderLoading;
     /**
-     * Graceful degradation - return partial result on error
+     * Render the main checkout UI
      */
-    static withGracefulDegradation<T>(fn: () => Promise<T>, defaultValue: T, onError?: (error: Error) => void): Promise<T>;
-}
-
-/**
- * Session Key Lifecycle Manager
- * High-level wrapper for device-bound session keys
- * Handles common patterns: create → cache → use → revoke
- *
- * @example
- * ```typescript
- * import { SessionKeyLifecycle } from '@zendfi/sdk/helpers';
- *
- * const lifecycle = new SessionKeyLifecycle(zendfi, {
- *   cache: QuickCaches.persistent(),
- *   pinProvider: () => promptUserForPIN(),
- * });
- *
- * // Create and fund in one call
- * await lifecycle.createAndFund({
- *   userWallet: address,
- *   agentId: 'my-agent',
- *   limitUsdc: 100,
- * });
- *
- * // Make payments (auto-handles caching/PIN)
- * await lifecycle.pay(5, 'Coffee');
- *
- * // Cleanup on app close
- * await lifecycle.cleanup();
- * ```
- */
-
-interface LifecycleConfig {
-    /** Optional cache instance */
-    cache?: SessionKeyCache;
-    /** PIN provider function (called when cache expires) */
-    pinProvider?: () => Promise<string>;
-    /** Device fingerprint generator */
-    deviceFingerprintProvider?: () => Promise<string>;
-    /** Auto-cleanup on window/tab close */
-    autoCleanup?: boolean;
-}
-interface CreateAndFundConfig {
-    userWallet: string;
-    agentId: string;
-    agentName?: string;
-    limitUsdc: number;
-    durationDays?: number;
-    onApprovalNeeded?: (transaction: string) => Promise<string>;
-}
-interface PaymentResult {
-    paymentId: string;
-    status: string;
-    signature?: string;
-    confirmedInMs?: number;
-}
-/**
- * Session Key Lifecycle Manager
- * Simplifies device-bound session key management
- */
-declare class SessionKeyLifecycle {
-    private client;
-    private config;
-    private sessionKeyId;
-    private sessionWallet;
-    constructor(client: ZendFiClient, config?: LifecycleConfig);
+    private render;
     /**
-     * Create and fund session key in one call
-     * Handles: keypair generation → encryption → backend registration
-     * Note: The SDK now handles all crypto internally
+     * Render header section
      */
-    createAndFund(config: CreateAndFundConfig): Promise<{
-        sessionKeyId: string;
-        sessionWallet: string;
-    }>;
+    private renderHeader;
     /**
-     * Make a payment using the session key
-     * Uses the new SDK's makePayment which handles caching internally
+     * Render payment information
      */
-    pay(amount: number, description: string): Promise<PaymentResult>;
+    private renderPaymentInfo;
     /**
-     * Check session key status
+     * Render custom amount input (Pay What You Want)
      */
-    getStatus(): Promise<{
-        sessionKeyId: string;
-        isActive: boolean;
-        isApproved: boolean;
-        limitUsdc: number;
-        usedAmountUsdc: number;
-        remainingUsdc: number;
-        expiresAt: string;
-        daysUntilExpiry: number;
-    }>;
+    private renderCustomAmountInput;
     /**
-     * Top up session key
-     * @deprecated Device-bound session keys are funded directly by the user.
-     * Use the session wallet address to send funds directly.
+     * Render payment methods
      */
-    topUp(_amount: number, _userWallet: string, _onApprovalNeeded?: (tx: string) => Promise<void>): Promise<void>;
+    private renderPaymentMethods;
     /**
-     * Revoke session key
+     * Render QR code payment method
      */
-    revoke(): Promise<void>;
+    private renderQRCodeMethod;
     /**
-     * Cleanup (clear cache, reset state)
+     * Render browser wallet method
      */
-    cleanup(): Promise<void>;
+    private renderWalletMethod;
     /**
-     * Get current session key ID
+     * Render WalletConnect method
      */
-    getSessionKeyId(): string | null;
+    private renderWalletConnectMethod;
     /**
-     * Check if session is active
+     * Render bank payment method (PAJ Ramp onramp)
      */
-    isActive(): boolean;
-    private promptForPIN;
-}
-/**
- * Quick setup function for common use case
- */
-declare function setupQuickSessionKey(client: ZendFiClient, config: {
-    userWallet: string;
-    agentId: string;
-    budgetUsdc: number;
-    onApproval: (tx: string) => Promise<string>;
-}): Promise<SessionKeyLifecycle>;
-
-/**
- * Development Tools & Utilities
- * Debugging helpers for development and testing
- *
- * @example
- * ```typescript
- * import { DevTools } from '@zendfi/sdk/helpers';
- *
- * // Enable debug mode
- * DevTools.enableDebugMode();
- *
- * // Create test session key
- * const testKey = await DevTools.createTestSessionKey();
- *
- * // Mock wallet for testing
- * const mockWallet = DevTools.mockWallet();
- *
- * // Log transaction flow
- * DevTools.logTransactionFlow(paymentId);
- * ```
- */
-interface MockWallet {
-    address: string;
-    publicKey: any;
-    signTransaction: (tx: any) => Promise<any>;
-    signMessage: (msg: Uint8Array) => Promise<{
-        signature: Uint8Array;
-    }>;
-    isConnected: () => boolean;
-    disconnect: () => Promise<void>;
-}
-interface TestSessionKey {
-    sessionKeyId: string;
-    sessionWallet: string;
-    privateKey: Uint8Array;
-    budget: number;
-}
-/**
- * Development Tools
- * Utilities for debugging and testing
- */
-declare class DevTools {
-    private static debugEnabled;
-    private static requestLog;
+    private renderBankMethod;
     /**
-     * Enable debug mode (logs all API requests/responses)
+     * Render bank email/OTP step
      */
-    static enableDebugMode(): void;
+    private renderBankEmailStep;
     /**
-     * Disable debug mode
+     * Render bank details step
      */
-    static disableDebugMode(): void;
+    private renderBankDetailsStep;
     /**
-     * Check if debug mode is enabled
+     * Render footer
      */
-    static isDebugEnabled(): boolean;
+    private renderFooter;
     /**
-     * Log API request
+     * Render success state
      */
-    static logRequest(method: string, url: string, body?: any): void;
+    private renderSuccess;
     /**
-     * Log API response
+     * Render error state
      */
-    static logResponse(method: string, url: string, status: number, data: any, duration?: number): void;
+    private renderError;
     /**
-     * Get request log
+     * Attach event listeners to interactive elements
      */
-    static getRequestLog(): Array<{
-        timestamp: Date;
-        method: string;
-        url: string;
-        status?: number;
-        duration?: number;
-    }>;
+    private attachEventListeners;
     /**
-     * Clear request log
+     * Handle wallet connection and payment
      */
-    static clearRequestLog(): void;
+    private handleWalletConnect;
     /**
-     * Create a test session key (devnet only)
+     * Handle mobile wallet connection via Solana Pay deep link
      */
-    static createTestSessionKey(): Promise<TestSessionKey>;
+    private handleWalletConnectScan;
     /**
-     * Create a mock wallet for testing
+     * Generate QR code on canvas using QRious library
      */
-    static mockWallet(address?: string): MockWallet;
+    private generateQRCode;
     /**
-     * Log transaction flow (visual diagram in console)
+     * Inject custom styles
      */
-    static logTransactionFlow(paymentId: string): void;
+    private injectStyles;
     /**
-     * Log session key lifecycle
+     * Load external dependencies (QR code library, Solana web3.js)
      */
-    static logSessionKeyLifecycle(sessionKeyId: string): void;
+    private loadDependencies;
     /**
-     * Benchmark API request
+     * Load external script
      */
-    static benchmarkRequest<T>(name: string, fn: () => Promise<T>): Promise<{
-        result: T;
-        durationMs: number;
-    }>;
+    private loadScript;
     /**
-     * Stress test (send multiple concurrent requests)
+     * Get computed theme with defaults
      */
-    static stressTest<T>(name: string, fn: () => Promise<T>, concurrency?: number, iterations?: number): Promise<{
-        totalRequests: number;
-        successful: number;
-        failed: number;
-        avgDurationMs: number;
-        minDurationMs: number;
-        maxDurationMs: number;
-    }>;
+    private getComputedTheme;
     /**
-     * Inspect ZendFi SDK configuration
+     * Style helpers
      */
-    static inspectConfig(client: any): void;
+    private getCheckoutContainerStyles;
+    private getLoadingStyles;
+    private getSpinnerStyles;
+    private getSuccessStyles;
+    private getErrorStyles;
     /**
-     * Generate test data
+     * Handle bank payment submit (send OTP or verify OTP)
      */
-    static generateTestData(): {
-        userWallet: string;
-        agentId: string;
-        sessionKeyId: string;
-        paymentId: string;
-    };
+    private handleBankSubmit;
     /**
-     * Check if running in development environment
+     * Start polling bank payment status
      */
-    private static isDevelopment;
+    private startBankStatusPolling;
     /**
-     * Generate test Solana address
+     * Check bank payment status
      */
-    private static generateTestAddress;
+    private checkBankPaymentStatus;
     /**
-     * Generate test ID with prefix
+     * Handle successful bank payment
      */
-    private static generateTestId;
+    private handleBankPaymentSuccess;
     /**
-     * Get Solana Web3.js
+     * Manually refresh bank payment status
      */
-    private static getSolanaWeb3;
+    private refreshBankStatus;
 }
+
 /**
- * Performance Monitor
- * Track SDK performance metrics
+ * ZendFi SDK Error Classes
+ *
+ * Custom error types with helpful messages, error codes, and documentation links
  */
-declare class PerformanceMonitor {
-    private metrics;
-    /**
-     * Record a metric
-     */
-    record(name: string, value: number): void;
-    /**
-     * Get statistics for a metric
-     */
-    getStats(name: string): {
-        count: number;
-        avg: number;
-        min: number;
-        max: number;
-        p50: number;
-        p95: number;
-        p99: number;
-    } | null;
-    /**
-     * Get all metrics
-     */
-    getAllStats(): Record<string, ReturnType<typeof this.getStats>>;
+type ZendFiErrorType = 'authentication_error' | 'payment_error' | 'validation_error' | 'network_error' | 'rate_limit_error' | 'api_error' | 'webhook_error' | 'unknown_error';
+interface ZendFiErrorData {
+    code: string;
+    message: string;
+    type: ZendFiErrorType;
+    suggestion?: string;
+    statusCode?: number;
+    response?: unknown;
+}
+/**
+ * Base ZendFi Error class with enhanced developer experience
+ */
+declare class ZendFiError extends Error {
+    readonly code: string;
+    readonly type: ZendFiErrorType;
+    readonly suggestion?: string;
+    readonly docs_url: string;
+    readonly statusCode?: number;
+    readonly response?: unknown;
+    constructor(data: ZendFiErrorData);
     /**
-     * Print report
+     * Format error for display
      */
-    printReport(): void;
+    toString(): string;
     /**
-     * Clear all metrics
+     * Convert error to JSON
      */
-    clear(): void;
+    toJSON(): Record<string, unknown>;
+}
+/**
+ * Authentication errors
+ */
+declare class AuthenticationError extends ZendFiError {
+    constructor(message: string, code?: string, suggestion?: string);
 }
+/**
+ * Payment processing errors
+ */
+declare class PaymentError extends ZendFiError {
+    constructor(message: string, code?: string, suggestion?: string);
+}
+/**
+ * Validation errors
+ */
+declare class ValidationError extends ZendFiError {
+    constructor(message: string, code?: string, suggestion?: string);
+}
+/**
+ * Network/connection errors
+ */
+declare class NetworkError extends ZendFiError {
+    constructor(message: string, code?: string, suggestion?: string);
+}
+/**
+ * Rate limit errors
+ */
+declare class RateLimitError extends ZendFiError {
+    constructor(message: string, retryAfter?: number);
+}
+/**
+ * Generic API errors
+ */
+declare class ApiError extends ZendFiError {
+    constructor(message: string, code: string, statusCode: number, response?: unknown);
+}
+/**
+ * Webhook verification errors
+ */
+declare class WebhookError extends ZendFiError {
+    constructor(message: string, code?: string, suggestion?: string);
+}
+/**
+ * Error factory - creates appropriate error based on response
+ */
+declare function createZendFiError(statusCode: number, responseBody: any, message?: string): ZendFiError;
+/**
+ * Common error codes and their messages
+ */
+declare const ERROR_CODES: {
+    readonly INVALID_API_KEY: "invalid_api_key";
+    readonly API_KEY_EXPIRED: "api_key_expired";
+    readonly API_KEY_REVOKED: "api_key_revoked";
+    readonly INSUFFICIENT_BALANCE: "insufficient_balance";
+    readonly PAYMENT_DECLINED: "payment_declined";
+    readonly PAYMENT_EXPIRED: "payment_expired";
+    readonly INVALID_AMOUNT: "invalid_amount";
+    readonly INVALID_CURRENCY: "invalid_currency";
+    readonly MISSING_REQUIRED_FIELD: "missing_required_field";
+    readonly INVALID_PARAMETER: "invalid_parameter";
+    readonly NETWORK_ERROR: "network_error";
+    readonly TIMEOUT: "timeout";
+    readonly RATE_LIMIT_EXCEEDED: "rate_limit_exceeded";
+    readonly WEBHOOK_SIGNATURE_INVALID: "webhook_signature_invalid";
+    readonly WEBHOOK_TIMESTAMP_TOO_OLD: "webhook_timestamp_too_old";
+};
+/**
+ * Helper to check if error is a ZendFi error
+ */
+declare function isZendFiError(error: unknown): error is ZendFiError;
 
-export { AgentAPI, AgentAnalytics, AgentApiKey, AgentPaymentRequest, AgentPaymentResponse, AgentSession, AnthropicAdapter, ApiError, ApiKeyMode, ApproveEscrowRequest, AuthenticationError, AutonomyAPI, AutonomyStatus, type CachedKeypair, type CheckoutError, type CheckoutTheme, ConfigLoader, ConfirmPaymentIntentRequest, type ConnectedWallet, CreateAgentApiKeyRequest, CreateAgentSessionRequest, type CreateAndFundConfig, CreateEscrowRequest, CreateInstallmentPlanRequest, CreateInvoiceRequest, CreatePaymentIntentRequest, CreatePaymentLinkRequest, CreatePaymentRequest, CreateSubscriptionPlanRequest, CreateSubscriptionRequest, type CustomStorageAdapter, DevTools, DeviceBoundSessionKey, type DeviceBoundSessionKeyOptions, DeviceFingerprintGenerator, DisputeEscrowRequest, ERROR_CODES, type EmbeddedCheckoutConfig, EnableAutonomyRequest, EnableAutonomyResponse, type EncryptedSessionKey, type ErrorInterceptor, ErrorRecovery, Escrow, GeminiAdapter, InstallmentPlan, InterceptorManager, type Interceptors, Invoice, type LifecycleConfig, ListPaymentsRequest, LitCryptoSigner, type LitCryptoSignerConfig, type LitNetwork, type MockWallet, NetworkError, OpenAIAdapter, PINRateLimiter, type PINValidationResult, PINValidator, PPPFactor, PaginatedResponse, type ParsedIntent, Payment, PaymentError, PaymentIntent, PaymentIntentEvent, PaymentIntentParser, PaymentIntentsAPI, PaymentLink, type PaymentResult, type PaymentSuccessData, PerformanceMonitor, type PollingOptions, PricingAPI, PricingSuggestion, PricingSuggestionRequest, QuickCaches, RateLimitError, RateLimiter, type RecoveryQR, RecoveryQRGenerator, RefundEscrowRequest, type RequestConfig, type RequestInterceptor, type ResponseData, type ResponseInterceptor, type RetryOptions, RetryStrategy, SPENDING_LIMIT_ACTION_CID, SecureStorage, SessionKeyCache, type SessionKeyCacheConfig, SessionKeyCrypto, SessionKeyLifecycle, SessionKeysAPI, type SignPaymentParams, type SignPaymentResult, SmartPaymentRequest, SmartPaymentResponse, SmartPaymentsAPI, Subscription, SubscriptionPlan, type TestSessionKey, TransactionMonitor, TransactionPoller, type TransactionStatus, ValidationError, VerifyWebhookRequest, WalletConnector, WebhookError, WebhookPayload, ZendFiClient, ZendFiConfig, ZendFiEmbeddedCheckout, ZendFiError, type ZendFiErrorData, type ZendFiErrorType, createWalletHook, createZendFiError, decodeSignatureFromLit, encodeTransactionForLit, generateIdempotencyKey, isZendFiError, requiresLitSigning, setupQuickSessionKey, sleep, verifyExpressWebhook, verifyNextWebhook, verifyWebhookSignature, zendfi };
+export { ApiError, ApiKeyMode, AuthenticationError, type CheckoutError, type CheckoutTheme, ConfigLoader, CreateInstallmentPlanRequest, CreateInvoiceRequest, CreatePaymentLinkRequest, CreatePaymentRequest, CreateSubscriptionPlanRequest, CreateSubscriptionRequest, ERROR_CODES, type EmbeddedCheckoutConfig, type ErrorInterceptor, InstallmentPlan, InterceptorManager, type Interceptors, Invoice, NetworkError, Payment, PaymentError, PaymentLink, type PaymentSuccessData, RateLimitError, RateLimiter, type RequestConfig, type RequestInterceptor, type ResponseData, type ResponseInterceptor, Subscription, SubscriptionPlan, ValidationError, VerifyWebhookRequest, WebhookError, WebhookPayload, ZendFiClient, ZendFiConfig, ZendFiEmbeddedCheckout, ZendFiError, type ZendFiErrorData, type ZendFiErrorType, createZendFiError, generateIdempotencyKey, isZendFiError, sleep, verifyExpressWebhook, verifyNextWebhook, verifyWebhookSignature, zendfi };