@diviswap/sdk 1.7.6

package/dist/wallet-BEGvzNtB.d.mts

@@ -0,0 +1,1614 @@
+/**
+ * Core type definitions for Diviswap SDK
+ */
+type Environment = 'production' | 'sandbox' | 'development';
+type AuthMode = 'user' | 'partner';
+interface BaseDiviswapConfig {
+    /** Environment to use (defaults to 'production') */
+    environment?: Environment;
+    /** Custom API URL (optional) */
+    apiUrl?: string;
+    /** Enable debug logging (defaults to false) */
+    debug?: boolean;
+    /** Request timeout in milliseconds (defaults to 30000) */
+    timeout?: number;
+    /** Default integrator fee percentage (defaults to 0.5%) */
+    defaultFee?: number;
+    /** Token storage strategy: 'localStorage' (default), 'memory' (for iframes), or 'custom' */
+    tokenStorage?: 'localStorage' | 'memory' | 'custom';
+    /** Custom token storage implementation (required when tokenStorage is 'custom') */
+    customTokenStorage?: {
+        get: () => {
+            accessToken: string | null;
+            refreshToken: string | null;
+        };
+        set: (accessToken: string, refreshToken?: string) => void;
+        clear: () => void;
+    };
+}
+interface UserDiviswapConfig extends BaseDiviswapConfig {
+    /** Your Diviswap API Key */
+    apiKey: string;
+    /** Your Diviswap Client ID */
+    clientId: string;
+    /** Authentication mode (automatically set to 'user') */
+    mode?: 'user';
+}
+interface PartnerDiviswapConfig extends BaseDiviswapConfig {
+    /** Authentication mode (optional - auto-detected from keyId/secretKey) */
+    mode?: 'partner';
+    /** Partner key ID (pk_...) */
+    keyId: string;
+    /** Partner secret key (sk_...) */
+    secretKey: string;
+    /** Authentication method: 'hmac' (default) or 'jwt' */
+    authMethod?: 'hmac' | 'jwt';
+    /** Customer ID in your system (for shadow user linking) */
+    customerId?: string;
+    /** Customer email (for shadow user linking) */
+    customerEmail?: string;
+}
+type DiviswapConfig = UserDiviswapConfig | PartnerDiviswapConfig;
+/** @deprecated Use DiviswapConfig instead */
+type LiberExConfig = DiviswapConfig;
+/** @deprecated Use UserDiviswapConfig instead */
+type UserLiberExConfig = UserDiviswapConfig;
+/** @deprecated Use PartnerDiviswapConfig instead */
+type PartnerLiberExConfig = PartnerDiviswapConfig;
+interface LegacyDiviswapConfig {
+    apiKey: string;
+    clientId: string;
+    environment?: Environment;
+    apiUrl?: string;
+    debug?: boolean;
+    timeout?: number;
+    defaultFee?: number;
+    tokenStorage?: 'localStorage' | 'memory' | 'custom';
+    customTokenStorage?: {
+        get: () => {
+            accessToken: string | null;
+            refreshToken: string | null;
+        };
+        set: (accessToken: string, refreshToken?: string) => void;
+        clear: () => void;
+    };
+}
+interface AuthCredentials {
+    email: string;
+    password: string;
+}
+interface User {
+    id: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    phone?: string;
+    kycStatus?: KycStatus;
+    kybStatus?: KybStatus;
+    createdAt: string;
+    updatedAt: string;
+}
+interface IndividualData {
+    residential_country_code: string;
+    residential_address_line_one: string;
+    residential_address_line_two?: string;
+    residential_city: string;
+    residential_state: string;
+    residential_postal_code: string;
+    id_country_code: string;
+    dob: string;
+    id_number: string;
+}
+interface RegisterRequest extends AuthCredentials {
+    firstName?: string;
+    lastName?: string;
+    phone?: string;
+    referralCode?: string;
+    individual?: IndividualData;
+}
+interface AuthResponse {
+    accessToken: string;
+    refreshToken?: string;
+    user: User;
+}
+interface Payee {
+    id: string;
+    nickname: string;
+    accountNumber: string;
+    routingNumber: string;
+    accountType: 'checking' | 'savings';
+    isDefault: boolean;
+    verified: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreatePayeeRequest {
+    nickname: string;
+    accountNumber?: string;
+    routingNumber?: string;
+    accountType: 'checking' | 'savings' | 'debit_card';
+    setAsDefault?: boolean;
+    debitCard?: {
+        number: string;
+        expirationMonth: string;
+        expirationYear: string;
+        cvv: string;
+    };
+}
+interface Transaction {
+    id: string;
+    type?: 'onramp' | 'offramp';
+    status?: 'pending' | 'processing' | 'completed' | 'failed';
+    amount?: number;
+    currency?: string;
+    fromAddress?: string;
+    toAddress?: string;
+    payeeId?: string;
+    fee?: number;
+    createdAt?: string;
+    updatedAt?: string;
+    to_address?: string;
+    chain_id?: number;
+    message?: string;
+    test_mode?: boolean;
+    feature_flag_enabled?: boolean;
+}
+interface OnrampRequest {
+    amount: number;
+    currency: string;
+    payeeId: string;
+    toAddress: string;
+    chain?: string;
+}
+interface OfframpRequest {
+    amount: number;
+    currency: string;
+    fromAddress: string;
+    payeeId: string;
+    chain?: string;
+    memo?: string;
+    toAddress?: string;
+    txHash?: string;
+}
+interface ApiResponse<T = any> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    message?: string;
+}
+type KycStatus = 'NOT_STARTED' | 'PENDING' | 'PENDING_VERIFICATION' | 'APPROVED' | 'REJECTED';
+type KybStatus = 'NOT_STARTED' | 'PENDING' | 'PENDING_VERIFICATION' | 'APPROVED' | 'REJECTED';
+interface KycMetadata {
+    applicantId?: string;
+    levelName?: string;
+    rejectLabels?: string[];
+    createdAt?: string;
+    reviewResult?: {
+        reviewAnswer?: string;
+        rejectLabels?: string[];
+        moderationComment?: string;
+    };
+}
+interface KybMetadata {
+    applicantId?: string;
+    levelName?: string;
+    createdAt?: string;
+}
+interface OrganizationInfo {
+    id: string;
+    name: string;
+    businessName?: string;
+    businessType?: string;
+    ein?: string;
+    createdAt?: string;
+    needsVerification?: boolean;
+}
+interface ComplianceStatus {
+    kycStatus: KycStatus;
+    kycMetadata?: KycMetadata;
+    kybStatus: KybStatus;
+    kybMetadata?: KybMetadata;
+    organizationInfo?: OrganizationInfo;
+    canTransact: boolean;
+    requiresAction: boolean;
+    nextStep?: 'COMPLETE_KYC' | 'COMPLETE_KYB' | 'WAIT_FOR_APPROVAL' | null;
+    verificationLevel?: string;
+    kycUri?: string;
+}
+interface KycSessionResponse {
+    sessionUrl: string;
+    applicantId: string;
+    expiresAt: string;
+}
+interface KycDocumentRequest {
+    type: 'PASSPORT' | 'DRIVERS_LICENSE' | 'ID_CARD' | 'RESIDENCE_PERMIT';
+    frontImage: string;
+    backImage?: string;
+}
+interface KycPersonalInfo {
+    firstName: string;
+    lastName: string;
+    dateOfBirth: string;
+    ssn?: string;
+    phone?: string;
+    address: {
+        street: string;
+        city: string;
+        state: string;
+        postalCode: string;
+        country: string;
+    };
+}
+
+/**
+ * JWT Token management with auto-refresh
+ */
+interface TokenData {
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: number;
+}
+/**
+ * Token Manager handles JWT token lifecycle
+ */
+declare class TokenManager {
+    private storage;
+    private refreshPromise;
+    constructor(useLocalStorage?: boolean);
+    /**
+     * Parse JWT token to extract expiration
+     */
+    private parseToken;
+    /**
+     * Store tokens
+     */
+    setTokens(accessToken: string, refreshToken?: string): void;
+    /**
+     * Get current access token
+     */
+    getAccessToken(): string | null;
+    /**
+     * Get refresh token
+     */
+    getRefreshToken(): string | null;
+    /**
+     * Check if token is expired or about to expire (5 min buffer)
+     */
+    isTokenExpired(): boolean;
+    /**
+     * Clear all tokens
+     */
+    clearTokens(): void;
+    /**
+     * Refresh access token
+     */
+    refreshAccessToken(refreshCallback: (refreshToken: string) => Promise<TokenData>): Promise<string>;
+    /**
+     * Get valid access token (refresh if needed)
+     */
+    getValidAccessToken(refreshCallback?: (refreshToken: string) => Promise<TokenData>): Promise<string | null>;
+}
+
+/**
+ * Unified API Client supporting both user and partner authentication
+ */
+
+interface UnifiedApiClientConfig {
+    baseUrl: string;
+    timeout: number;
+    debug: boolean;
+    mode: AuthMode;
+    apiKey?: string;
+    clientId?: string;
+    keyId?: string;
+    secretKey?: string;
+    authMethod?: 'hmac' | 'jwt';
+    customerId?: string;
+    customerEmail?: string;
+}
+interface RequestOptions {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    path: string;
+    body?: any;
+    headers?: Record<string, string>;
+    useApiKey?: boolean;
+    skipAuth?: boolean;
+}
+/**
+ * Unified API client supporting both user and partner authentication modes
+ */
+declare class UnifiedApiClient {
+    private config;
+    tokenManager: TokenManager;
+    private partnerAuth?;
+    private refreshCallback?;
+    constructor(config: UnifiedApiClientConfig, useLocalStorage?: boolean);
+    /**
+     * Create client from legacy user config (backward compatibility)
+     */
+    static fromUserConfig(config: UserDiviswapConfig, useLocalStorage?: boolean): UnifiedApiClient;
+    /**
+     * Create client from partner config
+     */
+    static fromPartnerConfig(config: PartnerDiviswapConfig, useLocalStorage?: boolean): UnifiedApiClient;
+    /**
+     * Create client from any config (auto-detect mode)
+     */
+    static fromConfig(config: DiviswapConfig, useLocalStorage?: boolean): UnifiedApiClient;
+    private static getDefaultApiUrl;
+    /**
+     * Update customer context for partner auth
+     */
+    setCustomer(customerId: string, customerEmail?: string): void;
+    /**
+     * Clear customer context
+     */
+    clearCustomer(): void;
+    /**
+     * Get authentication mode
+     */
+    getAuthMode(): 'user' | 'partner';
+    /**
+     * Get current customer ID (partner mode only)
+     */
+    getCustomerId(): string | undefined;
+    /**
+     * Set refresh callback for automatic token refresh (user mode only)
+     */
+    setRefreshCallback(callback: (refreshToken: string) => Promise<TokenData>): void;
+    /**
+     * Set access token directly (user mode only)
+     */
+    setTokens(accessToken: string, refreshToken?: string): void;
+    /**
+     * Get current access token (user mode only)
+     */
+    getAccessToken(): Promise<string | null>;
+    /**
+     * Clear stored tokens (user mode only)
+     */
+    clearTokens(): void;
+    /**
+     * Make authenticated API request
+     */
+    request<T>(options: RequestOptions): Promise<T>;
+    /**
+     * Add partner authentication headers
+     */
+    private addPartnerAuth;
+    /**
+     * Add user authentication headers (legacy)
+     */
+    private addUserAuth;
+    private handleErrorResponse;
+    get<T>(path: string, options?: Omit<RequestOptions, 'method' | 'path'>): Promise<T>;
+    post<T>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'path' | 'body'>): Promise<T>;
+    put<T>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'path' | 'body'>): Promise<T>;
+    delete<T>(path: string, options?: Omit<RequestOptions, 'method' | 'path'>): Promise<T>;
+}
+
+/**
+ * Authentication module for Diviswap SDK
+ */
+
+declare class AuthModule {
+    private client;
+    constructor(client: UnifiedApiClient);
+    /**
+     * Register a new user
+     *
+     * @example
+     * ```typescript
+     * const { user, accessToken } = await diviswap.auth.register({
+     *   email: 'user@example.com',
+     *   password: 'secure-password',
+     *   firstName: 'John',
+     *   lastName: 'Doe'
+     * });
+     * ```
+     */
+    register(data: RegisterRequest): Promise<AuthResponse>;
+    /**
+     * Login an existing user
+     *
+     * @example
+     * ```typescript
+     * const { user, accessToken } = await diviswap.auth.login({
+     *   email: 'user@example.com',
+     *   password: 'secure-password'
+     * });
+     * ```
+     */
+    login(credentials: AuthCredentials): Promise<AuthResponse>;
+    /**
+     * Get current user profile
+     *
+     * @example
+     * ```typescript
+     * const user = await diviswap.auth.getProfile();
+     * console.log(user.email, user.kycStatus);
+     * ```
+     *
+     * Note: This endpoint is not yet available in the v1 API
+     */
+    getProfile(): Promise<User>;
+    /**
+     * Update user profile
+     *
+     * @example
+     * ```typescript
+     * const updatedUser = await diviswap.auth.updateProfile({
+     *   firstName: 'Jane',
+     *   lastName: 'Smith'
+     * });
+     * ```
+     *
+     * Note: This endpoint is not yet available in the v1 API
+     */
+    updateProfile(_data: Partial<User>): Promise<User>;
+    /**
+     * Request password reset
+     *
+     * @example
+     * ```typescript
+     * await diviswap.auth.requestPasswordReset('user@example.com');
+     * ```
+     *
+     * Note: This endpoint is not yet available in the v1 API
+     */
+    requestPasswordReset(_email: string): Promise<ApiResponse>;
+    /**
+     * Set new password with reset token
+     *
+     * @example
+     * ```typescript
+     * await diviswap.auth.setPassword('reset-token', 'new-secure-password');
+     * ```
+     *
+     * Note: This endpoint is not yet available in the v1 API
+     */
+    setPassword(_token: string, _password: string): Promise<ApiResponse>;
+    /**
+     * Logout current user
+     *
+     * @example
+     * ```typescript
+     * await diviswap.auth.logout();
+     * ```
+     */
+    logout(): Promise<void>;
+    /**
+     * Get compliance status
+     * @deprecated Use diviswap.kyc.getComplianceStatus() instead
+     */
+    getComplianceStatus(): Promise<any>;
+    /**
+     * Check if user is authenticated
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Refresh access token (internal)
+     *
+     * Note: This endpoint is not yet available in the v1 API
+     */
+    private refreshToken;
+}
+
+/**
+ * Payees module for managing bank accounts
+ */
+
+interface VerifyPayeeRequest {
+    amount1: number;
+    amount2: number;
+}
+declare class PayeesModule {
+    private client;
+    constructor(client: UnifiedApiClient);
+    /**
+     * Create a new payee (bank account)
+     *
+     * @example
+     * ```typescript
+     * // Bank account
+     * const bankAccount = await diviswap.payees.create({
+     *   nickname: 'My Checking',
+     *   accountNumber: '123456789',
+     *   routingNumber: '021000021',
+     *   accountType: 'checking',
+     *   setAsDefault: true
+     * });
+     *
+     * // Debit card
+     * const debitCard = await diviswap.payees.create({
+     *   nickname: 'My Debit Card',
+     *   accountType: 'debit_card',
+     *   debitCard: {
+     *     number: '4111111111111111',
+     *     expirationMonth: '12',
+     *     expirationYear: '2025',
+     *     cvv: '123'
+     *   },
+     *   setAsDefault: false
+     * });
+     * ```
+     */
+    create(data: CreatePayeeRequest): Promise<Payee>;
+    /**
+     * List all payees
+     *
+     * @example
+     * ```typescript
+     * const payees = await diviswap.payees.list();
+     * const defaultPayee = payees.find(p => p.isDefault);
+     * ```
+     */
+    list(): Promise<Payee[]>;
+    private parsePayeesResponse;
+    /**
+     * Get a specific payee
+     *
+     * @example
+     * ```typescript
+     * const payee = await diviswap.payees.get('payee-id');
+     * ```
+     */
+    get(payeeId: string): Promise<Payee>;
+    /**
+     * Set a payee as default
+     *
+     * @example
+     * ```typescript
+     * await diviswap.payees.setDefault('payee-id');
+     * ```
+     */
+    setDefault(payeeId: string): Promise<Payee>;
+    /**
+     * Delete a payee
+     *
+     * @example
+     * ```typescript
+     * await diviswap.payees.delete('payee-id');
+     * ```
+     */
+    delete(payeeId: string): Promise<ApiResponse>;
+    /**
+     * Get verification status of a payee
+     *
+     * @example
+     * ```typescript
+     * const status = await diviswap.payees.getVerificationStatus('payee-id');
+     * console.log(status.verified, status.microDepositsStatus);
+     * ```
+     */
+    getVerificationStatus(_payeeId: string): Promise<any>;
+    /**
+     * Verify a payee with micro-deposit amounts
+     *
+     * @example
+     * ```typescript
+     * const result = await diviswap.payees.verify('payee-id', {
+     *   amount1: 0.32,
+     *   amount2: 0.45
+     * });
+     * ```
+     */
+    verify(_payeeId: string, _data: VerifyPayeeRequest): Promise<ApiResponse>;
+    /**
+     * Get the default payee
+     *
+     * @example
+     * ```typescript
+     * const defaultPayee = await diviswap.payees.getDefault();
+     * if (!defaultPayee) {
+     *   console.log('No default payee set');
+     * }
+     * ```
+     */
+    getDefault(): Promise<Payee | null>;
+}
+
+/**
+ * Transactions module for crypto on/off ramps
+ */
+
+interface TransactionFilters {
+    type?: 'onramp' | 'offramp';
+    status?: 'pending' | 'processing' | 'completed' | 'failed';
+    startDate?: string;
+    endDate?: string;
+    limit?: number;
+    offset?: number;
+}
+interface FeeEstimate {
+    amount: number;
+    currency: string;
+    fee: number;
+    total: number;
+}
+declare class TransactionsModule {
+    private client;
+    private depositAddresses;
+    constructor(client: UnifiedApiClient, environment?: 'production' | 'sandbox' | 'development');
+    /**
+     * Map chain name to chain ID
+     * @private
+     */
+    private getChainId;
+    /**
+     * Get deposit address for a given chain
+     * @private
+     */
+    private getDepositAddress;
+    /**
+     * Get all configured deposit addresses
+     * @returns Object mapping chain names to deposit addresses
+     */
+    getDepositAddresses(): Record<string, string>;
+    /**
+     * Get deposit address for a specific chain
+     * @param chain - Chain name (e.g., 'ethereum', 'base', 'polygon')
+     * @returns The deposit address for the specified chain
+     * @throws Error if chain is not supported
+     */
+    getDepositAddressForChain(chain: string): string;
+    /**
+     * Create an onramp transaction (fiat to crypto)
+     *
+     * @example
+     * ```typescript
+     * const transaction = await diviswap.transactions.onramp({
+     *   amount: 100,
+     *   currency: 'USD',
+     *   payeeId: 'payee-id',
+     *   toAddress: '0xa3da8ffC1D131F917f9D0Ac078D82914e75d9651',
+     *   chain: 'ethereum'
+     * });
+     * ```
+     *
+     * @throws {Error} If user is not KYC approved
+     */
+    onramp(_data: OnrampRequest): Promise<Transaction>;
+    /**
+     * Create an offramp transaction (crypto to fiat)
+     *
+     * ⚠️ IMPORTANT: Follow the production pattern:
+     * 1. Send crypto transaction on blockchain FIRST
+     * 2. Get the transaction hash
+     * 3. Call this method with the hash
+     *
+     * @example
+     * ```typescript
+     * import { extractTransactionHash } from '@diviswap/sdk';
+     *
+     * // 1. Send crypto transaction first and get tx hash
+     * const txResult = await sendTransactionAsync({
+     *   to: depositAddress,
+     *   value: parseEther('0.5')
+     * });
+     *
+     * // 2. Extract hash (handles different wallet return types)
+     * const txHash = extractTransactionHash(txResult);
+     *
+     * // 3. Record the transaction
+     * const transaction = await diviswap.transactions.offramp({
+     *   amount: 0.5,
+     *   currency: 'ETH',
+     *   fromAddress: '0xa3da8ffC1D131F917f9D0Ac078D82914e75d9651',
+     *   payeeId: 'payee-id',
+     *   chain: 'ethereum',
+     *   txHash: txHash
+     * });
+     * ```
+     *
+     * @throws {Error} If user is not KYC approved
+     */
+    offramp(data: OfframpRequest & {
+        txHash: string;
+    }): Promise<Transaction>;
+    /**
+     * Create a test offramp transaction using the same production flow.
+     * Requires a transaction hash - send crypto first, then call this method.
+     *
+     * ⚠️ IMPORTANT: Follow the production pattern:
+     * 1. Send crypto transaction on blockchain FIRST
+     * 2. Get the transaction hash
+     * 3. Call this method with the hash
+     *
+     * @example
+     * ```typescript
+     * // 1. Send crypto transaction first and get tx hash
+     * const txHash = await sendCryptoTransaction({...});
+     *
+     * // 2. Record the transaction using production endpoint
+     * const transaction = await diviswap.transactions.offrampTest({
+     *   amount: 0.1,
+     *   currency: 'USDC',
+     *   fromAddress: '0x...',
+     *   toAddress: '0x...',
+     *   payeeId: 'payee-id',
+     *   chain: 'base',
+     *   txHash: txHash
+     * });
+     * ```
+     */
+    offrampTest(data: OfframpRequest & {
+        txHash: string;
+    }): Promise<Transaction>;
+    /**
+     * List transactions with optional filters
+     *
+     * @example
+     * ```typescript
+     * // Get all transactions
+     * const allTransactions = await diviswap.transactions.list();
+     *
+     * // Get only completed onramp transactions
+     * const completedOnramps = await diviswap.transactions.list({
+     *   type: 'onramp',
+     *   status: 'completed'
+     * });
+     * ```
+     */
+    list(filters?: TransactionFilters): Promise<Transaction[]>;
+    /**
+     * Get a specific transaction by ID
+     *
+     * @example
+     * ```typescript
+     * const transaction = await diviswap.transactions.get('transaction-id');
+     * console.log(transaction.status, transaction.amount);
+     * ```
+     */
+    get(transactionId: string): Promise<Transaction>;
+    /**
+     * Get fee estimate for a transaction
+     *
+     * @example
+     * ```typescript
+     * const estimate = await diviswap.transactions.estimateFees({
+     *   amount: 100,
+     *   currency: 'USD',
+     *   type: 'onramp'
+     * });
+     * console.log(`Fee: $${estimate.fee}, Total: $${estimate.total}`);
+     * ```
+     */
+    estimateFees(params: {
+        amount: number;
+        currency: string;
+        type: 'onramp' | 'offramp';
+    }): Promise<FeeEstimate>;
+    /**
+     * Get recent transactions (convenience method)
+     *
+     * @example
+     * ```typescript
+     * const recentTransactions = await diviswap.transactions.getRecent(10);
+     * ```
+     */
+    getRecent(limit?: number): Promise<Transaction[]>;
+    /**
+     * Get transaction statistics
+     *
+     * @example
+     * ```typescript
+     * const stats = await diviswap.transactions.getStats();
+     * console.log(`Total volume: $${stats.totalVolume}`);
+     * ```
+     */
+    getStats(): Promise<{
+        totalTransactions: number;
+        totalVolume: number;
+        pendingTransactions: number;
+        completedTransactions: number;
+    }>;
+    /**
+     * Get stablecoin addresses for a specific chain
+     * @param chain - Chain name (e.g., 'ethereum', 'base', 'polygon')
+     * @returns Object mapping stablecoin symbols to contract addresses
+     */
+    getStablecoinAddresses(chain: string): Record<string, string>;
+}
+
+/**
+ * KYC/KYB module for identity verification
+ */
+
+declare class KycModule {
+    private readonly client;
+    constructor(client: UnifiedApiClient);
+    /**
+     * Get current compliance status including KYC and KYB
+     *
+     * @example
+     * ```typescript
+     * const status = await diviswap.kyc.getComplianceStatus();
+     *
+     * if (!status.canTransact) {
+     *   if (status.nextStep === 'COMPLETE_KYC') {
+     *     // Redirect to KYC flow
+     *   }
+     * }
+     * ```
+     */
+    getComplianceStatus(): Promise<ComplianceStatus>;
+    /**
+     * Start KYC verification session (opens Sumsub widget)
+     *
+     * @example
+     * ```typescript
+     * const session = await diviswap.kyc.startKycSession();
+     *
+     * // Redirect user to session URL
+     * window.location.href = session.sessionUrl;
+     *
+     * // Or embed in iframe
+     * const iframe = document.createElement('iframe');
+     * iframe.src = session.sessionUrl;
+     * ```
+     */
+    startKycSession(): Promise<KycSessionResponse>;
+    /**
+     * Submit KYC documents programmatically
+     *
+     * @example
+     * ```typescript
+     * // Convert file to base64
+     * const toBase64 = (file: File) => new Promise<string>((resolve, reject) => {
+     *   const reader = new FileReader();
+     *   reader.readAsDataURL(file);
+     *   reader.onload = () => resolve(reader.result as string);
+     *   reader.onerror = reject;
+     * });
+     *
+     * const frontImage = await toBase64(frontFile);
+     * const backImage = await toBase64(backFile);
+     *
+     * await diviswap.kyc.submitDocuments({
+     *   type: 'DRIVERS_LICENSE',
+     *   frontImage,
+     *   backImage
+     * });
+     * ```
+     */
+    submitDocuments(documents: KycDocumentRequest): Promise<ApiResponse>;
+    /**
+     * Submit personal information for KYC
+     *
+     * @example
+     * ```typescript
+     * await diviswap.kyc.submitPersonalInfo({
+     *   firstName: 'John',
+     *   lastName: 'Doe',
+     *   dateOfBirth: '1990-01-01',
+     *   ssn: '123-45-6789',
+     *   address: {
+     *     street: '123 Main St',
+     *     city: 'New York',
+     *     state: 'NY',
+     *     postalCode: '10001',
+     *     country: 'US'
+     *   }
+     * });
+     * ```
+     */
+    submitPersonalInfo(info: KycPersonalInfo): Promise<ApiResponse>;
+    /**
+     * Check if user can transact (convenience method)
+     *
+     * @example
+     * ```typescript
+     * const canTransact = await diviswap.kyc.canTransact();
+     * if (!canTransact) {
+     *   // Show KYC prompt
+     * }
+     * ```
+     */
+    canTransact(): Promise<boolean>;
+    /**
+     * Check if KYC is approved
+     *
+     * @example
+     * ```typescript
+     * const isApproved = await diviswap.kyc.isKycApproved();
+     * ```
+     */
+    isKycApproved(): Promise<boolean>;
+    /**
+     * Check if KYB is approved (for business accounts)
+     *
+     * @example
+     * ```typescript
+     * const isBusinessApproved = await diviswap.kyc.isKybApproved();
+     * ```
+     */
+    isKybApproved(): Promise<boolean>;
+    /**
+     * Get rejection reasons if KYC/KYB was rejected
+     *
+     * @example
+     * ```typescript
+     * const reasons = await diviswap.kyc.getRejectionReasons();
+     * if (reasons.length > 0) {
+     *   console.log('Rejected because:', reasons.join(', '));
+     * }
+     * ```
+     */
+    getRejectionReasons(): Promise<string[]>;
+    /**
+     * Wait for KYC approval (polling)
+     *
+     * @example
+     * ```typescript
+     * // Start KYC session
+     * const session = await diviswap.kyc.startKycSession();
+     * window.open(session.sessionUrl);
+     *
+     * // Wait for approval (polls every 5 seconds for up to 10 minutes)
+     * try {
+     *   await diviswap.kyc.waitForApproval();
+     *   console.log('KYC approved!');
+     * } catch (error) {
+     *   console.log('KYC not approved:', error.message);
+     * }
+     * ```
+     */
+    waitForApproval(options?: {
+        pollInterval?: number;
+        maxAttempts?: number;
+    }): Promise<ComplianceStatus>;
+}
+
+/**
+ * Fees module for managing integrator fees
+ *
+ * This module allows integrators to:
+ * - Set a custom fee percentage on top of Diviswap's base 1.5% fee
+ * - Configure fees globally or per-user
+ * - Retrieve current fee settings
+ * - Calculate total fees for transactions
+ */
+
+interface FeeSettings {
+    integratorFeePercentage: number;
+    baseFeePercentage: number;
+    totalFeePercentage: number;
+    userId?: string;
+}
+interface SetFeeRequest {
+    percentage: number;
+    userId?: number;
+}
+interface FeeCalculation {
+    amount: number;
+    baseFee: number;
+    integratorFee: number;
+    totalFee: number;
+    netAmount: number;
+}
+declare class FeesModule {
+    private client;
+    constructor(client: UnifiedApiClient);
+    /**
+     * Set integrator fee percentage
+     *
+     * @example
+     * ```typescript
+     * // Set global integrator fee to 0.75% (applies to all your users)
+     * await diviswap.fees.setFee({ percentage: 0.75 });
+     *
+     * // Set fee for specific user (overrides global)
+     * await diviswap.fees.setFee({
+     *   percentage: 1.0,
+     *   userId: 123
+     * });
+     * ```
+     */
+    setFee(data: SetFeeRequest): Promise<FeeSettings>;
+    /**
+     * Get current fee settings
+     *
+     * @example
+     * ```typescript
+     * // Get global fee settings (your default)
+     * const fees = await diviswap.fees.getFees();
+     * console.log(`Total fee: ${fees.totalFeePercentage}%`);
+     * ```
+     */
+    getFees(): Promise<FeeSettings>;
+    /**
+     * Calculate fees for a transaction amount
+     *
+     * @example
+     * ```typescript
+     * const calc = await diviswap.fees.calculateFees({
+     *   amount: 100,
+     *   userId: 123 // Optional: checks for user-specific override
+     * });
+     *
+     * console.log(`Base fee: $${calc.baseFee}`);
+     * console.log(`Your fee: $${calc.integratorFee}`);
+     * console.log(`Total fee: $${calc.totalFee}`);
+     * console.log(`User receives: $${calc.netAmount}`);
+     * ```
+     */
+    calculateFees(params: {
+        amount: number;
+        userId?: number;
+    }): Promise<FeeCalculation>;
+    /**
+     * Remove custom fee for a user (reverts to partner default)
+     *
+     * @example
+     * ```typescript
+     * // Remove VIP user's custom fee, they'll use your default fee again
+     * await diviswap.fees.removeFee(123);
+     * ```
+     */
+    removeFee(userId: number): Promise<void>;
+}
+
+/**
+ * Address-related type definitions
+ */
+interface Address {
+    id: number;
+    uuid: string;
+    uuid_history: string[];
+    chain_id: number;
+    address: string;
+    is_default: boolean;
+    user_id?: number;
+    organization_id?: number;
+    created_at: string;
+    updated_at: string;
+}
+interface CreateAddressRequest {
+    chain_id: number;
+    address: string;
+    is_default?: boolean;
+}
+interface SetDefaultAddressRequest {
+    chain_id: number;
+    address: string;
+}
+interface DeleteAddressRequest {
+    chain_id: number;
+    address: string;
+}
+/**
+ * Chain ID mappings
+ */
+declare const CHAIN_IDS: {
+    readonly ethereum: 1;
+    readonly optimism: 10;
+    readonly base: 8453;
+    readonly polygon: 137;
+    readonly arbitrum: 42161;
+    readonly sepolia: 11155111;
+    readonly optimism_sepolia: 11155420;
+    readonly base_sepolia: 84532;
+    readonly polygon_mumbai: 80001;
+    readonly arbitrum_sepolia: 421614;
+};
+type ChainName = keyof typeof CHAIN_IDS;
+/**
+ * Wallet connection info for automatic tracking
+ */
+interface WalletConnection {
+    address: string;
+    chainId: number;
+    chainName?: string;
+}
+
+/**
+ * Addresses module for managing crypto addresses
+ */
+
+declare class AddressesModule {
+    private client;
+    constructor(client: UnifiedApiClient);
+    /**
+     * Get all addresses for the authenticated user
+     *
+     * @example
+     * ```typescript
+     * const addresses = await diviswap.addresses.list();
+     * console.log('User addresses:', addresses);
+     * ```
+     */
+    list(): Promise<Address[]>;
+    /**
+     * Create a new crypto address for the user
+     *
+     * @example
+     * ```typescript
+     * const address = await diviswap.addresses.create({
+     *   chain_id: 1, // Ethereum mainnet
+     *   address: '0x742d35Cc6647C9532c9fc77C68076aFb1e5AAc05',
+     *   is_default: true
+     * });
+     * ```
+     */
+    create(data: CreateAddressRequest): Promise<Address>;
+    /**
+     * Set a specific address as the default for its chain
+     *
+     * @example
+     * ```typescript
+     * await diviswap.addresses.setDefault({
+     *   chain_id: 1,
+     *   address: '0x742d35Cc6647C9532c9fc77C68076aFb1e5AAc05'
+     * });
+     * ```
+     */
+    setDefault(data: SetDefaultAddressRequest): Promise<void>;
+    /**
+     * Delete a crypto address
+     *
+     * @example
+     * ```typescript
+     * await diviswap.addresses.delete({
+     *   chain_id: 1,
+     *   address: '0x742d35Cc6647C9532c9fc77C68076aFb1e5AAc05'
+     * });
+     * ```
+     */
+    delete(data: DeleteAddressRequest): Promise<void>;
+    /**
+     * Get addresses for a specific chain
+     *
+     * @example
+     * ```typescript
+     * const ethAddresses = await diviswap.addresses.getByChain(1);
+     * const baseAddresses = await diviswap.addresses.getByChain('base');
+     * ```
+     */
+    getByChain(chainIdOrName: number | ChainName): Promise<Address[]>;
+    /**
+     * Get the default address for a specific chain
+     *
+     * @example
+     * ```typescript
+     * const defaultEthAddress = await diviswap.addresses.getDefault(1);
+     * const defaultBaseAddress = await diviswap.addresses.getDefault('base');
+     * ```
+     */
+    getDefault(chainIdOrName: number | ChainName): Promise<Address | null>;
+    /**
+     * Check if an address exists for the user
+     *
+     * @example
+     * ```typescript
+     * const exists = await diviswap.addresses.exists({
+     *   chain_id: 1,
+     *   address: '0x742d35Cc6647C9532c9fc77C68076aFb1e5AAc05'
+     * });
+     * ```
+     */
+    exists(data: {
+        chain_id: number;
+        address: string;
+    }): Promise<boolean>;
+    /**
+     * Automatically track a wallet connection
+     * This is the main method for automatic address tracking
+     *
+     * @example
+     * ```typescript
+     * // When user connects wallet
+     * const connection = await diviswap.addresses.trackWallet({
+     *   address: account,
+     *   chainId: chainId,
+     *   chainName: 'ethereum' // optional
+     * });
+     * ```
+     */
+    trackWallet(connection: WalletConnection): Promise<Address>;
+    /**
+     * Auto-track multiple wallet connections (useful for multi-chain wallets)
+     *
+     * @example
+     * ```typescript
+     * // When user connects a multi-chain wallet
+     * const addresses = await diviswap.addresses.trackMultipleWallets([
+     *   { address: account, chainId: 1 },      // Ethereum
+     *   { address: account, chainId: 8453 },   // Base
+     *   { address: account, chainId: 10 }      // Optimism
+     * ]);
+     * ```
+     */
+    trackMultipleWallets(connections: WalletConnection[]): Promise<Address[]>;
+    /**
+     * Helper to get chain name from chain ID
+     */
+    getChainName(chainId: number): string | undefined;
+    /**
+     * Helper to get chain ID from chain name
+     */
+    getChainId(chainName: ChainName): number;
+    /**
+     * Get all supported chains
+     */
+    getSupportedChains(): Record<string, number>;
+}
+
+/**
+ * Webhooks module for managing partner webhook configurations
+ */
+
+interface WebhookConfig {
+    webhook_url: string | null;
+    has_webhook_secret: boolean;
+    enabled: boolean;
+}
+interface WebhookEvent {
+    id: number;
+    partner_id: number;
+    user_id: number | null;
+    event_type: string;
+    payload: any;
+    status: 'pending' | 'delivered' | 'failed';
+    response_code: number | null;
+    attempts: number;
+    max_attempts: number;
+    created_at: string;
+    delivered_at: string | null;
+    next_retry_at: string | null;
+}
+interface SetWebhookRequest {
+    webhook_url: string;
+    webhook_secret?: string;
+}
+declare class WebhooksModule {
+    private client;
+    constructor(client: UnifiedApiClient);
+    /**
+     * Set webhook URL and secret for your partner account
+     *
+     * @example
+     * ```typescript
+     * await diviswap.webhooks.setConfig({
+     *   webhook_url: 'https://myapp.com/api/webhooks/diviswap',
+     *   webhook_secret: 'whsec_...' // Optional, auto-generated if not provided
+     * });
+     * ```
+     */
+    setConfig(data: SetWebhookRequest): Promise<{
+        success: boolean;
+        webhook_url: string;
+        webhook_secret: string;
+    }>;
+    /**
+     * Set webhook for a specific partner (user-owned partner)
+     *
+     * @example
+     * ```typescript
+     * await diviswap.webhooks.setConfigForPartner(4, {
+     *   webhook_url: 'https://myapp.com/webhooks'
+     * });
+     * ```
+     */
+    setConfigForPartner(partnerId: number, data: SetWebhookRequest): Promise<{
+        success: boolean;
+        webhook_url: string;
+        webhook_secret: string;
+    }>;
+    /**
+     * Get current webhook configuration
+     *
+     * @example
+     * ```typescript
+     * const config = await diviswap.webhooks.getConfig();
+     * console.log(`Webhook enabled: ${config.enabled}`);
+     * console.log(`URL: ${config.webhook_url}`);
+     * ```
+     */
+    getConfig(): Promise<WebhookConfig>;
+    /**
+     * Get webhook config for a specific partner (user-owned)
+     */
+    getConfigForPartner(partnerId: number): Promise<WebhookConfig>;
+    /**
+     * List webhook delivery events
+     *
+     * @example
+     * ```typescript
+     * const events = await diviswap.webhooks.listEvents({
+     *   limit: 100,
+     *   status: 'failed'
+     * });
+     *
+     * events.forEach(event => {
+     *   console.log(`${event.event_type}: ${event.status}`);
+     * });
+     * ```
+     */
+    listEvents(options?: {
+        partnerId?: number;
+        limit?: number;
+        status?: 'pending' | 'delivered' | 'failed';
+    }): Promise<{
+        success: boolean;
+        events: WebhookEvent[];
+    }>;
+    /**
+     * Send a test webhook to verify your endpoint is working
+     *
+     * @example
+     * ```typescript
+     * const result = await diviswap.webhooks.test();
+     * if (result.success) {
+     *   console.log('Webhook endpoint is working!');
+     * }
+     * ```
+     */
+    test(partnerId?: number): Promise<any>;
+    /**
+     * Verify a webhook signature (static helper for your webhook endpoint)
+     *
+     * @example
+     * ```typescript
+     * import crypto from 'crypto';
+     *
+     * const isValid = WebhooksModule.verifySignature(
+     *   rawBody,
+     *   request.headers['x-signature'],
+     *   process.env.WEBHOOK_SECRET
+     * );
+     * ```
+     */
+    static verifySignature(payload: string, signature: string, secret: string): boolean;
+}
+
+/**
+ * Main Diviswap SDK Client
+ */
+
+/**
+ * Diviswap SDK Client
+ *
+ * @example
+ * User Authentication (existing):
+ * ```typescript
+ * const diviswap = Diviswap.init({
+ *   apiKey: 'your-api-key',
+ *   clientId: 'your-client-id',
+ *   environment: 'sandbox'
+ * });
+ * ```
+ *
+ * Partner Authentication (new):
+ * ```typescript
+ * const diviswap = Diviswap.init({
+ *   mode: 'partner',
+ *   keyId: 'pk_...',
+ *   secretKey: 'sk_...',
+ *   authMethod: 'hmac', // or 'jwt'
+ *   environment: 'sandbox'
+ * });
+ * ```
+ */
+declare class Diviswap {
+    private config;
+    private static instance;
+    private apiClient;
+    auth: AuthModule;
+    payees: PayeesModule;
+    transactions: TransactionsModule;
+    kyc: KycModule;
+    fees: FeesModule;
+    addresses: AddressesModule;
+    webhooks: WebhooksModule;
+    private constructor();
+    /**
+     * Initialize the Diviswap SDK
+     *
+     * @param config - SDK configuration
+     * @returns Diviswap SDK instance
+     *
+     * @example
+     * ```typescript
+     * const diviswap = Diviswap.init({
+     *   apiKey: 'your-api-key',
+     *   clientId: 'your-client-id'
+     * });
+     * ```
+     */
+    static init(config: DiviswapConfig): Diviswap;
+    /**
+     * Get the current SDK instance
+     * @throws {ConfigurationError} If SDK hasn't been initialized
+     */
+    static getInstance(): Diviswap;
+    /**
+     * Reset the SDK instance (useful for testing)
+     */
+    static reset(): void;
+    /**
+     * Update SDK configuration
+     * @deprecated Configuration updates require re-initialization. Call Diviswap.reset() then Diviswap.init() with new config.
+     */
+    updateConfig(_config: Partial<DiviswapConfig>): void;
+    /**
+     * Get current configuration (excluding sensitive data)
+     */
+    getConfig(): Partial<DiviswapConfig>;
+    /**
+     * Get current access token (for developers who need it for custom API calls)
+     * Only available in user authentication mode.
+     *
+     * @example
+     * ```typescript
+     * const token = await diviswap.getAccessToken();
+     * if (token) {
+     *   // Use token for custom API calls
+     *   fetch('https://api.diviswap.io/custom-endpoint', {
+     *     headers: { 'Authorization': `Bearer ${token}` }
+     *   });
+     * }
+     * ```
+     */
+    getAccessToken(): Promise<string | null>;
+    /**
+     * Set access token (for server-side usage where tokens are stored externally)
+     * Only available in user authentication mode.
+     *
+     * @example
+     * ```typescript
+     * // In a Next.js API route where token is stored in cookies
+     * const token = cookies().get('diviswap_session')?.value;
+     * if (token) {
+     *   diviswap.setAccessToken(token);
+     * }
+     * ```
+     */
+    setAccessToken(accessToken: string, refreshToken?: string): void;
+    /**
+     * Set customer context for partner authentication mode
+     *
+     * @example
+     * ```typescript
+     * // For partner auth mode - link requests to a specific customer
+     * diviswap.setCustomer('user-123', 'user@example.com');
+     *
+     * // Now all API calls will be made on behalf of this customer
+     * const payees = await diviswap.payees.getAll();
+     * ```
+     */
+    setCustomer(customerId: string, customerEmail?: string): void;
+    /**
+     * Clear customer context for partner authentication mode
+     */
+    clearCustomer(): void;
+    private validateConfig;
+}
+
+/**
+ * Wallet integration helpers for automatic address tracking
+ */
+
+/**
+ * Ethereum-like wallet interface (compatible with MetaMask, WalletConnect, etc.)
+ */
+interface EthereumWallet {
+    request: (args: {
+        method: string;
+        params?: any[];
+    }) => Promise<any>;
+    on?: (event: string, handler: (...args: any[]) => void) => void;
+    removeListener?: (event: string, handler: (...args: any[]) => void) => void;
+}
+/**
+ * Automatic wallet tracking configuration
+ */
+interface WalletTrackingConfig {
+    /** Automatically track when accounts change */
+    trackAccountChanges?: boolean;
+    /** Automatically track when chain changes */
+    trackChainChanges?: boolean;
+    /** Set newly connected addresses as default for their chain */
+    setAsDefault?: boolean;
+    /** Custom chain mappings for unsupported chains */
+    customChains?: Record<number, string>;
+}
+/**
+ * Wallet tracking manager for automatic address management
+ */
+declare class WalletTracker {
+    private static instance;
+    private wallet;
+    private diviswap;
+    private config;
+    private listeners;
+    private constructor();
+    /**
+     * Get or create the wallet tracker instance
+     */
+    static getInstance(config?: WalletTrackingConfig): WalletTracker;
+    /**
+     * Initialize wallet tracking with Diviswap SDK instance
+     */
+    init(diviswap: Diviswap, wallet?: EthereumWallet): void;
+    /**
+     * Connect and track a wallet
+     */
+    connect(): Promise<WalletConnection[]>;
+    /**
+     * Track current wallet state without requesting connection
+     */
+    trackCurrent(): Promise<WalletConnection[]>;
+    /**
+     * Setup listener for account changes
+     */
+    private setupAccountChangeListener;
+    /**
+     * Setup listener for chain changes
+     */
+    private setupChainChangeListener;
+    /**
+     * Get chain name from chain ID
+     */
+    private getChainName;
+    /**
+     * Cleanup listeners
+     */
+    cleanup(): void;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<WalletTrackingConfig>): void;
+}
+/**
+ * Convenience functions for easy integration
+ */
+/**
+ * Connect wallet and automatically track addresses
+ *
+ * @example
+ * ```typescript
+ * import { Diviswap, connectWallet } from '@diviswap/sdk';
+ *
+ * const diviswap = Diviswap.init(config);
+ *
+ * // Connect and track wallet automatically
+ * const connections = await connectWallet(diviswap);
+ * console.log('Tracked addresses:', connections);
+ * ```
+ */
+declare function connectWallet(diviswap: Diviswap, wallet?: EthereumWallet, config?: WalletTrackingConfig): Promise<WalletConnection[]>;
+/**
+ * Track current wallet state without requesting connection
+ *
+ * @example
+ * ```typescript
+ * import { Diviswap, trackCurrentWallet } from '@diviswap/sdk';
+ *
+ * const diviswap = Diviswap.init(config);
+ *
+ * // Track currently connected accounts
+ * const connections = await trackCurrentWallet(diviswap);
+ * ```
+ */
+declare function trackCurrentWallet(diviswap: Diviswap, wallet?: EthereumWallet, config?: WalletTrackingConfig): Promise<WalletConnection[]>;
+/**
+ * Setup automatic wallet tracking (listens for account/chain changes)
+ *
+ * @example
+ * ```typescript
+ * import { Diviswap, setupWalletTracking } from '@diviswap/sdk';
+ *
+ * const diviswap = Diviswap.init(config);
+ *
+ * // Setup automatic tracking
+ * setupWalletTracking(diviswap, {
+ *   trackAccountChanges: true,
+ *   trackChainChanges: true,
+ *   setAsDefault: true
+ * });
+ * ```
+ */
+declare function setupWalletTracking(diviswap: Diviswap, wallet?: EthereumWallet, config?: WalletTrackingConfig): WalletTracker;
+
+export { type AuthCredentials as A, type OrganizationInfo as B, type ComplianceStatus as C, Diviswap as D, type Environment as E, type KycDocumentRequest as F, type KycPersonalInfo as G, type IndividualData as I, type KycStatus as K, type LiberExConfig as L, type OnrampRequest as O, type Payee as P, type RegisterRequest as R, type SetDefaultAddressRequest as S, type Transaction as T, type User as U, type WalletConnection as W, type DiviswapConfig as a, type KybStatus as b, type KycSessionResponse as c, type Address as d, type CreateAddressRequest as e, type DeleteAddressRequest as f, type ChainName as g, CHAIN_IDS as h, WalletTracker as i, connectWallet as j, type EthereumWallet as k, type WalletTrackingConfig as l, type AuthMode as m, type UserDiviswapConfig as n, type PartnerDiviswapConfig as o, type UserLiberExConfig as p, type PartnerLiberExConfig as q, type LegacyDiviswapConfig as r, setupWalletTracking as s, trackCurrentWallet as t, type AuthResponse as u, type CreatePayeeRequest as v, type OfframpRequest as w, type ApiResponse as x, type KycMetadata as y, type KybMetadata as z };