SDKS & Libraries

SDKs and Libraries

Overview

Buburuza provides native SDKs for all major programming languages and platforms, enabling developers to integrate AI-powered banking services with minimal code. Our SDKs handle authentication, error handling, and provide type-safe interfaces for all API operations.

JavaScript/TypeScript SDK

Installation

npm install @buburuza/sdk
# or
yarn add @buburuza/sdk

Quick Start

import { BuburuざAPI } from '@buburuza/sdk';

// Initialize the client
const buburuza = new BuburuざAPI({
  apiKey: 'bb_test_1234567890abcdef',
  environment: 'sandbox', // 'sandbox' | 'production'
  version: 'v1'
});

// Create a customer account
const customer = await buburuza.customers.create({
  email: '[email protected]',
  firstName: 'John',
  lastName: 'Doe',
  phone: '+1-555-0123'
});

// Create a wallet
const wallet = await buburuza.wallets.create({
  customerId: customer.id,
  currency: 'USD',
  type: 'personal'
});

// Process a transaction
const transaction = await buburuza.transactions.create({
  type: 'transfer',
  fromWalletId: wallet.id,
  toWalletId: 'wallet_recipient_456',
  amount: 5000, // $50.00
  currency: 'USD',
  description: 'Payment for services'
});

TypeScript Support

Full TypeScript support with comprehensive type definitions.

import { 
  Customer, 
  Wallet, 
  Transaction, 
  CreateCustomerRequest,
  CreateWalletRequest
} from '@buburuza/sdk';

// Strongly typed request objects
const customerRequest: CreateCustomerRequest = {
  email: '[email protected]',
  firstName: 'Jane',
  lastName: 'Smith',
  dateOfBirth: '1990-01-15',
  address: {
    street: '123 Main St',
    city: 'San Francisco',
    state: 'CA',
    postalCode: '94102',
    country: 'US'
  }
};

// Strongly typed response objects
const customer: Customer = await buburuza.customers.create(customerRequest);

// Type-safe wallet operations
const walletRequest: CreateWalletRequest = {
  customerId: customer.id,
  currency: 'USD',
  type: 'savings',
  name: 'Emergency Fund'
};

const wallet: Wallet = await buburuza.wallets.create(walletRequest);

React Hooks

React hooks for seamless integration in React applications.

import { useBuburuza, useWallet, useTransactions } from '@buburuza/react';

function BankingDashboard({ customerId }: { customerId: string }) {
  const buburuza = useBuburuza();
  
  // Fetch wallet data with automatic caching and revalidation
  const { wallet, loading, error, refetch } = useWallet(customerId);
  
  // Fetch transaction history with pagination
  const { 
    transactions, 
    loading: txLoading, 
    loadMore, 
    hasMore 
  } = useTransactions(wallet?.id, { limit: 20 });

  const handleTransfer = async (amount: number, recipientId: string) => {
    try {
      await buburuza.transactions.create({
        type: 'transfer',
        fromWalletId: wallet.id,
        toWalletId: recipientId,
        amount: amount * 100, // Convert to cents
        currency: 'USD'
      });
      
      // Automatically refetch wallet and transactions
      refetch();
    } catch (error) {
      console.error('Transfer failed:', error);
    }
  };

  if (loading) return <div>Loading wallet...</div>;
  if (error) return <div>Error: {error.message}</div>;

  return (
    <div>
      <h2>Account Balance: ${wallet.balance / 100}</h2>
      
      <TransactionList 
        transactions={transactions}
        loading={txLoading}
        onLoadMore={loadMore}
        hasMore={hasMore}
      />
      
      <TransferForm onSubmit={handleTransfer} />
    </div>
  );
}

AI Services Integration

// Natural language transaction processing
const aiIntent = await buburuza.ai.parseIntent({
  customerId: customer.id,
  message: "Send $100 to my mom for her birthday",
  context: {
    recentContacts: [
      { name: 'Mom', accountId: 'acc_mom_123', relationship: 'family' }
    ],
    accountBalance: wallet.balance
  }
});

if (aiIntent.confidence > 0.8) {
  const transaction = await buburuza.transactions.createFromIntent({
    intentId: aiIntent.id,
    confirmations: {
      recipient: 'acc_mom_123'
    }
  });
}

// Conversational banking
const conversation = await buburuza.ai.conversation({
  customerId: customer.id,
  sessionId: 'session_123',
  message: "What's the best way to save for a house?",
  context: {
    customerProfile: {
      age: 28,
      income: 85000,
      currentSavings: wallet.balance
    }
  }
});

console.log('AI Response:', conversation.response);

Python SDK

Installation

pip install buburuza-python

Quick Start

from buburuza import BuburuざAPI
from buburuza.models import CreateCustomerRequest, CreateWalletRequest

# Initialize the client
buburuza = BuburuざAPI(
    api_key='bb_test_1234567890abcdef',
    environment='sandbox'
)

# Create a customer
customer = buburuza.customers.create(
    email='[email protected]',
    first_name='John',
    last_name='Doe',
    phone='+1-555-0123'
)

# Create a wallet
wallet = buburuza.wallets.create(
    customer_id=customer.id,
    currency='USD',
    type='checking',
    name='Primary Account'
)

# Process a transaction
transaction = buburuza.transactions.create(
    type='transfer',
    from_wallet_id=wallet.id,
    to_wallet_id='wallet_recipient_456',
    amount=5000,  # $50.00 in cents
    currency='USD',
    description='Payment for services'
)

print(f"Transaction completed: {transaction.id}")

Async Support

Full async/await support for high-performance applications.

import asyncio
from buburuza import AsyncBuburuざAPI

async def main():
    # Initialize async client
    buburuza = AsyncBuburuざAPI(
        api_key='bb_test_1234567890abcdef',
        environment='sandbox'
    )
    
    # Concurrent operations
    tasks = [
        buburuza.customers.create(email=f'user{i}@example.com', 
                                first_name=f'User{i}', 
                                last_name='Test')
        for i in range(10)
    ]
    
    customers = await asyncio.gather(*tasks)
    print(f"Created {len(customers)} customers concurrently")
    
    # Close the client
    await buburuza.close()

asyncio.run(main())

Django Integration

Django models and views for seamless integration.

# models.py
from django.db import models
from buburuza.django import BuburuざModelMixin

class UserProfile(models.Model, BuburuざModelMixin):
    user = models.OneToOneField('auth.User', on_delete=models.CASCADE)
    buburuza_customer_id = models.CharField(max_length=50, blank=True)
    
    def create_buburuza_account(self):
        """Create Buburuza customer account"""
        customer = self.get_buburuza_client().customers.create(
            email=self.user.email,
            first_name=self.user.first_name,
            last_name=self.user.last_name
        )
        
        self.buburuza_customer_id = customer.id
        self.save()
        
        return customer

# views.py
from django.shortcuts import render
from buburuza.django import BuburuざViewMixin

class WalletView(BuburuざViewMixin, TemplateView):
    template_name = 'wallet.html'
    
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        
        # Get user's wallets
        wallets = self.buburuza.wallets.list(
            customer_id=self.request.user.profile.buburuza_customer_id
        )
        
        context['wallets'] = wallets.data
        return context

Java SDK

Installation

<!-- Maven -->
<dependency>
    <groupId>com.buburuza</groupId>
    <artifactId>buburuza-java</artifactId>
    <version>1.0.0</version>
</dependency>

// Gradle
implementation 'com.buburuza:buburuza-java:1.0.0'

Quick Start

import com.buburuza.BuburuざAPI;
import com.buburuza.models.*;
import com.buburuza.exceptions.BuburuざException;

public class BankingApp {
    public static void main(String[] args) {
        // Initialize the client
        BuburuざAPI buburuza = new BuburuざAPI.Builder()
            .apiKey("bb_test_1234567890abcdef")
            .environment(Environment.SANDBOX)
            .build();
        
        try {
            // Create a customer
            CreateCustomerRequest customerRequest = CreateCustomerRequest.builder()
                .email("[email protected]")
                .firstName("John")
                .lastName("Doe")
                .phone("+1-555-0123")
                .build();
            
            Customer customer = buburuza.customers().create(customerRequest);
            
            // Create a wallet
            CreateWalletRequest walletRequest = CreateWalletRequest.builder()
                .customerId(customer.getId())
                .currency("USD")
                .type(WalletType.CHECKING)
                .name("Primary Account")
                .build();
            
            Wallet wallet = buburuza.wallets().create(walletRequest);
            
            // Process a transaction
            CreateTransactionRequest transactionRequest = CreateTransactionRequest.builder()
                .type(TransactionType.TRANSFER)
                .fromWalletId(wallet.getId())
                .toWalletId("wallet_recipient_456")
                .amount(5000L) // $50.00 in cents
                .currency("USD")
                .description("Payment for services")
                .build();
            
            Transaction transaction = buburuza.transactions().create(transactionRequest);
            
            System.out.println("Transaction completed: " + transaction.getId());
            
        } catch (BuburuざException e) {
            System.err.println("API Error: " + e.getMessage());
            System.err.println("Error Code: " + e.getCode());
        }
    }
}

Spring Boot Integration

Spring Boot starter for auto-configuration.

// Configuration
@Configuration
@EnableBuburuざ
public class BuburuざConfig {
    
    @Bean
    @ConfigurationProperties("buburuza")
    public BuburuざProperties buburuざProperties() {
        return new BuburuざProperties();
    }
}

// Service class
@Service
public class BankingService {
    
    @Autowired
    private BuburuざAPI buburuza;
    
    public Customer createCustomer(String email, String firstName, String lastName) {
        CreateCustomerRequest request = CreateCustomerRequest.builder()
            .email(email)
            .firstName(firstName)
            .lastName(lastName)
            .build();
        
        return buburuza.customers().create(request);
    }
    
    public List<Wallet> getCustomerWallets(String customerId) {
        return buburuza.wallets().list(
            WalletListRequest.builder()
                .customerId(customerId)
                .build()
        ).getData();
    }
}

// REST Controller
@RestController
@RequestMapping("/api/banking")
public class BankingController {
    
    @Autowired
    private BankingService bankingService;
    
    @PostMapping("/customers")
    public ResponseEntity<Customer> createCustomer(@RequestBody CreateCustomerDto dto) {
        Customer customer = bankingService.createCustomer(
            dto.getEmail(), 
            dto.getFirstName(), 
            dto.getLastName()
        );
        
        return ResponseEntity.ok(customer);
    }
    
    @GetMapping("/customers/{customerId}/wallets")
    public ResponseEntity<List<Wallet>> getWallets(@PathVariable String customerId) {
        List<Wallet> wallets = bankingService.getCustomerWallets(customerId);
        return ResponseEntity.ok(wallets);
    }
}

iOS Swift SDK

Installation

// Package.swift
dependencies: [
    .package(url: "https://github.com/buburuza/buburuza-ios.git", from: "1.0.0")
]

// Or via CocoaPods
// pod 'BuburuざSDK'

// Or via Carthage
// github "buburuza/buburuza-ios"

Quick Start

import BuburuざSDK

class BankingManager {
    private let buburuza: BuburuざAPI
    
    init() {
        buburuza = BuburuざAPI(
            apiKey: "bb_test_1234567890abcdef",
            environment: .sandbox
        )
    }
    
    func createCustomer() async throws -> Customer {
        let request = CreateCustomerRequest(
            email: "[email protected]",
            firstName: "John",
            lastName: "Doe",
            phone: "+1-555-0123"
        )
        
        return try await buburuza.customers.create(request)
    }
    
    func createWallet(for customerId: String) async throws -> Wallet {
        let request = CreateWalletRequest(
            customerId: customerId,
            currency: .USD,
            type: .checking,
            name: "Primary Account"
        )
        
        return try await buburuza.wallets.create(request)
    }
    
    func transferMoney(
        from fromWalletId: String,
        to toWalletId: String,
        amount: Int
    ) async throws -> Transaction {
        let request = CreateTransactionRequest(
            type: .transfer,
            fromWalletId: fromWalletId,
            toWalletId: toWalletId,
            amount: amount,
            currency: .USD,
            description: "Transfer"
        )
        
        return try await buburuza.transactions.create(request)
    }
}

SwiftUI Integration

SwiftUI views and observable objects for reactive UIs.

import SwiftUI
import BuburuざSDK

@MainActor
class WalletViewModel: ObservableObject {
    @Published var wallets: [Wallet] = []
    @Published var isLoading = false
    @Published var error: Error?
    
    private let buburuza = BuburuざAPI.shared
    
    func loadWallets(for customerId: String) async {
        isLoading = true
        error = nil
        
        do {
            let response = try await buburuza.wallets.list(
                customerId: customerId
            )
            wallets = response.data
        } catch {
            self.error = error
        }
        
        isLoading = false
    }
}

struct WalletView: View {
    @StateObject private var viewModel = WalletViewModel()
    let customerId: String
    
    var body: some View {
        NavigationView {
            Group {
                if viewModel.isLoading {
                    ProgressView("Loading wallets...")
                } else if let error = viewModel.error {
                    ErrorView(error: error) {
                        Task {
                            await viewModel.loadWallets(for: customerId)
                        }
                    }
                } else {
                    List(viewModel.wallets) { wallet in
                        WalletRowView(wallet: wallet)
                    }
                }
            }
            .navigationTitle("My Wallets")
            .task {
                await viewModel.loadWallets(for: customerId)
            }
        }
    }
}

struct WalletRowView: View {
    let wallet: Wallet
    
    var body: some View {
        VStack(alignment: .leading, spacing: 4) {
            Text(wallet.name)
                .font(.headline)
            
            Text("Balance: \(wallet.formattedBalance)")
                .font(.subheadline)
                .foregroundColor(.secondary)
            
            Text(wallet.currency.rawValue)
                .font(.caption)
                .padding(.horizontal, 8)
                .padding(.vertical, 2)
                .background(Color.blue.opacity(0.1))
                .cornerRadius(4)
        }
        .padding(.vertical, 4)
    }
}

Biometric Authentication

import LocalAuthentication
import BuburuざSDK

class BiometricAuthManager {
    private let buburuza = BuburuざAPI.shared
    
    func authenticateWithBiometrics(for userId: String) async throws -> AuthResult {
        let context = LAContext()
        var error: NSError?
        
        // Check if biometric authentication is available
        guard context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, error: &error) else {
            throw BiometricError.notAvailable
        }
        
        // Perform biometric authentication
        let reason = "Authenticate to access your Buburuza account"
        
        do {
            let success = try await context.evaluatePolicy(
                .deviceOwnerAuthenticationWithBiometrics,
                localizedReason: reason
            )
            
            if success {
                // Generate biometric signature
                let signature = try generateBiometricSignature(context: context)
                
                // Authenticate with Buburuza
                let authResult = try await buburuza.auth.biometric.verify(
                    userId: userId,
                    signature: signature,
                    biometricType: .faceID
                )
                
                return authResult
            }
        } catch {
            throw BiometricError.authenticationFailed(error)
        }
        
        throw BiometricError.unknown
    }
    
    private func generateBiometricSignature(context: LAContext) throws -> String {
        // Implementation for generating biometric signature
        // This would use the secure enclave to sign a challenge
        return "biometric_signature_data"
    }
}

enum BiometricError: Error {
    case notAvailable
    case authenticationFailed(Error)
    case unknown
}

Android Kotlin SDK

Installation

// build.gradle (Module: app)
dependencies {
    implementation 'com.buburuza:buburuza-android:1.0.0'
}

Quick Start

import com.buburuza.BuburuざAPI
import com.buburuza.models.*
import kotlinx.coroutines.runBlocking

class BankingManager {
    private val buburuza = BuburuざAPI.Builder()
        .apiKey("bb_test_1234567890abcdef")
        .environment(Environment.SANDBOX)
        .build()
    
    suspend fun createCustomer(): Customer {
        val request = CreateCustomerRequest(
            email = "[email protected]",
            firstName = "John",
            lastName = "Doe",
            phone = "+1-555-0123"
        )
        
        return buburuza.customers.create(request)
    }
    
    suspend fun createWallet(customerId: String): Wallet {
        val request = CreateWalletRequest(
            customerId = customerId,
            currency = Currency.USD,
            type = WalletType.CHECKING,
            name = "Primary Account"
        )
        
        return buburuza.wallets.create(request)
    }
    
    suspend fun transferMoney(
        fromWalletId: String,
        toWalletId: String,
        amount: Long
    ): Transaction {
        val request = CreateTransactionRequest(
            type = TransactionType.TRANSFER,
            fromWalletId = fromWalletId,
            toWalletId = toWalletId,
            amount = amount,
            currency = Currency.USD,
            description = "Transfer"
        )
        
        return buburuza.transactions.create(request)
    }
}

Jetpack Compose Integration

import androidx.compose.runtime.*
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch

class WalletViewModel : ViewModel() {
    private val buburuza = BuburuざAPI.shared
    
    var wallets by mutableStateOf<List<Wallet>>(emptyList())
        private set
    
    var isLoading by mutableStateOf(false)
        private set
    
    var error by mutableStateOf<String?>(null)
        private set
    
    fun loadWallets(customerId: String) {
        viewModelScope.launch {
            isLoading = true
            error = null
            
            try {
                val response = buburuza.wallets.list(customerId = customerId)
                wallets = response.data
            } catch (e: Exception) {
                error = e.message
            } finally {
                isLoading = false
            }
        }
    }
}

@Composable
fun WalletScreen(
    customerId: String,
    viewModel: WalletViewModel = hiltViewModel()
) {
    val wallets = viewModel.wallets
    val isLoading = viewModel.isLoading
    val error = viewModel.error
    
    LaunchedEffect(customerId) {
        viewModel.loadWallets(customerId)
    }
    
    Column {
        when {
            isLoading -> {
                Box(
                    modifier = Modifier.fillMaxSize(),
                    contentAlignment = Alignment.Center
                ) {
                    CircularProgressIndicator()
                }
            }
            
            error != null -> {
                ErrorMessage(
                    message = error,
                    onRetry = { viewModel.loadWallets(customerId) }
                )
            }
            
            else -> {
                LazyColumn {
                    items(wallets) { wallet ->
                        WalletCard(wallet = wallet)
                    }
                }
            }
        }
    }
}

@Composable
fun WalletCard(wallet: Wallet) {
    Card(
        modifier = Modifier
            .fillMaxWidth()
            .padding(horizontal = 16.dp, vertical = 8.dp)
    ) {
        Column(
            modifier = Modifier.padding(16.dp)
        ) {
            Text(
                text = wallet.name,
                style = MaterialTheme.typography.h6
            )
            
            Text(
                text = "Balance: ${wallet.formattedBalance}",
                style = MaterialTheme.typography.body2,
                color = MaterialTheme.colors.onSurface.copy(alpha = 0.6f)
            )
            
            Chip(
                onClick = { },
                content = { Text(wallet.currency.name) }
            )
        }
    }
}

React Native SDK

Installation

npm install @buburuza/react-native
# iOS additional setup
cd ios && pod install

Quick Start

import { BuburuざAPI } from '@buburuza/react-native';
import { useBuburuざWallets } from '@buburuza/react-native/hooks';

// Initialize the SDK
const buburuza = new BuburuざAPI({
  apiKey: 'bb_test_1234567890abcdef',
  environment: 'sandbox'
});

// React Native component
function WalletScreen({ customerId }: { customerId: string }) {
  const { wallets, loading, error, refetch } = useBuburuざWallets(customerId);
  
  const handleTransfer = async (amount: number, toWalletId: string) => {
    try {
      await buburuza.transactions.create({
        type: 'transfer',
        fromWalletId: wallets[0].id,
        toWalletId,
        amount: amount * 100,
        currency: 'USD'
      });
      
      refetch();
      Alert.alert('Success', 'Transfer completed successfully');
    } catch (error) {
      Alert.alert('Error', error.message);
    }
  };

  if (loading) {
    return <ActivityIndicator size="large" />;
  }

  if (error) {
    return (
      <View style={styles.errorContainer}>
        <Text style={styles.errorText}>{error.message}</Text>
        <Button title="Retry" onPress={refetch} />
      </View>
    );
  }

  return (
    <FlatList
      data={wallets}
      renderItem={({ item: wallet }) => (
        <WalletCard 
          wallet={wallet} 
          onTransfer={handleTransfer}
        />
      )}
      keyExtractor={(wallet) => wallet.id}
    />
  );
}

Biometric Authentication

import { BiometricAuth } from '@buburuza/react-native';

async function authenticateWithBiometrics(userId: string) {
  try {
    // Check if biometrics are available
    const isAvailable = await BiometricAuth.isAvailable();
    if (!isAvailable) {
      throw new Error('Biometric authentication not available');
    }
    
    // Authenticate with biometrics
    const result = await BiometricAuth.authenticate({
      reason: 'Authenticate to access your account',
      fallbackToPasscode: true
    });
    
    if (result.success) {
      // Verify with Buburuza
      const authResult = await buburuza.auth.biometric.verify({
        userId,
        signature: result.signature,
        biometricType: result.biometricType
      });
      
      return authResult;
    }
  } catch (error) {
    console.error('Biometric authentication failed:', error);
    throw error;
  }
}

Error Handling

Standardized Error Handling

All SDKs provide consistent error handling with detailed error information.

// JavaScript/TypeScript
try {
  const transaction = await buburuza.transactions.create(request);
} catch (error) {
  if (error instanceof BuburuざError) {
    switch (error.code) {
      case 'insufficient_funds':
        console.log('Account balance too low');
        break;
      case 'invalid_recipient':
        console.log('Recipient account not found');
        break;
      case 'rate_limit_exceeded':
        console.log('Too many requests, please try again later');
        break;
      default:
        console.log('Unexpected error:', error.message);
    }
  }
}

# Python
from buburuza.exceptions import BuburuざError, InsufficientFundsError

try:
    transaction = buburuza.transactions.create(request)
except InsufficientFundsError as e:
    print(f"Insufficient funds: {e.available_balance}")
except BuburuざError as e:
    print(f"API Error: {e.message} (Code: {e.code})")

// Java
try {
    Transaction transaction = buburuza.transactions().create(request);
} catch (InsufficientFundsException e) {
    System.out.println("Insufficient funds: " + e.getAvailableBalance());
} catch (BuburuざException e) {
    System.out.println("API Error: " + e.getMessage() + " (Code: " + e.getCode() + ")");
}

Testing and Mocking

Mock SDK for Testing

All SDKs include mock implementations for testing.

// JavaScript/TypeScript
import { MockBuburuざAPI } from '@buburuza/sdk/testing';

const mockBuburuza = new MockBuburuざAPI();

// Configure mock responses
mockBuburuza.transactions.create.mockResolvedValue({
  id: 'txn_mock_123',
  status: 'completed',
  amount: 5000,
  currency: 'USD'
});

// Use in tests
test('should create transaction', async () => {
  const result = await mockBuburuza.transactions.create({
    type: 'transfer',
    amount: 5000,
    currency: 'USD'
  });
  
  expect(result.id).toBe('txn_mock_123');
});

# Python
from buburuza.testing import MockBuburuざAPI

mock_buburuza = MockBuburuざAPI()

# Configure mock responses
mock_buburuza.transactions.create.return_value = Transaction(
    id='txn_mock_123',
    status='completed',
    amount=5000,
    currency='USD'
)

# Use in tests
def test_create_transaction():
    result = mock_buburuza.transactions.create(request)
    assert result.id == 'txn_mock_123'

Configuration and Environment Management

Environment Configuration

// Development
const devBuburuza = new BuburuざAPI({
  apiKey: process.env.BUBURUZA_TEST_API_KEY,
  environment: 'sandbox',
  debug: true,
  timeout: 30000
});

// Production
const prodBuburuza = new BuburuざAPI({
  apiKey: process.env.BUBURUZA_LIVE_API_KEY,
  environment: 'production',
  retryConfig: {
    maxRetries: 3,
    backoffMultiplier: 1.5
  }
});

// Custom endpoint
const customBuburuza = new BuburuざAPI({
  apiKey: 'your_api_key',
  baseUrl: 'https://api.custom.buburuza.com',
  version: 'v2'
});

Performance Optimization

Connection Pooling and Caching

// Enable connection pooling and caching
const buburuza = new BuburuざAPI({
  apiKey: 'your_api_key',
  environment: 'production',
  httpConfig: {
    keepAlive: true,
    maxSockets: 10,
    timeout: 30000
  },
  caching: {
    enabled: true,
    ttl: 300, // 5 minutes
    maxSize: 1000 // Max 1000 cached responses
  }
});

// Batch operations for better performance
const batchResults = await buburuza.batch([
  { method: 'customers.get', params: { id: 'cust_123' } },
  { method: 'wallets.list', params: { customerId: 'cust_123' } },
  { method: 'transactions.list', params: { walletId: 'wallet_456' } }
]);

Support and Documentation

For SDK-specific support, join our developer community or contact [email protected].

PreviousAi-Services API NextQ4 2025: Foundation Established

Last updated 3 months ago

hashtagSDKs and Libraries

hashtagOverview

hashtagJavaScript/TypeScript SDK

hashtagInstallation

hashtagQuick Start

hashtagTypeScript Support

hashtagReact Hooks

hashtagAI Services Integration

hashtagPython SDK

hashtagInstallation

hashtagQuick Start

hashtagAsync Support

hashtagDjango Integration

hashtagJava SDK

hashtagInstallation

hashtagQuick Start

hashtagSpring Boot Integration

hashtagiOS Swift SDK

hashtagInstallation

hashtagQuick Start

hashtagSwiftUI Integration

hashtagBiometric Authentication

hashtagAndroid Kotlin SDK

hashtagInstallation

hashtagQuick Start

hashtagJetpack Compose Integration

hashtagReact Native SDK

hashtagInstallation

hashtagQuick Start

hashtagBiometric Authentication

hashtagError Handling

hashtagStandardized Error Handling

hashtagTesting and Mocking

hashtagMock SDK for Testing

hashtagConfiguration and Environment Management

hashtagEnvironment Configuration

hashtagPerformance Optimization

hashtagConnection Pooling and Caching

hashtagSupport and Documentation

SDKs and Libraries

Overview

JavaScript/TypeScript SDK

Installation

Quick Start

TypeScript Support

React Hooks

AI Services Integration

Python SDK

Installation

Quick Start

Async Support

Django Integration

Java SDK

Installation

Quick Start

Spring Boot Integration

iOS Swift SDK

Installation

Quick Start

SwiftUI Integration

Biometric Authentication

Android Kotlin SDK

Installation

Quick Start

Jetpack Compose Integration

React Native SDK

Installation

Quick Start

Biometric Authentication

Error Handling

Standardized Error Handling

Testing and Mocking

Mock SDK for Testing

Configuration and Environment Management

Environment Configuration

Performance Optimization

Connection Pooling and Caching

Support and Documentation