@zendfi/sdk 0.5.2 → 0.5.4

package/README.md

@@ -20,6 +20,7 @@ Accept **SOL, USDC, and USDT** payments in your app with just a few lines of cod
 - **Test Mode** — Free devnet testing with no real money
 - **Multi-Network** — Automatic routing to devnet or mainnet
 - **Agentic Intent Protocol** — AI agent payment capabilities with scoped API keys
+- **Session Keys** — On-chain funded wallets for autonomous agent payments
 - **PPP Pricing** — Purchasing Power Parity for global reach (27+ countries)
 - **Payment Intents** — Two-phase commit pattern for reliable checkout
 
@@ -146,6 +147,7 @@ import { zendfi } from '@zendfi/sdk';
 // Agent API - Manage agent keys and sessions
 zendfi.agent.createKey(...)
 zendfi.agent.createSession(...)
+zendfi.agent.pay(...)         // Make payments via sessions
 
 // Payment Intents - Two-phase payment flow
 zendfi.intents.create(...)
@@ -162,6 +164,13 @@ zendfi.autonomy.getStatus(...)
 // Smart Payments - AI-powered routing
 zendfi.smart.execute(...)
 zendfi.smart.submitSigned(...)  // For device-bound flows
+
+// Session Keys - On-chain funded wallets with PKP identity
+zendfi.sessionKeys.create(...)
+zendfi.sessionKeys.submitApproval(...)
+zendfi.sessionKeys.getStatus(...)
+zendfi.sessionKeys.topUp(...)
+zendfi.sessionKeys.revoke(...)
 ```
 
 ### Agent API Keys
@@ -213,6 +222,23 @@ const session = await zendfi.agent.createSession({
   duration_hours: 24,
 });
 
+// Make payments within the session (spending limits enforced!)
+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 transaction:', payment.unsigned_transaction);
+  console.log('Submit to:', payment.submit_url);
+} else {
+  // Auto-signed: payment complete
+  console.log('Payment confirmed:', payment.transaction_signature);
+}
+
 // List active sessions
 const sessions = await zendfi.agent.listSessions();
 
@@ -313,6 +339,71 @@ const status = await zendfi.autonomy.getStatus(walletAddress);
 await zendfi.autonomy.revoke(delegateId);
 ```
 
+### Session Keys (On-Chain Funded Wallets)
+
+Session keys are pre-funded wallets with spending limits that enable AI agents to make autonomous payments. They use Lit Protocol's PKP (Programmable Key Pairs) for secure on-chain identity.
+
+**The Flow:**
+1. **Create** - Agent requests a session key with spending limit
+2. **Approve** - User signs a one-time approval transaction
+3. **Spend** - Agent makes payments autonomously up to the limit
+4. **Top-up** - Optionally add more funds when needed
+
+```typescript
+// Step 1: Create a session key
+const key = await zendfi.sessionKeys.create({
+  agent_id: 'shopping-assistant',
+  user_wallet: 'Hx7B...abc',
+  max_amount: 100,       // $100 spending limit
+  expiry_hours: 24,      // Valid for 24 hours
+  token: 'USDC',
+});
+
+// key.session_key_id - Unique identifier
+// key.approval_transaction - Transaction for user to sign
+// key.session_key_address - The funded wallet address
+// key.pkp_public_key - Lit Protocol PKP public key
+
+// Step 2: User signs the approval transaction (one-time)
+const signedTx = await wallet.signTransaction(key.approval_transaction);
+await zendfi.sessionKeys.submitApproval(key.session_key_id, {
+  signed_transaction: signedTx,
+});
+
+// Step 3: Check status and make payments
+const status = await zendfi.sessionKeys.getStatus(key.session_key_id);
+console.log(`Status: ${status.status}`);           // "active"
+console.log(`Remaining: $${status.remaining_amount}`);
+console.log(`Spent: $${status.spent_amount}`);
+console.log(`Transactions: ${status.transaction_count}`);
+
+// Step 4: Top-up if needed
+const topUp = await zendfi.sessionKeys.topUp(key.session_key_id, {
+  amount: 50,  // Add $50 more
+});
+// User signs the top-up transaction
+const signedTopUp = await wallet.signTransaction(topUp.approval_transaction);
+await zendfi.sessionKeys.submitTopUp(key.session_key_id, {
+  signed_transaction: signedTopUp,
+});
+
+// Revoke when done
+await zendfi.sessionKeys.revoke(key.session_key_id);
+
+// List all session keys
+const keys = await zendfi.sessionKeys.list();
+keys.session_keys.forEach(k => {
+  console.log(`${k.session_key_id}: $${k.remaining_amount} remaining`);
+});
+```
+
+**Session Key Statuses:**
+- `pending_approval` - Waiting for user to sign approval
+- `active` - Ready for payments
+- `exhausted` - Spending limit reached
+- `expired` - Past expiry time
+- `revoked` - Manually revoked
+
 ### Smart Payments
 
 AI-powered payments that automatically apply optimizations:

package/dist/express.d.mts

@@ -1,4 +1,4 @@
-import { W as WebhookHandlerConfig, a as WebhookHandlers } from './webhook-handler-D8wEoYd7.mjs';
+import { W as WebhookHandlerConfig, a as WebhookHandlers } from './webhook-handler-B-RdABQr.mjs';
 
 /**
  * Express Webhook Handler

package/dist/express.d.ts

@@ -1,4 +1,4 @@
-import { W as WebhookHandlerConfig, a as WebhookHandlers } from './webhook-handler-D8wEoYd7.js';
+import { W as WebhookHandlerConfig, a as WebhookHandlers } from './webhook-handler-B-RdABQr.js';
 
 /**
  * Express Webhook Handler

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-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 { 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, p as CreateSessionKeyRequest, q as CreateSessionKeyResponse, r as CreateDeviceBoundSessionKeyRequest$1, s as CreateDeviceBoundSessionKeyResponse$1, t as SubmitSignedTransactionRequest, u as SubmitTransactionResponse, v as SessionKeyStatus, w as SessionKeyListResponse, T as TopUpSessionKeyRequest, x as TopUpSessionKeyResponse, Z as ZendFiConfig, y as CreatePaymentRequest, z as Payment, L as ListPaymentsRequest, B as PaginatedResponse, D as CreateSubscriptionPlanRequest, F as SubscriptionPlan, G as CreateSubscriptionRequest, H as Subscription, I as CreatePaymentLinkRequest, J as PaymentLink, K as CreateInstallmentPlanRequest, M as InstallmentPlan, N as CreateEscrowRequest, O as Escrow, Q as ApproveEscrowRequest, R as RefundEscrowRequest, U as DisputeEscrowRequest, V as CreateInvoiceRequest, X as Invoice, Y as VerifyWebhookRequest, _ as WebhookPayload } from './webhook-handler-B-RdABQr.mjs';
+export { a5 as AgentKeyId, ao as ApiKeyMode, aD as ApiKeyScope, aJ as AutonomousDelegate, a2 as Brand, aG as CaptureMethod, aA as CreateInstallmentPlanResponse, ap as Currency, an as Environment, a9 as EscrowId, au as EscrowStatus, aa as InstallmentPlanId, at as InstallmentPlanStatus, az as InstallmentScheduleItem, ac as IntentId, a7 as InvoiceId, aC as InvoiceLineItem, av as InvoiceStatus, a6 as MerchantId, aI as PPPConfig, a3 as PaymentId, aF as PaymentIntentStatus, ab as PaymentLinkCode, ar as PaymentStatus, aq as PaymentToken, aB as ReleaseCondition, aK as RevokeAutonomyRequest, aO as SecurityStatus, a4 as SessionId, aM as SessionKeyInstructions, aN as SessionKeySecurityInfo, aP as SessionKeyStats, aE as SessionLimits, aL as SmartPaymentStatus, ay as SplitRecipient, aw as SplitStatus, a8 as SubscriptionId, as as SubscriptionStatus, aH as UserProfile, ax as WebhookEvent, a1 as WebhookEventHandler, W as WebhookHandlerConfig, a as WebhookHandlers, a0 as WebhookResult, af as asAgentKeyId, aj as asEscrowId, ak as asInstallmentPlanId, am as asIntentId, ah as asInvoiceId, ag as asMerchantId, ad as asPaymentId, al as asPaymentLinkCode, ae as asSessionId, ai as asSubscriptionId, $ as processWebhook } from './webhook-handler-B-RdABQr.mjs';
 import { Transaction, Keypair } from '@solana/web3.js';
 
 /**
@@ -84,10 +84,10 @@ interface Interceptors {
  * ```
  */
 
-type RequestFn$4 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
+type RequestFn$5 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
 declare class AgentAPI {
     private request;
-    constructor(request: RequestFn$4);
+    constructor(request: RequestFn$5);
     /**
      * Create a new agent API key with scoped permissions
      *
@@ -210,6 +210,53 @@ declare class AgentAPI {
      * ```
      */
     revokeSession(sessionId: string): Promise<void>;
+    /**
+     * 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);
+     * }
+     * ```
+     */
+    pay(request: AgentPaymentRequest): Promise<AgentPaymentResponse>;
     /**
      * Get analytics for all agent activity
      *
@@ -253,7 +300,7 @@ declare class AgentAPI {
  * ```
  */
 
-type RequestFn$3 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
+type RequestFn$4 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
 interface ListIntentsOptions {
     /** Filter by status */
     status?: string;
@@ -264,7 +311,7 @@ interface ListIntentsOptions {
 }
 declare class PaymentIntentsAPI {
     private request;
-    constructor(request: RequestFn$3);
+    constructor(request: RequestFn$4);
     /**
      * Create a payment intent
      *
@@ -400,10 +447,10 @@ declare class PaymentIntentsAPI {
  * ```
  */
 
-type RequestFn$2 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
+type RequestFn$3 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
 declare class PricingAPI {
     private request;
-    constructor(request: RequestFn$2);
+    constructor(request: RequestFn$3);
     /**
      * Get PPP factor for a specific country
      *
@@ -538,10 +585,10 @@ declare class PricingAPI {
  * ```
  */
 
-type RequestFn$1 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
+type RequestFn$2 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
 declare class AutonomyAPI {
     private request;
-    constructor(request: RequestFn$1);
+    constructor(request: RequestFn$2);
     /**
      * Enable autonomous signing for a session key
      *
@@ -695,10 +742,10 @@ declare class AutonomyAPI {
  * ```
  */
 
-type RequestFn = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
+type RequestFn$1 = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
 declare class SmartPaymentsAPI {
     private request;
-    constructor(request: RequestFn);
+    constructor(request: RequestFn$1);
     /**
      * Execute an AI-powered smart payment
      *
@@ -776,6 +823,241 @@ declare class SmartPaymentsAPI {
     submitSigned(paymentId: string, signedTransaction: string): Promise<SmartPaymentResponse>;
 }
 
+/**
+ * Session Keys API - On-chain funded session wallets
+ *
+ * Session keys are dedicated wallets funded by users for AI agents to use.
+ * Two modes are supported:
+ *
+ * 1. **Custodial Mode**: Backend generates and stores the keypair (simpler)
+ * 2. **Device-Bound Mode**: Client generates keypair and encrypts with PIN (more secure)
+ *
+ * @example
+ * ```typescript
+ * // Create a custodial session key
+ * const result = await zendfi.sessionKeys.create({
+ *   user_wallet: 'Hx7B...abc',
+ *   limit_usdc: 100,
+ *   duration_days: 7,
+ *   device_fingerprint: await getDeviceFingerprint(),
+ * });
+ *
+ * // User signs the approval transaction in their wallet
+ * const signedTx = await wallet.signTransaction(result.approval_transaction);
+ *
+ * // Submit the signed transaction
+ * await zendfi.sessionKeys.submitApproval({
+ *   session_key_id: result.session_key_id,
+ *   signed_transaction: signedTx,
+ * });
+ *
+ * // Check status
+ * const status = await zendfi.sessionKeys.getStatus(result.session_key_id);
+ * console.log(`Remaining: $${status.remaining_usdc}`);
+ * ```
+ */
+
+type RequestFn = <T>(method: string, endpoint: string, data?: any) => Promise<T>;
+declare class SessionKeysAPI {
+    private request;
+    constructor(request: RequestFn);
+    /**
+     * Create a custodial session key
+     *
+     * The backend generates and securely stores the keypair.
+     * Returns an approval transaction that the user must sign to fund the session wallet.
+     *
+     * @param request - Session key configuration
+     * @returns Creation response with approval transaction
+     *
+     * @example
+     * ```typescript
+     * const result = await zendfi.sessionKeys.create({
+     *   user_wallet: 'Hx7B...abc',
+     *   limit_usdc: 100,
+     *   duration_days: 7,
+     *   device_fingerprint: deviceFingerprint,
+     * });
+     *
+     * console.log(`Session key: ${result.session_key_id}`);
+     * console.log('Please sign the approval transaction');
+     * ```
+     */
+    create(request: CreateSessionKeyRequest): Promise<CreateSessionKeyResponse>;
+    /**
+     * Create a device-bound session key (non-custodial)
+     *
+     * The client generates the keypair and encrypts it with a PIN before sending.
+     * The backend cannot decrypt the keypair - only the user's device can.
+     *
+     * @param request - Device-bound session key configuration
+     * @returns Creation response with session wallet address
+     *
+     * @example
+     * ```typescript
+     * // Generate keypair client-side
+     * const keypair = Keypair.generate();
+     *
+     * // Encrypt with PIN
+     * const encrypted = await encryptWithPin(keypair.secretKey, pin);
+     *
+     * const result = await zendfi.sessionKeys.createDeviceBound({
+     *   user_wallet: 'Hx7B...abc',
+     *   limit_usdc: 100,
+     *   duration_days: 7,
+     *   encrypted_session_key: encrypted.ciphertext,
+     *   nonce: encrypted.nonce,
+     *   session_public_key: keypair.publicKey.toBase58(),
+     *   device_fingerprint: deviceFingerprint,
+     * });
+     *
+     * console.log(`Session wallet: ${result.session_wallet}`);
+     * ```
+     */
+    createDeviceBound(request: CreateDeviceBoundSessionKeyRequest$1): Promise<CreateDeviceBoundSessionKeyResponse$1>;
+    /**
+     * Get encrypted session key for device-bound mode
+     *
+     * Retrieves the encrypted keypair so the client can decrypt it with their PIN.
+     * The device fingerprint must match the one used during creation.
+     *
+     * @param sessionKeyId - UUID of the session key
+     * @param deviceFingerprint - Current device fingerprint
+     * @returns Encrypted key data
+     */
+    getEncrypted(sessionKeyId: string, deviceFingerprint: string): Promise<{
+        encrypted_session_key: string;
+        nonce: string;
+        device_fingerprint_valid: boolean;
+    }>;
+    /**
+     * Submit a signed approval transaction
+     *
+     * After the user signs the approval transaction from `create()`,
+     * submit it here to activate the session key.
+     *
+     * @param request - Signed transaction data
+     * @returns Submission result with signature
+     *
+     * @example
+     * ```typescript
+     * const result = await zendfi.sessionKeys.submitApproval({
+     *   session_key_id: sessionKeyId,
+     *   signed_transaction: signedTxBase64,
+     * });
+     *
+     * console.log(`Approved! Signature: ${result.signature}`);
+     * ```
+     */
+    submitApproval(request: SubmitSignedTransactionRequest & {
+        session_key_id: string;
+    }): Promise<SubmitTransactionResponse>;
+    /**
+     * Submit a signed top-up transaction
+     *
+     * After the user signs the top-up transaction from `topUp()`,
+     * submit it here to add funds.
+     *
+     * @param sessionKeyId - UUID of the session key
+     * @param signedTransaction - Base64 encoded signed transaction
+     * @returns Submission result with new limit
+     */
+    submitTopUp(sessionKeyId: string, signedTransaction: string): Promise<SubmitTransactionResponse>;
+    /**
+     * Get session key status
+     *
+     * @param sessionKeyId - UUID of the session key
+     * @returns Current status with remaining balance
+     *
+     * @example
+     * ```typescript
+     * const status = await zendfi.sessionKeys.getStatus(sessionKeyId);
+     *
+     * console.log(`Active: ${status.is_active}`);
+     * console.log(`Limit: $${status.limit_usdc}`);
+     * console.log(`Used: $${status.used_amount_usdc}`);
+     * console.log(`Remaining: $${status.remaining_usdc}`);
+     * console.log(`Expires in ${status.days_until_expiry} days`);
+     * ```
+     */
+    getStatus(sessionKeyId: string): Promise<SessionKeyStatus>;
+    /**
+     * List all session keys for the merchant
+     *
+     * @returns List of session keys with stats
+     *
+     * @example
+     * ```typescript
+     * const { session_keys, stats } = await zendfi.sessionKeys.list();
+     *
+     * console.log(`Total keys: ${stats.total_keys}`);
+     * console.log(`Active: ${stats.active_keys}`);
+     *
+     * session_keys.forEach(key => {
+     *   console.log(`${key.session_key_id}: $${key.remaining_usdc} remaining`);
+     * });
+     * ```
+     */
+    list(): Promise<SessionKeyListResponse>;
+    /**
+     * Top up a session key with additional funds
+     *
+     * Returns a transaction that the user must sign to add funds.
+     *
+     * @param sessionKeyId - UUID of the session key
+     * @param request - Top-up configuration
+     * @returns Top-up transaction to sign
+     *
+     * @example
+     * ```typescript
+     * const topUp = await zendfi.sessionKeys.topUp(sessionKeyId, {
+     *   user_wallet: 'Hx7B...abc',
+     *   amount_usdc: 50,
+     *   device_fingerprint: deviceFingerprint,
+     * });
+     *
+     * console.log(`Adding $${topUp.added_amount}`);
+     * console.log(`New limit will be: $${topUp.new_limit}`);
+     *
+     * // User signs the transaction
+     * const signedTx = await wallet.signTransaction(topUp.top_up_transaction);
+     *
+     * // Submit it
+     * await zendfi.sessionKeys.submitTopUp(sessionKeyId, signedTx);
+     * ```
+     */
+    topUp(sessionKeyId: string, request: TopUpSessionKeyRequest): Promise<TopUpSessionKeyResponse>;
+    /**
+     * Revoke a session key
+     *
+     * Immediately deactivates the session key. Any remaining funds
+     * are refunded to the user's wallet.
+     *
+     * @param sessionKeyId - UUID of the session key
+     * @returns Revocation result with optional refund details
+     *
+     * @example
+     * ```typescript
+     * const result = await zendfi.sessionKeys.revoke(sessionKeyId);
+     *
+     * console.log('Session key revoked');
+     * if (result.refund?.refunded) {
+     *   console.log(`Refunded: ${result.refund.transaction_signature}`);
+     * }
+     * ```
+     */
+    revoke(sessionKeyId: string): Promise<{
+        message: string;
+        session_key_id: string;
+        note: string;
+        refund?: {
+            refunded: boolean;
+            transaction_signature: string;
+            message: string;
+        };
+    }>;
+}
+
 /**
  * ZendFi SDK Client.
  * AZero-config TypeScript SDK for crypto payments
@@ -880,6 +1162,38 @@ declare class ZendFiClient {
      * ```
      */
     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
@@ -1944,4 +2258,4 @@ declare function requiresLitSigning(session: {
 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 };
+export { AgentAPI, AgentAnalytics, AgentApiKey, AgentPaymentRequest, AgentPaymentResponse, AgentSession, ApiError, ApproveEscrowRequest, AuthenticationError, AutonomyAPI, AutonomyStatus, ConfigLoader, ConfirmPaymentIntentRequest, CreateAgentApiKeyRequest, CreateAgentSessionRequest, type CreateDeviceBoundSessionKeyRequest, type CreateDeviceBoundSessionKeyResponse, CreateEscrowRequest, CreateInstallmentPlanRequest, CreateInvoiceRequest, CreatePaymentIntentRequest, CreatePaymentLinkRequest, CreatePaymentRequest, CreateSessionKeyRequest, CreateSessionKeyResponse, 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, SessionKeyListResponse, type SessionKeyPaymentRequest, SessionKeyStatus, SessionKeysAPI, type SignPaymentParams, type SignPaymentResult, SmartPaymentRequest, SmartPaymentResponse, SmartPaymentsAPI, SubmitSignedTransactionRequest, SubmitTransactionResponse, Subscription, SubscriptionPlan, TopUpSessionKeyRequest, TopUpSessionKeyResponse, ValidationError, VerifyWebhookRequest, WebhookError, WebhookPayload, ZendFiClient, ZendFiConfig, ZendFiError, type ZendFiErrorData, type ZendFiErrorType, ZendFiSessionKeyManager, createZendFiError, decodeSignatureFromLit, encodeTransactionForLit, generateIdempotencyKey, isZendFiError, requiresLitSigning, sleep, verifyExpressWebhook, verifyNextWebhook, verifyWebhookSignature, zendfi };