blaaiz-nodejs-sdk 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Blaaiz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,630 @@
+# Blaaiz Node.js SDK
+
+A comprehensive Node.js SDK for the Blaaiz RaaS (Remittance as a Service) API. This SDK provides easy-to-use methods for payment processing, collections, payouts, customer management, and more.
+
+## Installation
+
+```bash
+npm install blaaiz-nodejs-sdk
+```
+
+## Quick Start
+
+```javascript
+const { Blaaiz } = require('blaaiz-nodejs-sdk');
+
+// Initialize the SDK
+const blaaiz = new Blaaiz('your-api-key-here', {
+  baseURL: 'https://api-dev.blaaiz.com', // Optional: defaults to dev environment
+  timeout: 30000 // Optional: request timeout in milliseconds
+});
+
+// Test the connection
+const isConnected = await blaaiz.testConnection();
+console.log('API Connected:', isConnected);
+```
+
+## Features
+
+- **Customer Management**: Create, update, and manage customers with KYC verification
+- **Collections**: Support for multiple collection methods (Open Banking, Card, Crypto, Bank Transfer)
+- **Payouts**: Bank transfers and Interac payouts across multiple currencies
+- **Virtual Bank Accounts**: Create and manage virtual accounts for NGN collections
+- **Wallets**: Multi-currency wallet management
+- **Transactions**: Transaction history and status tracking
+- **Webhooks**: Webhook configuration and management
+- **Files**: Document upload with pre-signed URLs
+- **Fees**: Real-time fee calculations and breakdowns
+- **Banks & Currencies**: Access to supported banks and currencies
+
+## Supported Currencies & Methods
+
+### Collections
+- **CAD**: Interac (push mechanism)
+- **NGN**: Bank Transfer (VBA) and Card Payment
+- **USD**: Card Payment
+- **EUR/GBP**: Open Banking
+
+### Payouts
+- **Bank Transfer**: All supported currencies
+- **Interac**: CAD transactions
+
+## API Reference
+
+### Customer Management
+
+#### Create a Customer
+
+```javascript
+const customer = await blaaiz.customers.create({
+  first_name: "John",
+  last_name: "Doe",
+  type: "individual", // or "business"
+  email: "john.doe@example.com",
+  country: "NG",
+  id_type: "passport", // drivers_license, passport, id_card, resident_permit
+  id_number: "A12345678",
+  // business_name: "Company Name" // Required if type is "business"
+});
+
+console.log('Customer ID:', customer.data.data.id);
+```
+
+#### Get Customer
+
+```javascript
+const customer = await blaaiz.customers.get('customer-id');
+console.log('Customer:', customer.data);
+```
+
+#### List All Customers
+
+```javascript
+const customers = await blaaiz.customers.list();
+console.log('Customers:', customers.data);
+```
+
+#### Update Customer
+
+```javascript
+const updatedCustomer = await blaaiz.customers.update('customer-id', {
+  first_name: "Jane",
+  email: "jane.doe@example.com"
+});
+```
+
+### File Management & KYC
+
+#### Upload Customer Documents
+
+**Method 1: Complete File Upload (Recommended)**
+```javascript
+// Option A: Upload from Buffer
+const result = await blaaiz.customers.uploadFileComplete('customer-id', {
+  file: fileBuffer, // Buffer or Uint8Array
+  file_category: 'identity', // identity, proof_of_address, liveness_check
+  filename: 'passport.jpg', // Optional
+  contentType: 'image/jpeg' // Optional
+});
+
+// Option B: Upload from Base64 string
+const result = await blaaiz.customers.uploadFileComplete('customer-id', {
+  file: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
+  file_category: 'identity'
+});
+
+// Option C: Upload from Data URL (with automatic content type detection)
+const result = await blaaiz.customers.uploadFileComplete('customer-id', {
+  file: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
+  file_category: 'identity'
+});
+
+// Option D: Upload from Public URL (automatically downloads and uploads)
+const result = await blaaiz.customers.uploadFileComplete('customer-id', {
+  file: 'https://example.com/documents/passport.jpg',
+  file_category: 'identity'
+});
+
+console.log('Upload complete:', result.data);
+console.log('File ID:', result.file_id);
+```
+
+**Method 2: Manual 3-Step Process**
+```javascript
+// Step 1: Get pre-signed URL
+const presignedUrl = await blaaiz.files.getPresignedUrl({
+  customer_id: 'customer-id',
+  file_category: 'identity' // identity, proof_of_address, liveness_check
+});
+
+// Step 2: Upload file to the pre-signed URL (implement your file upload logic)
+// const uploadResponse = await uploadFileToUrl(presignedUrl.data.url, fileBuffer);
+
+// Step 3: Associate file with customer
+const fileAssociation = await blaaiz.customers.uploadFiles('customer-id', {
+  id_file: presignedUrl.data.file_id // Use the file_id from step 1
+});
+```
+
+> **Note**: The `uploadFileComplete` method is recommended as it handles all three steps automatically: getting the pre-signed URL, uploading the file to S3, and associating the file with the customer. It supports multiple file input formats:
+> - **Buffer/Uint8Array**: Direct binary data
+> - **Base64 string**: Plain base64 encoded data
+> - **Data URL**: Complete data URL with mime type (e.g., `data:image/jpeg;base64,/9j/4AAQ...`)
+> - **Public URL**: HTTP/HTTPS URL that will be downloaded automatically (supports redirects, content-type detection, and filename extraction)
+
+### Collections
+
+#### Initiate Open Banking Collection (EUR/GBP)
+
+```javascript
+const collection = await blaaiz.collections.initiate({
+  method: "open_banking",
+  amount: 100.00,
+  customer_id: "customer-id",
+  wallet_id: "wallet-id",
+  phone: "+1234567890" // Optional
+});
+
+console.log('Payment URL:', collection.data.url);
+console.log('Transaction ID:', collection.data.transaction_id);
+```
+
+#### Initiate Card Collection (NGN/USD)
+
+```javascript
+const collection = await blaaiz.collections.initiate({
+  method: "card",
+  amount: 5000,
+  customer_id: "customer-id",
+  wallet_id: "wallet-id"
+});
+
+console.log('Payment URL:', collection.data.url);
+```
+
+#### Crypto Collection
+
+```javascript
+// Get available networks
+const networks = await blaaiz.collections.getCryptoNetworks();
+console.log('Available networks:', networks.data);
+
+// Initiate crypto collection
+const cryptoCollection = await blaaiz.collections.initiateCrypto({
+  amount: 100,
+  network: "ethereum",
+  token: "USDT",
+  wallet_id: "wallet-id"
+});
+```
+
+#### Attach Customer to Collection
+
+```javascript
+const attachment = await blaaiz.collections.attachCustomer({
+  customer_id: "customer-id",
+  transaction_id: "transaction-id"
+});
+```
+
+### Payouts
+
+#### Bank Transfer Payout
+
+```javascript
+const payout = await blaaiz.payouts.initiate({
+  wallet_id: "wallet-id",
+  customer_id: "customer-id",
+  method: "bank_transfer",
+  from_amount: 1000,
+  from_currency_id: "1", // NGN
+  to_currency_id: "1", // NGN
+  account_number: "0123456789",
+  bank_id: "1", // Required for NGN
+  phone_number: "+2348012345678"
+});
+
+console.log('Payout Status:', payout.data.transaction.status);
+```
+
+#### Interac Payout (CAD)
+
+```javascript
+const interacPayout = await blaaiz.payouts.initiate({
+  wallet_id: "wallet-id",
+  customer_id: "customer-id",
+  method: "interac",
+  from_amount: 100,
+  from_currency_id: "2", // CAD
+  to_currency_id: "2", // CAD
+  email: "recipient@example.com",
+  interac_first_name: "John",
+  interac_last_name: "Doe"
+});
+```
+
+### Virtual Bank Accounts
+
+#### Create Virtual Bank Account
+
+```javascript
+const vba = await blaaiz.virtualBankAccounts.create({
+  wallet_id: "wallet-id",
+  account_name: "John Doe"
+});
+
+console.log('Account Number:', vba.data.account_number);
+console.log('Bank Name:', vba.data.bank_name);
+```
+
+#### List Virtual Bank Accounts
+
+```javascript
+const vbas = await blaaiz.virtualBankAccounts.list("wallet-id");
+console.log('Virtual Accounts:', vbas.data);
+```
+
+### Wallets
+
+#### List All Wallets
+
+```javascript
+const wallets = await blaaiz.wallets.list();
+console.log('Wallets:', wallets.data);
+```
+
+#### Get Specific Wallet
+
+```javascript
+const wallet = await blaaiz.wallets.get("wallet-id");
+console.log('Wallet Balance:', wallet.data.balance);
+```
+
+### Transactions
+
+#### List Transactions
+
+```javascript
+const transactions = await blaaiz.transactions.list({
+  page: 1,
+  limit: 10,
+  status: "SUCCESSFUL" // Optional filter
+});
+
+console.log('Transactions:', transactions.data);
+```
+
+#### Get Transaction Details
+
+```javascript
+const transaction = await blaaiz.transactions.get("transaction-id");
+console.log('Transaction:', transaction.data);
+```
+
+### Banks & Currencies
+
+#### List Banks
+
+```javascript
+const banks = await blaaiz.banks.list();
+console.log('Available Banks:', banks.data);
+```
+
+#### Bank Account Lookup
+
+```javascript
+const accountInfo = await blaaiz.banks.lookupAccount({
+  account_number: "0123456789",
+  bank_id: "1"
+});
+
+console.log('Account Name:', accountInfo.data.account_name);
+```
+
+#### List Currencies
+
+```javascript
+const currencies = await blaaiz.currencies.list();
+console.log('Supported Currencies:', currencies.data);
+```
+
+### Fees
+
+#### Get Fee Breakdown
+
+```javascript
+const feeBreakdown = await blaaiz.fees.getBreakdown({
+  from_currency_id: "1", // NGN
+  to_currency_id: "2", // CAD
+  from_amount: 100000
+});
+
+console.log('You send:', feeBreakdown.data.you_send);
+console.log('Recipient gets:', feeBreakdown.data.recipient_gets);
+console.log('Total fees:', feeBreakdown.data.total_fees);
+```
+
+### Webhooks
+
+#### Register Webhooks
+
+```javascript
+const webhook = await blaaiz.webhooks.register({
+  collection_url: "https://your-domain.com/webhooks/collection",
+  payout_url: "https://your-domain.com/webhooks/payout"
+});
+```
+
+#### Get Webhook Configuration
+
+```javascript
+const webhookConfig = await blaaiz.webhooks.get();
+console.log('Webhook URLs:', webhookConfig.data);
+```
+
+#### Replay Webhook
+
+```javascript
+const replay = await blaaiz.webhooks.replay({
+  transaction_id: "transaction-id"
+});
+```
+
+## Advanced Usage
+
+### Complete Payout Workflow
+
+```javascript
+const completePayoutResult = await blaaiz.createCompleteePayout({
+  customerData: {
+    first_name: "John",
+    last_name: "Doe",
+    type: "individual",
+    email: "john@example.com",
+    country: "NG",
+    id_type: "passport",
+    id_number: "A12345678"
+  },
+  payoutData: {
+    wallet_id: "wallet-id",
+    method: "bank_transfer",
+    from_amount: 1000,
+    from_currency_id: "1",
+    to_currency_id: "1",
+    account_number: "0123456789",
+    bank_id: "1",
+    phone_number: "+2348012345678"
+  }
+});
+
+console.log('Customer ID:', completePayoutResult.customer_id);
+console.log('Payout:', completePayoutResult.payout);
+console.log('Fees:', completePayoutResult.fees);
+```
+
+### Complete Collection Workflow
+
+```javascript
+const completeCollectionResult = await blaaiz.createCompleteCollection({
+  customerData: {
+    first_name: "Jane",
+    last_name: "Smith",
+    type: "individual",
+    email: "jane@example.com",
+    country: "NG",
+    id_type: "drivers_license",
+    id_number: "ABC123456"
+  },
+  collectionData: {
+    method: "card",
+    amount: 5000,
+    wallet_id: "wallet-id"
+  },
+  createVBA: true // Optionally create a virtual bank account
+});
+
+console.log('Customer ID:', completeCollectionResult.customer_id);
+console.log('Collection:', completeCollectionResult.collection);
+console.log('Virtual Account:', completeCollectionResult.virtual_account);
+```
+
+## Error Handling
+
+The SDK uses a custom `BlaaizError` class that provides detailed error information:
+
+```javascript
+try {
+  const customer = await blaaiz.customers.create(invalidData);
+} catch (error) {
+  if (error instanceof BlaaizError) {
+    console.error('Blaaiz API Error:', error.message);
+    console.error('Status Code:', error.status);
+    console.error('Error Code:', error.code);
+  } else {
+    console.error('Unexpected Error:', error.message);
+  }
+}
+```
+
+## Rate Limiting
+
+The Blaaiz API has a rate limit of 100 requests per minute. The SDK automatically includes rate limit headers in responses:
+
+- `X-RateLimit-Limit`: Maximum requests per minute
+- `X-RateLimit-Remaining`: Remaining requests in current window
+- `X-RateLimit-Reset`: When the rate limit resets
+
+## Webhook Handling
+
+### Webhook Signature Verification
+
+The SDK provides built-in webhook signature verification to ensure webhook authenticity:
+
+```javascript
+const { Blaaiz } = require('blaaiz-nodejs-sdk');
+
+const blaaiz = new Blaaiz('your-api-key');
+
+// Method 1: Verify signature manually
+const isValid = blaaiz.webhooks.verifySignature(
+  payload,        // Raw webhook payload (string or object)
+  signature,      // Signature from webhook headers
+  webhookSecret   // Your webhook secret key
+);
+
+if (isValid) {
+  console.log('Webhook signature is valid');
+} else {
+  console.log('Invalid webhook signature');
+}
+
+// Method 2: Construct verified event (recommended)
+try {
+  const event = blaaiz.webhooks.constructEvent(
+    payload,        // Raw webhook payload
+    signature,      // Signature from webhook headers  
+    webhookSecret   // Your webhook secret key
+  );
+  
+  console.log('Verified event:', event);
+  // event.verified will be true
+  // event.timestamp will contain verification timestamp
+} catch (error) {
+  console.error('Webhook verification failed:', error.message);
+}
+```
+
+### Complete Express.js Webhook Handler
+
+```javascript
+const express = require('express');
+const { Blaaiz } = require('blaaiz-nodejs-sdk');
+
+const app = express();
+const blaaiz = new Blaaiz('your-api-key');
+
+// Webhook secret (get this from your Blaaiz dashboard)
+const WEBHOOK_SECRET = process.env.BLAAIZ_WEBHOOK_SECRET;
+
+// Middleware to capture raw body for signature verification
+app.use('/webhooks', express.raw({ type: 'application/json' }));
+
+// Collection webhook with signature verification
+app.post('/webhooks/collection', (req, res) => {
+  const signature = req.headers['x-blaaiz-signature'];
+  const payload = req.body.toString();
+  
+  try {
+    // Verify webhook signature and construct event
+    const event = blaaiz.webhooks.constructEvent(payload, signature, WEBHOOK_SECRET);
+    
+    console.log('Verified collection event:', {
+      transaction_id: event.transaction_id,
+      status: event.status,
+      amount: event.amount,
+      currency: event.currency,
+      verified: event.verified
+    });
+    
+    // Process the collection
+    // Update your database, send notifications, etc.
+    
+    res.status(200).json({ received: true });
+  } catch (error) {
+    console.error('Webhook verification failed:', error.message);
+    res.status(400).json({ error: 'Invalid signature' });
+  }
+});
+
+// Payout webhook with signature verification
+app.post('/webhooks/payout', (req, res) => {
+  const signature = req.headers['x-blaaiz-signature'];
+  const payload = req.body.toString();
+  
+  try {
+    // Verify webhook signature and construct event
+    const event = blaaiz.webhooks.constructEvent(payload, signature, WEBHOOK_SECRET);
+    
+    console.log('Verified payout event:', {
+      transaction_id: event.transaction_id,
+      status: event.status,
+      recipient: event.recipient,
+      verified: event.verified
+    });
+    
+    // Process the payout completion
+    // Update your database, send notifications, etc.
+    
+    res.status(200).json({ received: true });
+  } catch (error) {
+    console.error('Webhook verification failed:', error.message);
+    res.status(400).json({ error: 'Invalid signature' });
+  }
+});
+
+app.listen(3000, () => {
+  console.log('Webhook server running on port 3000');
+});
+```
+
+### Manual Signature Verification (Alternative)
+
+If you prefer manual verification:
+
+```javascript
+app.post('/webhooks/collection', (req, res) => {
+  const signature = req.headers['x-blaaiz-signature'];
+  const payload = req.body.toString();
+  
+  // Verify signature manually
+  const isValid = blaaiz.webhooks.verifySignature(payload, signature, WEBHOOK_SECRET);
+  
+  if (!isValid) {
+    console.error('Invalid webhook signature');
+    return res.status(400).json({ error: 'Invalid signature' });
+  }
+  
+  // Parse payload manually
+  const event = JSON.parse(payload);
+  console.log('Collection received:', event);
+  
+  res.status(200).json({ received: true });
+});
+```
+
+## Environment Configuration
+
+```javascript
+// Development
+const blaaizDev = new Blaaiz('dev-api-key', {
+  baseURL: 'https://api-dev.blaaiz.com'
+});
+
+// Production (when available)
+const blaaizProd = new Blaaiz('prod-api-key', {
+  baseURL: 'https://api.blaaiz.com'
+});
+```
+
+## Best Practices
+
+1. **Always validate customer data before creating customers**
+2. **Use the fees API to calculate and display fees to users**
+3. **Always verify webhook signatures using the SDK's built-in methods**
+4. **Store customer IDs and transaction IDs for tracking**
+5. **Handle rate limiting gracefully with exponential backoff**
+6. **Use environment variables for API keys and webhook secrets**
+7. **Implement proper error handling and logging**
+8. **Test webhook endpoints thoroughly with signature verification**
+9. **Use raw body parsing for webhook endpoints to preserve signature integrity**
+10. **Return appropriate HTTP status codes from webhook handlers (200 for success, 400 for invalid signatures)**
+
+## Support
+
+For support and additional documentation:
+- Email: onboarding@blaaiz.com
+- Documentation: https://docs.business.blaaiz.com
+
+## License
+
+This SDK is provided under the MIT License

package/index.d.ts

@@ -0,0 +1,354 @@
+// Type definitions for blaaiz-nodejs-sdk
+// Project: https://github.com/blaaiz/nodejs-sdk
+// Definitions by: Blaaiz Team
+
+export interface BlaaizOptions {
+  baseURL?: string;
+  timeout?: number;
+}
+
+export interface BlaaizResponse<T = any> {
+  data: T;
+  status: number;
+  headers: { [key: string]: string };
+}
+
+export class BlaaizError extends Error {
+  public status: number | null;
+  public code: string;
+  
+  constructor(message: string, status?: number | null, code?: string);
+}
+
+// Customer Types
+export interface CustomerData {
+  first_name: string;
+  last_name: string;
+  business_name?: string;
+  type: 'individual' | 'business';
+  email: string;
+  country: string;
+  id_type: 'drivers_license' | 'passport' | 'id_card' | 'resident_permit' | 'certificate_of_incorporation';
+  id_number: string;
+}
+
+export interface Customer extends CustomerData {
+  id: string;
+  business_id: string;
+  verification_status: 'PENDING' | 'VERIFIED' | 'REJECTED';
+}
+
+export interface CustomerKYCData {
+  [key: string]: any;
+}
+
+export interface CustomerFileData {
+  id_file?: string;
+  proof_of_address_file?: string;
+  liveness_check_file?: string;
+}
+
+export interface FileUploadOptions {
+  file: Buffer | Uint8Array | string;
+  file_category: 'identity' | 'proof_of_address' | 'liveness_check';
+  filename?: string;
+  contentType?: string;
+}
+
+// Collection Types
+export interface CollectionData {
+  method: 'open_banking' | 'card' | 'bank_transfer' | 'crypto';
+  amount: number;
+  customer_id?: string;
+  wallet_id: string;
+  phone?: string;
+}
+
+export interface CryptoCollectionData {
+  amount: number;
+  network: string;
+  token: string;
+  wallet_id: string;
+  customer_id?: string;
+}
+
+export interface CollectionResponse {
+  message: string;
+  transaction_id: string;
+  url?: string;
+}
+
+export interface AttachCustomerData {
+  customer_id: string;
+  transaction_id: string;
+}
+
+// Payout Types
+export interface PayoutData {
+  wallet_id: string;
+  customer_id?: string;
+  method: 'bank_transfer' | 'interac';
+  from_amount: number;
+  to_amount?: number;
+  phone_number?: string;
+  from_currency_id: string;
+  to_currency_id: string;
+  account_number?: string;
+  bank_id?: string;
+  email?: string;
+  interac_first_name?: string;
+  interac_last_name?: string;
+  wallet_address?: string;
+  wallet_network?: string;
+  wallet_token?: string;
+}
+
+export interface PayoutResponse {
+  message: string;
+  transaction: Transaction;
+}
+
+// Transaction Types
+export interface Transaction {
+  id: string;
+  business_id: string;
+  business_customer_id: string;
+  business_wallet_id: string;
+  status: 'PENDING' | 'SUCCESSFUL' | 'FAILED' | 'CANCELLED';
+  reference: string;
+  currency: string;
+  amount: number;
+  amount_without_fee: number;
+  fee: number;
+  rate: number;
+  date: string;
+  recipient?: {
+    id: string;
+    account_number: string;
+    account_name: string;
+    amount: number;
+    currency: string;
+    bank_name: string;
+    bank_code: string;
+  };
+}
+
+export interface TransactionFilters {
+  page?: number;
+  limit?: number;
+  status?: string;
+  currency?: string;
+  type?: 'COLLECTION' | 'PAYOUT';
+}
+
+// Wallet Types
+export interface Wallet {
+  id: string;
+  currency: string;
+  balance: number;
+  status: string;
+}
+
+// Virtual Bank Account Types
+export interface VirtualBankAccountData {
+  wallet_id: string;
+  account_name?: string;
+}
+
+export interface VirtualBankAccount {
+  id: string;
+  account_number: string;
+  account_name: string;
+  bank_name: string;
+  bank_code: string;
+  wallet_id: string;
+}
+
+// Bank Types
+export interface Bank {
+  id: string;
+  name: string;
+  code: string;
+  country: string;
+}
+
+export interface BankAccountLookupData {
+  account_number: string;
+  bank_id: string;
+}
+
+export interface BankAccountInfo {
+  account_name: string;
+  account_number: string;
+  bank_name: string;
+}
+
+// Currency Types
+export interface Currency {
+  id: string;
+  name: string;
+  code: string;
+  status: string;
+}
+
+// Fees Types
+export interface FeeBreakdownData {
+  from_currency_id: string;
+  to_currency_id: string;
+  from_amount: number;
+  to_amount?: number;
+}
+
+export interface FeeBreakdown {
+  you_send: number;
+  total_amount_to_send: number;
+  recipient_gets: number;
+  total_fees: number;
+  exchange_rate?: number;
+  collection_fees?: any[];
+  payout_fees?: any[];
+}
+
+// File Types
+export interface FileUploadData {
+  customer_id: string;
+  file_category: 'identity' | 'proof_of_address' | 'liveness_check';
+}
+
+export interface PreSignedUrlResponse {
+  url: string;
+  file_id: string;
+  headers: { [key: string]: string };
+}
+
+// Webhook Types
+export interface WebhookData {
+  collection_url: string;
+  payout_url: string;
+}
+
+export interface WebhookReplayData {
+  transaction_id: string;
+}
+
+export interface WebhookEvent {
+  [key: string]: any;
+  verified: boolean;
+  timestamp: string;
+}
+
+// Service Classes
+export declare class CustomerService {
+  constructor(client: any);
+  create(customerData: CustomerData): Promise<BlaaizResponse<{ data: Customer }>>;
+  list(): Promise<BlaaizResponse<Customer[]>>;
+  get(customerId: string): Promise<BlaaizResponse<Customer>>;
+  update(customerId: string, updateData: Partial<CustomerData>): Promise<BlaaizResponse<Customer>>;
+  addKYC(customerId: string, kycData: CustomerKYCData): Promise<BlaaizResponse<any>>;
+  uploadFiles(customerId: string, fileData: CustomerFileData): Promise<BlaaizResponse<any>>;
+  uploadFileComplete(customerId: string, fileOptions: FileUploadOptions): Promise<BlaaizResponse<any>>;
+}
+
+export declare class CollectionService {
+  constructor(client: any);
+  initiate(collectionData: CollectionData): Promise<BlaaizResponse<CollectionResponse>>;
+  initiateCrypto(cryptoData: CryptoCollectionData): Promise<BlaaizResponse<CollectionResponse>>;
+  attachCustomer(attachData: AttachCustomerData): Promise<BlaaizResponse<any>>;
+  getCryptoNetworks(): Promise<BlaaizResponse<any>>;
+}
+
+export declare class PayoutService {
+  constructor(client: any);
+  initiate(payoutData: PayoutData): Promise<BlaaizResponse<PayoutResponse>>;
+}
+
+export declare class WalletService {
+  constructor(client: any);
+  list(): Promise<BlaaizResponse<Wallet[]>>;
+  get(walletId: string): Promise<BlaaizResponse<Wallet>>;
+}
+
+export declare class VirtualBankAccountService {
+  constructor(client: any);
+  create(vbaData: VirtualBankAccountData): Promise<BlaaizResponse<VirtualBankAccount>>;
+  list(walletId?: string): Promise<BlaaizResponse<VirtualBankAccount[]>>;
+  get(vbaId: string): Promise<BlaaizResponse<VirtualBankAccount>>;
+}
+
+export declare class TransactionService {
+  constructor(client: any);
+  list(filters?: TransactionFilters): Promise<BlaaizResponse<Transaction[]>>;
+  get(transactionId: string): Promise<BlaaizResponse<Transaction>>;
+}
+
+export declare class BankService {
+  constructor(client: any);
+  list(): Promise<BlaaizResponse<Bank[]>>;
+  lookupAccount(lookupData: BankAccountLookupData): Promise<BlaaizResponse<BankAccountInfo>>;
+}
+
+export declare class CurrencyService {
+  constructor(client: any);
+  list(): Promise<BlaaizResponse<Currency[]>>;
+}
+
+export declare class FeesService {
+  constructor(client: any);
+  getBreakdown(feeData: FeeBreakdownData): Promise<BlaaizResponse<FeeBreakdown>>;
+}
+
+export declare class FileService {
+  constructor(client: any);
+  getPresignedUrl(fileData: FileUploadData): Promise<BlaaizResponse<PreSignedUrlResponse>>;
+}
+
+export declare class WebhookService {
+  constructor(client: any);
+  register(webhookData: WebhookData): Promise<BlaaizResponse<any>>;
+  get(): Promise<BlaaizResponse<WebhookData>>;
+  update(webhookData: Partial<WebhookData>): Promise<BlaaizResponse<any>>;
+  replay(replayData: WebhookReplayData): Promise<BlaaizResponse<any>>;
+  verifySignature(payload: string | object, signature: string, secret: string): boolean;
+  constructEvent(payload: string | object, signature: string, secret: string): WebhookEvent;
+}
+
+// Main SDK Class
+export declare class Blaaiz {
+  public customers: CustomerService;
+  public collections: CollectionService;
+  public payouts: PayoutService;
+  public wallets: WalletService;
+  public virtualBankAccounts: VirtualBankAccountService;
+  public transactions: TransactionService;
+  public banks: BankService;
+  public currencies: CurrencyService;
+  public fees: FeesService;
+  public files: FileService;
+  public webhooks: WebhookService;
+
+  constructor(apiKey: string, options?: BlaaizOptions);
+  
+  testConnection(): Promise<boolean>;
+  
+  createCompleteePayout(payoutConfig: {
+    customerData?: CustomerData;
+    payoutData: PayoutData;
+  }): Promise<{
+    customer_id: string;
+    payout: PayoutResponse;
+    fees: FeeBreakdown;
+  }>;
+  
+  createCompleteCollection(collectionConfig: {
+    customerData?: CustomerData;
+    collectionData: CollectionData;
+    createVBA?: boolean;
+  }): Promise<{
+    customer_id: string;
+    collection: CollectionResponse;
+    virtual_account?: VirtualBankAccount;
+  }>;
+}
+
+// Default export
+export default Blaaiz;

package/index.js

@@ -0,0 +1,2 @@
+module.exports = require('./src')
+module.exports.default = module.exports.Blaaiz

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "blaaiz-nodejs-sdk",
+  "version": "1.0.0",
+  "description": "Official Node.js SDK for Blaaiz RaaS (Remittance as a Service) API",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src/**/*.js",
+    "lint:fix": "eslint src/**/*.js --fix",
+    "docs": "jsdoc -d docs src/**/*.js",
+    "build": "npm run lint && npm test",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "blaaiz",
+    "payments",
+    "remittance",
+    "fintech",
+    "api",
+    "sdk",
+    "nodejs",
+    "payout",
+    "collection",
+    "raas",
+    "cryptocurrency",
+    "bank-transfer",
+    "interac",
+    "open-banking"
+  ],
+  "author": {
+    "name": "Blaaiz",
+    "email": "onboarding@blaaiz.com",
+    "url": "https://business.blaaiz.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/blaaiz/nodejs-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/blaaiz/nodejs-sdk/issues"
+  },
+  "homepage": "https://docs.business.blaaiz.com",
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.19.119",
+    "eslint": "^8.40.0",
+    "eslint-config-standard": "^17.0.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-n": "^15.7.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "jest": "^29.5.0",
+    "jsdoc": "^4.0.2"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}