@zendfi/sdk 0.5.2 → 0.5.4

package/dist/index.d.ts

@@ -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.js';
-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.js';
+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.js';
+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.js';
 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 };