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: '[phone]'
});

// 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='[phone]'
)

# 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("[phone]")
                .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: "[phone]"
        )
        
        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 = "[phone]"
        )
        
        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].