@zendfi/sdk 0.4.0 → 0.5.0

package/dist/index.d.mts

@@ -1,5 +1,6 @@
-import { Z as ZendFiConfig, C as CreatePaymentRequest, P as Payment, L as ListPaymentsRequest, b as PaginatedResponse, c as CreateSubscriptionPlanRequest, S as SubscriptionPlan, d as CreateSubscriptionRequest, e as Subscription, f as CreatePaymentLinkRequest, g as PaymentLink, h as CreateInstallmentPlanRequest, I as InstallmentPlan, i as CreateEscrowRequest, E as Escrow, A as ApproveEscrowRequest, R as RefundEscrowRequest, D as DisputeEscrowRequest, j as CreateInvoiceRequest, k as Invoice, V as VerifyWebhookRequest, l as WebhookPayload } from './webhook-handler-B9ZczHQn.mjs';
-export { q as ApiKeyMode, G as CreateInstallmentPlanResponse, r as Currency, o as Environment, w as EscrowStatus, v as InstallmentPlanStatus, F as InstallmentScheduleItem, J as InvoiceLineItem, x as InvoiceStatus, t as PaymentStatus, s as PaymentToken, H as ReleaseCondition, B as SplitRecipient, y as SplitStatus, u as SubscriptionStatus, z as WebhookEvent, n as WebhookEventHandler, W as WebhookHandlerConfig, a as WebhookHandlers, m as WebhookResult, p as processWebhook } from './webhook-handler-B9ZczHQn.mjs';
+import { C as CreateAgentApiKeyRequest, A as AgentApiKey, b as CreateAgentSessionRequest, c as AgentSession, d as AgentAnalytics, e as CreatePaymentIntentRequest, P as PaymentIntent, f as ConfirmPaymentIntentRequest, g as PaymentIntentEvent, h as PPPFactor, i as PricingSuggestionRequest, j as PricingSuggestion, E as EnableAutonomyRequest, k as EnableAutonomyResponse, l as AutonomyStatus, S as SmartPaymentRequest, m as SmartPaymentResponse, Z as ZendFiConfig, n as CreatePaymentRequest, o as Payment, L as ListPaymentsRequest, p as PaginatedResponse, q as CreateSubscriptionPlanRequest, r as SubscriptionPlan, s as CreateSubscriptionRequest, t as Subscription, u as CreatePaymentLinkRequest, v as PaymentLink, w as CreateInstallmentPlanRequest, I as InstallmentPlan, x as CreateEscrowRequest, y as Escrow, z as ApproveEscrowRequest, R as RefundEscrowRequest, D as DisputeEscrowRequest, B as CreateInvoiceRequest, F as Invoice, V as VerifyWebhookRequest, G as WebhookPayload } from './webhook-handler-D8wEoYd7.mjs';
+export { Q as AgentKeyId, ac as ApiKeyMode, ar as ApiKeyScope, ax as AutonomousDelegate, M as Brand, au as CaptureMethod, ao as CreateInstallmentPlanResponse, ad as Currency, ab as Environment, Y as EscrowId, ai as EscrowStatus, _ as InstallmentPlanId, ah as InstallmentPlanStatus, an as InstallmentScheduleItem, a0 as IntentId, U as InvoiceId, aq as InvoiceLineItem, aj as InvoiceStatus, T as MerchantId, aw as PPPConfig, N as PaymentId, at as PaymentIntentStatus, $ as PaymentLinkCode, af as PaymentStatus, ae as PaymentToken, ap as ReleaseCondition, ay as RevokeAutonomyRequest, O as SessionId, as as SessionLimits, az as SmartPaymentStatus, am as SplitRecipient, ak as SplitStatus, X as SubscriptionId, ag as SubscriptionStatus, av as UserProfile, al as WebhookEvent, K as WebhookEventHandler, W as WebhookHandlerConfig, a as WebhookHandlers, J as WebhookResult, a3 as asAgentKeyId, a7 as asEscrowId, a8 as asInstallmentPlanId, aa as asIntentId, a5 as asInvoiceId, a4 as asMerchantId, a1 as asPaymentId, a9 as asPaymentLinkCode, a2 as asSessionId, a6 as asSubscriptionId, H as processWebhook } from './webhook-handler-D8wEoYd7.mjs';
+import { Transaction, Keypair } from '@solana/web3.js';
 
 /**
  * Request/Response Interceptor System
@@ -57,6 +58,724 @@ interface Interceptors {
     error: InterceptorManager<ErrorInterceptor>;
 }
 
+/**
+ * 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,
+ * });
+ * ```
+ */
+
+type RequestFn$4 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
+declare class AgentAPI {
+    private request;
+    constructor(request: RequestFn$4);
+    /**
+     * 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..."
+     * ```
+     */
+    createKey(request: CreateAgentApiKeyRequest): Promise<AgentApiKey>;
+    /**
+     * 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(', ')})`);
+     * });
+     * ```
+     */
+    listKeys(): Promise<AgentApiKey[]>;
+    /**
+     * 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');
+     * ```
+     */
+    revokeKey(keyId: string): Promise<void>;
+    /**
+     * 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_..."
+     * ```
+     */
+    createSession(request: CreateAgentSessionRequest): Promise<AgentSession>;
+    /**
+     * 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`);
+     * ```
+     */
+    listSessions(): Promise<AgentSession[]>;
+    /**
+     * 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}`);
+     * ```
+     */
+    getSession(sessionId: string): Promise<AgentSession>;
+    /**
+     * 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');
+     * ```
+     */
+    revokeSession(sessionId: string): Promise<void>;
+    /**
+     * 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}`);
+     * ```
+     */
+    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$3 = <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$3);
+    /**
+     * 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"
+     * ```
+     */
+    create(request: CreatePaymentIntentRequest): Promise<PaymentIntent>;
+    /**
+     * 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}`);
+     * }
+     * ```
+     */
+    get(intentId: string): Promise<PaymentIntent>;
+    /**
+     * 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,
+     * });
+     * ```
+     */
+    list(options?: ListIntentsOptions): Promise<PaymentIntent[]>;
+    /**
+     * 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}`);
+     * }
+     * ```
+     */
+    confirm(intentId: string, request: ConfirmPaymentIntentRequest): Promise<PaymentIntent>;
+    /**
+     * 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"
+     * ```
+     */
+    cancel(intentId: string): Promise<PaymentIntent>;
+    /**
+     * 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}`);
+     * });
+     * ```
+     */
+    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$2 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
+declare class PricingAPI {
+    private request;
+    constructor(request: RequestFn$2);
+    /**
+     * 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`);
+     * ```
+     */
+    getPPPFactor(countryCode: string): Promise<PPPFactor>;
+    /**
+     * 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);
+     * ```
+     */
+    listFactors(): Promise<PPPFactor[]>;
+    /**
+     * 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"
+     * ```
+     */
+    getSuggestion(request: PricingSuggestionRequest): Promise<PricingSuggestion>;
+    /**
+     * 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}%)`);
+     * ```
+     */
+    calculateLocalPrice(basePrice: number, countryCode: string): Promise<{
+        original: number;
+        adjusted: number;
+        savings: number;
+        discount_percentage: number;
+        country: string;
+        ppp_factor: number;
+    }>;
+}
+
+/**
+ * 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$1 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
+declare class AutonomyAPI {
+    private request;
+    constructor(request: RequestFn$1);
+    /**
+     * 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
+     *
+     * @param sessionKeyId - UUID of the session key
+     * @param request - Autonomy configuration including delegation signature
+     * @returns The created autonomous delegate
+     *
+     * @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,
+     * });
+     *
+     * console.log(`Delegate ID: ${delegate.delegate_id}`);
+     * console.log(`Expires: ${delegate.expires_at}`);
+     * ```
+     */
+    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;
+}
+
+/**
+ * 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 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
+declare class SmartPaymentsAPI {
+    private request;
+    constructor(request: RequestFn);
+    /**
+     * 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>;
+}
+
 /**
  * ZendFi SDK Client.
  * AZero-config TypeScript SDK for crypto payments
@@ -64,6 +783,103 @@ interface Interceptors {
 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;
     constructor(options?: Partial<ZendFiConfig>);
     /**
      * Create a new payment
@@ -201,6 +1017,47 @@ declare class ZendFiClient {
         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
      *
@@ -280,6 +1137,72 @@ declare class ConfigLoader {
      */
     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
@@ -457,4 +1380,568 @@ declare const ERROR_CODES: {
  */
 declare function isZendFiError(error: unknown): error is ZendFiError;
 
-export { ApiError, ApproveEscrowRequest, AuthenticationError, ConfigLoader, CreateEscrowRequest, CreateInstallmentPlanRequest, CreateInvoiceRequest, CreatePaymentLinkRequest, CreatePaymentRequest, CreateSubscriptionPlanRequest, CreateSubscriptionRequest, DisputeEscrowRequest, ERROR_CODES, type ErrorInterceptor, Escrow, InstallmentPlan, InterceptorManager, type Interceptors, Invoice, ListPaymentsRequest, NetworkError, PaginatedResponse, Payment, PaymentError, PaymentLink, RateLimitError, RefundEscrowRequest, type RequestConfig, type RequestInterceptor, type ResponseData, type ResponseInterceptor, Subscription, SubscriptionPlan, ValidationError, VerifyWebhookRequest, WebhookError, WebhookPayload, ZendFiClient, ZendFiConfig, ZendFiError, type ZendFiErrorData, type ZendFiErrorType, createZendFiError, isZendFiError, verifyExpressWebhook, verifyNextWebhook, verifyWebhookSignature, zendfi };
+/**
+ * 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 cachedKeypair;
+    private cacheExpiry;
+    private readonly DEFAULT_CACHE_TTL_MS;
+    /**
+     * Create a new device-bound session key
+     */
+    static create(options: DeviceBoundSessionKeyOptions): Promise<DeviceBoundSessionKey>;
+    /**
+     * 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;
+}
+
+/**
+ * Device-Bound Session Keys - SDK Integration
+ *
+ * High-level API for managing non-custodial session keys
+ * Integrates with ZendFi backend API
+ *
+ * @module device-bound-session-keys
+ */
+
+interface CreateDeviceBoundSessionKeyRequest {
+    userWallet: string;
+    limitUsdc: number;
+    durationDays: number;
+    encryptedSessionKey: string;
+    nonce: string;
+    sessionPublicKey: string;
+    deviceFingerprint: string;
+    recoveryQrData?: string;
+}
+interface CreateDeviceBoundSessionKeyResponse {
+    sessionKeyId: string;
+    mode: 'device_bound';
+    isCustodial: false;
+    userWallet: string;
+    sessionWallet: string;
+    limitUsdc: number;
+    expiresAt: string;
+    requiresClientSigning: true;
+    securityInfo: {
+        encryptionType: string;
+        deviceBound: boolean;
+        backendCanDecrypt: boolean;
+        recoveryQrSaved: boolean;
+    };
+}
+interface SessionKeyPaymentRequest {
+    amount: number;
+    recipient: string;
+    token?: string;
+    description?: string;
+    pin?: string;
+    enableAutoSign?: boolean;
+}
+declare class ZendFiSessionKeyManager {
+    private baseURL;
+    private apiKey;
+    private sessionKey;
+    private sessionKeyId;
+    constructor(apiKey: string, baseURL?: string);
+    /**
+     * Create a new device-bound session key
+     *
+     * @example
+     * ```typescript
+     * const manager = new ZendFiSessionKeyManager('your-api-key');
+     *
+     * const sessionKey = await manager.createSessionKey({
+     *   userWallet: '7xKNH....',
+     *   limitUSDC: 100,
+     *   durationDays: 7,
+     *   pin: '123456',
+     *   generateRecoveryQR: true,
+     * });
+     *
+     * console.log('Session key created:', sessionKey.sessionKeyId);
+     * console.log('Recovery QR:', sessionKey.recoveryQR);
+     * ```
+     */
+    createSessionKey(options: {
+        userWallet: string;
+        limitUSDC: number;
+        durationDays: number;
+        pin: string;
+        generateRecoveryQR?: boolean;
+    }): Promise<{
+        sessionKeyId: string;
+        sessionWallet: string;
+        expiresAt: string;
+        recoveryQR?: string;
+        limitUsdc: number;
+    }>;
+    /**
+     * Load an existing session key from backend
+     * Requires PIN to decrypt
+     */
+    loadSessionKey(sessionKeyId: string, pin: string): Promise<void>;
+    /**
+     * Make a payment using the session key
+     *
+     * First payment: Requires PIN to decrypt session key
+     * Subsequent payments: Uses cached keypair (no PIN needed!) ✨
+     *
+     * @example
+     * ```typescript
+     * // First payment: requires PIN
+     * const result1 = await manager.makePayment({
+     *   amount: 5.0,
+     *   recipient: '7xKNH....',
+     *   pin: '123456',
+     *   description: 'Coffee purchase',
+     * });
+     *
+     * // Second payment: NO PIN NEEDED! Instant signing!
+     * const result2 = await manager.makePayment({
+     *   amount: 3.0,
+     *   recipient: '7xKNH....',
+     *   description: 'Donut purchase',
+     * }); // <- No PIN! Uses cached keypair
+     *
+     * console.log('Payment signature:', result2.signature);
+     *
+     * // Disable auto-signing for single payment
+     * const result3 = await manager.makePayment({
+     *   amount: 100.0,
+     *   recipient: '7xKNH....',
+     *   pin: '123456',
+     *   enableAutoSign: false, // Will require PIN every time
+     * });
+     * ```
+     */
+    makePayment(options: SessionKeyPaymentRequest): Promise<{
+        paymentId: string;
+        signature: string;
+        status: string;
+    }>;
+    /**
+     * Recover session key on new device
+     * Requires recovery QR and PIN from original device
+     *
+     * @example
+     * ```typescript
+     * const recovered = await manager.recoverSessionKey({
+     *   sessionKeyId: 'uuid...',
+     *   recoveryQR: '{"encryptedSessionKey":"..."}',
+     *   oldPin: '123456',
+     *   newPin: '654321',
+     * });
+     * ```
+     */
+    recoverSessionKey(options: {
+        sessionKeyId: string;
+        recoveryQR: string;
+        oldPin: string;
+        newPin: string;
+    }): Promise<void>;
+    /**
+     * Revoke session key
+     */
+    revokeSessionKey(sessionKeyId?: string): Promise<void>;
+    /**
+     * Unlock session key with PIN and cache for auto-signing
+     * Call this after creating/loading session key to enable instant payments
+     *
+     * @example
+     * ```typescript
+     * // Create session key
+     * await manager.createSessionKey({...});
+     *
+     * // Unlock with PIN (one-time)
+     * await manager.unlockSessionKey('123456');
+     *
+     * // Now all payments are instant (no PIN!)
+     * await manager.makePayment({amount: 5, ...}); // Instant!
+     * await manager.makePayment({amount: 3, ...}); // Instant!
+     * ```
+     */
+    unlockSessionKey(pin: string, cacheTTL?: number): Promise<void>;
+    /**
+     * Clear cached keypair
+     * Should be called on logout or when session ends
+     *
+     * @example
+     * ```typescript
+     * // Clear on logout
+     * manager.clearCache();
+     *
+     * // Or auto-clear on tab close
+     * window.addEventListener('beforeunload', () => {
+     *   manager.clearCache();
+     * });
+     * ```
+     */
+    clearCache(): void;
+    /**
+     * Check if keypair is cached (auto-signing enabled)
+     */
+    isCached(): boolean;
+    /**
+     * Get time remaining until cache expires (in milliseconds)
+     */
+    getCacheTimeRemaining(): number;
+    /**
+     * Extend cache expiry time
+     * Useful to keep session active during user activity
+     */
+    extendCache(additionalTTL: number): void;
+    /**
+     * Get session key status
+     */
+    getStatus(sessionKeyId?: string): Promise<{
+        isActive: boolean;
+        isApproved: boolean;
+        limitUsdc: number;
+        usedAmountUsdc: number;
+        remainingUsdc: number;
+        expiresAt: string;
+        daysUntilExpiry: number;
+    }>;
+    private request;
+}
+
+/**
+ * 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;
+
+export { AgentAPI, AgentAnalytics, AgentApiKey, AgentSession, ApiError, ApproveEscrowRequest, AuthenticationError, AutonomyAPI, AutonomyStatus, ConfigLoader, ConfirmPaymentIntentRequest, CreateAgentApiKeyRequest, CreateAgentSessionRequest, type CreateDeviceBoundSessionKeyRequest, type CreateDeviceBoundSessionKeyResponse, CreateEscrowRequest, CreateInstallmentPlanRequest, CreateInvoiceRequest, CreatePaymentIntentRequest, CreatePaymentLinkRequest, CreatePaymentRequest, CreateSubscriptionPlanRequest, CreateSubscriptionRequest, DeviceBoundSessionKey, type DeviceBoundSessionKeyOptions, DeviceFingerprintGenerator, DisputeEscrowRequest, ERROR_CODES, EnableAutonomyRequest, EnableAutonomyResponse, type EncryptedSessionKey, type ErrorInterceptor, Escrow, InstallmentPlan, InterceptorManager, type Interceptors, Invoice, ListPaymentsRequest, LitCryptoSigner, type LitCryptoSignerConfig, type LitNetwork, NetworkError, PPPFactor, PaginatedResponse, Payment, PaymentError, PaymentIntent, PaymentIntentEvent, PaymentIntentsAPI, PaymentLink, PricingAPI, PricingSuggestion, PricingSuggestionRequest, RateLimitError, RateLimiter, type RecoveryQR, RecoveryQRGenerator, RefundEscrowRequest, type RequestConfig, type RequestInterceptor, type ResponseData, type ResponseInterceptor, SPENDING_LIMIT_ACTION_CID, SessionKeyCrypto, type SessionKeyPaymentRequest, type SignPaymentParams, type SignPaymentResult, SmartPaymentRequest, SmartPaymentResponse, SmartPaymentsAPI, Subscription, SubscriptionPlan, ValidationError, VerifyWebhookRequest, WebhookError, WebhookPayload, ZendFiClient, ZendFiConfig, ZendFiError, type ZendFiErrorData, type ZendFiErrorType, ZendFiSessionKeyManager, createZendFiError, decodeSignatureFromLit, encodeTransactionForLit, generateIdempotencyKey, isZendFiError, requiresLitSigning, sleep, verifyExpressWebhook, verifyNextWebhook, verifyWebhookSignature, zendfi };