@bloque/sdk 0.0.1 → 0.0.3

package/README.md

@@ -1,46 +1,67 @@
-# Bloque Payments SDK
+# Bloque SDK
 
-The official TypeScript/JavaScript SDK for integrating [Bloque](https://www.bloque.app) payments into your applications.
+The official TypeScript/JavaScript SDK for integrating [Bloque](https://www.bloque.app) into your applications.
 
 ## Features
 
 - **TypeScript First**: Built with TypeScript for complete type safety
-- **Simple API**: Intuitive interface for creating and managing checkouts
-- **Multiple Payment Methods**: Support for cards, PSE, and cash payments
+- **Simple API**: Intuitive interface for managing organizations, compliance, accounts, and identity
 - **Fully Async**: Promise-based API for modern JavaScript workflows
 - **Lightweight**: Minimal dependencies for optimal bundle size
+- **Modular**: Import only what you need with tree-shakeable exports
 
 ## Installation
 
 ```bash
-bun add @bloque/payments
+bun add @bloque/sdk
 ```
 
 ## Quick Start
 
 ```typescript
-import { Bloque, type PaymentSubmitPayload } from '@bloque/payments';
+import { SDK } from '@bloque/sdk';
+import type { CreateOrgParams } from '@bloque/sdk/orgs';
 
 // Initialize the SDK (server-side only)
-const bloque = new Bloque({
+const bloque = new SDK({
   apiKey: process.env.BLOQUE_API_KEY!,
-  server: 'production', // or 'sandbox' for testing
+  mode: 'production', // or 'sandbox' for testing
 });
 
-app.post('/api/payments', async (req, res) => {
-  try {
-    const payload: PaymentSubmitPayload = req.body;
+// Create an organization
+async function createOrganization() {
+  const params: CreateOrgParams = {
+    org_type: 'business',
+    profile: {
+      legal_name: 'Acme Corporation',
+      tax_id: '123456789',
+      incorporation_date: '2020-01-01',
+      business_type: 'llc',
+      incorporation_country_code: 'US',
+      incorporation_state: 'CA',
+      address_line1: '123 Main St',
+      postal_code: '12345',
+      city: 'San Francisco',
+    },
+    metadata: {
+      source: 'api',
+    },
+  };
 
-    // Create payment using SDK
-    const payment = await bloque.payments.create({
-      payment: payload,
-    });
+  const organization = await bloque.orgs.create(params);
+  console.log('Organization created:', organization);
+}
 
-    res.json({ success: true, payment });
-  } catch (error) {
-    res.status(500).json({ success: false, error: error.message });
-  }
-});
+// Create a virtual card
+async function createCard() {
+  const card = await bloque.accounts.card.create({
+    urn: 'did:bloque:user:123e4567',
+    name: 'My Virtual Card',
+  });
+
+  console.log('Card created:', card.urn);
+  console.log('Last four digits:', card.lastFour);
+}
 ```
 
 ## Configuration
@@ -48,366 +69,551 @@ app.post('/api/payments', async (req, res) => {
 ### Initialize the SDK
 
 ```typescript
-import { Bloque } from '@bloque/payments';
+import { SDK } from '@bloque/sdk';
+import type { BloqueConfig } from '@bloque/sdk';
 
-const bloque = new Bloque({
+const bloque = new SDK({
   apiKey: 'your-api-key-here',    // Required: Your Bloque API key
-  server: 'sandbox',               // Required: 'sandbox' or 'production'
+  mode: 'sandbox',                 // Required: 'sandbox' or 'production'
 });
 ```
 
-### Environment Options
+### Configuration Options
 
-- **`sandbox`**: For testing and development
-- **`production`**: For live payments
+- **`apiKey`** (string, required): Your Bloque API key
+- **`mode`** ('sandbox' | 'production', required): Environment mode
+  - `sandbox`: For testing and development
+  - `production`: For live operations
 
 ## API Reference
 
-### Payments
+### Organizations
 
-The payments resource allows you to create payments for existing checkout sessions.
+The organizations resource allows you to create and manage organizations in the Bloque platform.
 
-#### Create a Payment
+#### Create an Organization
 
 ```typescript
-const payment = await bloque.payments.create({
-  checkoutId: string;        // Required: Checkout ID from an existing checkout
-  payment: {
-    type: 'card' | 'pse' | 'cash',
-    data: {
-      // Payment method specific data
-    }
-  }
-});
+const organization = await bloque.orgs.create(params);
 ```
 
-**Payment Types**:
+**Parameters**:
 
-**Card Payment**:
 ```typescript
-{
-  type: 'card',
-  data: {
-    cardNumber: string;        // 16-digit card number
-    cardholderName: string;    // Name on the card
-    expiryMonth: string;       // MM format
-    expiryYear: string;        // YY or YYYY format
-    cvv: string;               // 3-4 digit CVV
-    email?: string;            // Optional customer email
-  }
+interface CreateOrgParams {
+  org_type: 'business' | 'individual';  // Organization type
+  profile: OrgProfile;                   // Organization profile details
+  metadata?: Record<string, unknown>;    // Optional custom metadata
+}
+
+interface OrgProfile {
+  legal_name: string;                    // Legal name of the organization
+  tax_id: string;                        // Tax ID number
+  incorporation_date: string;            // Date of incorporation (YYYY-MM-DD)
+  business_type: string;                 // Type of business (e.g., 'llc', 'corporation')
+  incorporation_country_code: string;    // Country code (ISO 3166-1 alpha-2)
+  incorporation_state?: string;          // State/province (optional)
+  address_line1: string;                 // Primary address line
+  address_line2?: string;                // Secondary address line (optional)
+  postal_code: string;                   // Postal/ZIP code
+  city: string;                          // City
+  logo_url?: string;                     // Logo URL (optional)
+  places?: Place[];                      // Additional places/locations (optional)
+}
+
+interface Place {
+  country_code: string;                  // Country code
+  state: string;                         // State/province
+  address_line1: string;                 // Address line 1
+  postal_code: string;                   // Postal code
+  city: string;                          // City
+  is_primary: boolean;                   // Whether this is the primary place
 }
 ```
 
-**PSE Payment** (Colombian online banking):
+**Response**:
+
 ```typescript
-{
-  type: 'pse',
-  data: {
-    personType: 'natural' | 'juridica';  // Person type
-    documentType: string;                 // Document type (e.g., 'CC', 'NIT')
-    documentNumber: string;               // Document number
-    bankCode: string;                     // Bank code
-    email: string;                        // Customer email
-  }
+interface Organization {
+  urn: string;                           // Unique resource name
+  org_type: 'business' | 'individual';   // Organization type
+  profile: OrgProfile;                   // Organization profile
+  metadata?: Record<string, unknown>;    // Custom metadata
+  status: OrgStatus;                     // Organization status
 }
+
+type OrgStatus =
+  | 'awaiting_compliance_verification'
+  | 'active'
+  | 'suspended'
+  | 'closed';
 ```
 
-**Cash Payment**:
+### Compliance
+
+The compliance resource provides KYC (Know Your Customer) verification functionality.
+
+#### Start KYC Verification
+
+Start a KYC verification process for a user:
+
 ```typescript
-{
-  type: 'cash',
-  data: {
-    email: string;            // Customer email
-    documentType: string;     // Document type
-    documentNumber: string;   // Document number
-    fullName: string;         // Full name
-  }
-}
+const verification = await bloque.compliance.kyc.startVerification({
+  urn: 'did:bloque:origin:user-id',
+});
 ```
 
-**Payment Response**:
+**Parameters**:
+
 ```typescript
-{
-  id: string;                       // Payment ID
-  object: 'payment';                // Object type
-  status: 'pending' | 'processing' | 'completed' | 'failed';
-  checkout: Checkout;               // Associated checkout
-  payment_method: 'card' | 'pse' | 'cash';
-  amount: number;                   // Payment amount
-  currency: string;                 // Currency
-  created_at: string;               // Creation timestamp
-  updated_at: string;               // Last update timestamp
+interface KycVerificationParams {
+  /**
+   * URN (Uniform Resource Name) that uniquely identifies the user
+   * within the system. This value is used to associate the KYC
+   * verification process with a specific user.
+   *
+   * @example "did:bloque:origin:..."
+   */
+  urn: string;
+
+  /**
+   * URL where webhook notifications will be sent when the verification
+   * status changes (optional).
+   *
+   * @example "https://api.example.com/webhooks/kyc"
+   */
+  webhookUrl?: string;
 }
 ```
 
-### Checkout
+**Response**:
 
-The checkout resource allows you to create payment sessions.
+```typescript
+interface KycVerificationResponse {
+  url: string;  // URL where the user should complete the verification
+  status: 'awaiting_compliance_verification' | 'approved' | 'rejected';
+}
+```
+
+#### Get KYC Verification Status
 
-#### Create a Checkout
+Get the current status of a KYC verification:
 
 ```typescript
-const checkout = await bloque.checkout.create({
-  name: string;              // Required: Name of the checkout
-  description?: string;      // Optional: Description
-  image_url?: string;        // Optional: Product/checkout image URL
-  items: CheckoutItem[];     // Required: Items to be purchased
-  success_url: string;       // Required: Redirect URL after success
-  cancel_url: string;        // Required: Redirect URL after cancellation
-  metadata?: Record<string, string | number | boolean>; // Optional: Custom metadata
-  expires_at?: string;       // Optional: Expiration date (ISO 8601)
+const status = await bloque.compliance.kyc.getVerification({
+  urn: 'did:bloque:user:123e4567',
 });
 ```
 
-**Checkout Item**:
+**Parameters**:
+
 ```typescript
-{
-  name: string;        // Item name
-  amount: number;      // Price in smallest currency unit (e.g., cents)
-  quantity: number;    // Quantity
-  image_url?: string;  // Item image URL
+interface GetKycVerificationParams {
+  /**
+   * URN (Uniform Resource Name) that uniquely identifies the user
+   * within the system.
+   *
+   * @example "did:bloque:user:123e4567"
+   */
+  urn: string;
 }
 ```
 
-#### Checkout Response
+**Response**:
 
 ```typescript
-{
-  id: string;                // Unique checkout identifier
-  object: 'checkout';        // Object type
-  url: string;               // Public payment URL for the customer
-  status: string;            // Current checkout status
-  amount_total: number;      // Total amount
-  amount_subtotal: number;   // Subtotal amount
-  currency: 'USD';           // Currency
-  items: CheckoutItem[];     // Items in the checkout
-  metadata?: Metadata;       // Custom metadata
-  created_at: string;        // Creation timestamp (ISO 8601)
-  updated_at: string;        // Last update timestamp (ISO 8601)
-  expires_at: string;        // Expiration timestamp (ISO 8601)
+interface KycVerificationStatus {
+  status: 'awaiting_compliance_verification' | 'approved' | 'rejected';
+  url: string;                                  // URL for verification
+  completedAt: string | null;                               // Completion date (ISO 8601)
 }
 ```
 
-#### Retrieve a Checkout
+### Accounts
 
-Retrieve the details of an existing checkout by its ID.
+The accounts resource allows you to create virtual cards for users.
+
+#### Create a Virtual Card
+
+Create a virtual card for a user:
 
 ```typescript
-const checkout = await bloque.checkout.retrieve('checkout_id_here');
+const card = await bloque.accounts.card.create({
+  urn: 'did:bloque:user:123e4567',
+  name: 'My Virtual Card', // Optional
+});
 ```
 
 **Parameters**:
-- `checkoutId` (string): The ID of the checkout to retrieve
 
-**Returns**: A `Checkout` object with all the checkout details.
+```typescript
+interface CreateCardParams {
+  /**
+   * URN of the account holder (user or organization)
+   * @example "did:bloque:user:123e4567"
+   */
+  urn: string;
+
+  /**
+   * Display name for the card (optional)
+   */
+  name?: string;
+}
+```
+
+**Response**:
+
+```typescript
+interface CardAccount {
+  urn: string;                    // Unique resource name
+  id: string;                     // Card account ID
+  lastFour: string;               // Last four digits
+  productType: 'CREDIT' | 'DEBIT'; // Card product type
+  status: 'active' | 'disabled' | 'frozen' | 'deleted' | 'creation_in_progress' | 'creation_failed';
+  cardType: 'VIRTUAL' | 'PHYSICAL'; // Card type
+  detailsUrl: string;             // PCI-compliant URL to view card details
+  ownerUrn: string;               // Owner URN
+  webhookUrl: string | null;      // Webhook URL (if configured)
+  metadata?: Record<string, unknown>; // Custom metadata
+  createdAt: string;              // Creation timestamp (ISO 8601)
+  updatedAt: string;              // Last update timestamp (ISO 8601)
+}
+```
 
-#### Cancel a Checkout
+### Identity
 
-Cancel an existing checkout that hasn't been completed yet.
+The identity resource allows you to retrieve user aliases (alternative identifiers like email or phone).
+
+#### Get Alias
+
+Retrieve alias information by the alias value:
 
 ```typescript
-const checkout = await bloque.checkout.cancel('checkout_id_here');
+const alias = await bloque.identity.aliases.get('user@example.com');
 ```
 
 **Parameters**:
-- `checkoutId` (string): The ID of the checkout to cancel
 
-**Returns**: A `Checkout` object with updated status reflecting the cancellation.
+```typescript
+// Pass the alias string directly
+const alias: string = 'user@example.com' | '+1234567890';
+```
+
+**Response**:
+
+```typescript
+interface Alias {
+  id: string;                                  // Unique alias ID
+  alias: string;                               // Alias value
+  type: 'phone' | 'email' | string;           // Alias type
+  urn: string;                                 // Associated user URN
+  origin: string;                              // Origin identifier
+  details: {
+    phone?: string;                            // Phone details (if applicable)
+  };
+  metadata: {
+    alias: string;                             // Alias in metadata
+    [key: string]: unknown;                    // Additional metadata
+  };
+  status: 'active' | 'inactive' | 'revoked';  // Alias status
+  is_public: boolean;                          // Whether alias is public
+  is_primary: boolean;                         // Whether this is the primary alias
+  created_at: string;                          // Creation timestamp (ISO 8601)
+  updated_at: string;                          // Last update timestamp (ISO 8601)
+}
+```
 
 ## Examples
 
-### Processing Payments
+### Creating a Business Organization
 
 ```typescript
-import { Bloque, type PaymentSubmitPayload } from '@bloque/payments';
+import { SDK } from '@bloque/sdk';
+import type { CreateOrgParams } from '@bloque/sdk/orgs';
 
 // Initialize SDK with your API key
-const bloque = new Bloque({
+const bloque = new SDK({
   apiKey: process.env.BLOQUE_API_KEY!,
-  server: 'production',
+  mode: 'production',
 });
 
-// API endpoint handler
-app.post('/api/payments', async (req, res) => {
-  try {
-    // Receive payment data from frontend
-    const payload: PaymentSubmitPayload = req.body;
-
-    // Create payment using SDK
-    const payment = await bloque.payments.create({
-      payment: payload,
-    });
+// Create a business organization
+const params: CreateOrgParams = {
+  org_type: 'business',
+  profile: {
+    legal_name: 'Acme Corporation',
+    tax_id: '12-3456789',
+    incorporation_date: '2020-01-15',
+    business_type: 'llc',
+    incorporation_country_code: 'US',
+    incorporation_state: 'CA',
+    address_line1: '123 Market Street',
+    address_line2: 'Suite 400',
+    postal_code: '94103',
+    city: 'San Francisco',
+    logo_url: 'https://example.com/logo.png',
+  },
+  metadata: {
+    source: 'web_app',
+    campaign: 'q1_2024',
+  },
+};
 
-    res.json({ success: true, payment });
-  } catch (error) {
-    res.status(500).json({ success: false, error: error.message });
-  }
-});
+try {
+  const organization = await bloque.orgs.create(params);
+  console.log('Organization created:', organization.urn);
+  console.log('Status:', organization.status);
+} catch (error) {
+  console.error('Failed to create organization:', error);
+}
 ```
 
-### Payment Methods Examples
-
-#### Card Payment
+### Creating an Individual Organization
 
 ```typescript
-// Receive payload from frontend
-const cardPayment: PaymentSubmitPayload = req.body;
-// Example payload:
-// {
-//   type: 'card',
-//   data: {
-//     cardNumber: '4111111111111111',
-//     cardholderName: 'John Doe',
-//     expiryMonth: '12',
-//     expiryYear: '2025',
-//     cvv: '123',
-//     email: 'john@example.com'
-//   }
-// }
-
-const payment = await bloque.payments.create({
-  payment: cardPayment,
+import { SDK } from '@bloque/sdk';
+import type { CreateOrgParams } from '@bloque/sdk/orgs';
+
+const bloque = new SDK({
+  apiKey: process.env.BLOQUE_API_KEY!,
+  mode: 'sandbox',
 });
+
+const params: CreateOrgParams = {
+  org_type: 'individual',
+  profile: {
+    legal_name: 'John Doe',
+    tax_id: '123-45-6789',
+    incorporation_date: '1990-05-20',
+    business_type: 'sole_proprietorship',
+    incorporation_country_code: 'US',
+    address_line1: '456 Oak Avenue',
+    postal_code: '10001',
+    city: 'New York',
+  },
+};
+
+const organization = await bloque.orgs.create(params);
+console.log('Individual organization created:', organization);
 ```
 
-#### PSE Payment (Colombian online banking)
+### Organization with Multiple Locations
 
 ```typescript
-// Receive payload from frontend
-const psePayment: PaymentSubmitPayload = req.body;
-// Example payload:
-// {
-//   type: 'pse',
-//   data: {
-//     personType: 'natural',
-//     documentType: 'CC',
-//     documentNumber: '1234567890',
-//     bankCode: '1022',
-//     email: 'maria@example.com'
-//   }
-// }
-
-const payment = await bloque.payments.create({
-  payment: psePayment,
+import { SDK } from '@bloque/sdk';
+import type { CreateOrgParams } from '@bloque/sdk/orgs';
+
+const bloque = new SDK({
+  apiKey: process.env.BLOQUE_API_KEY!,
+  mode: 'production',
 });
+
+const params: CreateOrgParams = {
+  org_type: 'business',
+  profile: {
+    legal_name: 'Global Tech Solutions Inc.',
+    tax_id: '98-7654321',
+    incorporation_date: '2018-03-10',
+    business_type: 'corporation',
+    incorporation_country_code: 'US',
+    incorporation_state: 'DE',
+    address_line1: '789 Corporate Blvd',
+    postal_code: '19801',
+    city: 'Wilmington',
+    places: [
+      {
+        country_code: 'US',
+        state: 'CA',
+        address_line1: '100 Silicon Valley Drive',
+        postal_code: '94025',
+        city: 'Menlo Park',
+        is_primary: true,
+      },
+      {
+        country_code: 'US',
+        state: 'NY',
+        address_line1: '250 Broadway',
+        postal_code: '10007',
+        city: 'New York',
+        is_primary: false,
+      },
+    ],
+  },
+};
+
+const organization = await bloque.orgs.create(params);
+console.log('Multi-location organization created');
 ```
 
-#### Cash Payment
+### Starting KYC Verification
 
 ```typescript
-// Receive payload from frontend
-const cashPayment: PaymentSubmitPayload = req.body;
-// Example payload:
-// {
-//   type: 'cash',
-//   data: {
-//     email: 'carlos@example.com',
-//     documentType: 'CC',
-//     documentNumber: '9876543210',
-//     fullName: 'Carlos García'
-//   }
-// }
-
-const payment = await bloque.payments.create({
-  payment: cashPayment,
+import { SDK } from '@bloque/sdk';
+import type { KycVerificationParams } from '@bloque/sdk/compliance';
+
+const bloque = new SDK({
+  apiKey: process.env.BLOQUE_API_KEY!,
+  mode: 'production',
 });
-```
 
-### Type-Safe Payment Creation
+// Start KYC verification for a user
+const params: KycVerificationParams = {
+  urn: 'did:bloque:origin:user-123',
+  webhookUrl: 'https://api.example.com/webhooks/kyc', // Optional webhook URL
+};
 
-The `PaymentSubmitPayload` type is a discriminated union that provides automatic type narrowing:
+try {
+  const verification = await bloque.compliance.kyc.startVerification(params);
+
+  console.log('Verification URL:', verification.url);
+  console.log('Status:', verification.status);
+
+  // Redirect the user to verification.url to complete KYC
+  // Webhook notifications will be sent to the provided webhookUrl
+} catch (error) {
+  console.error('Failed to start KYC verification:', error);
+}
+```
+
+### Getting KYC Verification Status
 
 ```typescript
-// Backend API handler
-async function handlePayment(payload: PaymentSubmitPayload) {
-  // TypeScript automatically narrows the type based on the 'type' field
-  switch (payload.type) {
-    case 'card':
-      // payload.data is CardPaymentFormData
-      console.log('Processing card ending in:', payload.data.cardNumber.slice(-4));
-      break;
-
-    case 'pse':
-      // payload.data is PSEPaymentFormData
-      console.log('Processing PSE for bank:', payload.data.bankCode);
-      break;
-
-    case 'cash':
-      // payload.data is CashPaymentFormData
-      console.log('Processing cash payment for:', payload.data.fullName);
-      break;
-  }
+import { SDK } from '@bloque/sdk';
+import type { GetKycVerificationParams } from '@bloque/sdk/compliance';
 
-  // Create payment using SDK
-  return await bloque.payments.create({
-    payment: payload,
-  });
+const bloque = new SDK({
+  apiKey: process.env.BLOQUE_API_KEY!,
+  mode: 'production',
+});
+
+// Get verification status
+const params: GetKycVerificationParams = {
+  urn: 'did:bloque:user:123e4567',
+};
+
+try {
+  const status = await bloque.compliance.kyc.getVerification(params);
+
+  console.log('Status:', status.status);
+  console.log('Verification URL:', status.url);
+  console.log('Completed At:', status.completedAt);
+
+  if (status.status === 'approved') {
+    console.log('User verification approved!');
+  } else if (status.status === 'rejected') {
+    console.log('User verification rejected');
+  } else {
+    console.log('Verification still pending');
+  }
+} catch (error) {
+  console.error('Failed to get verification status:', error);
 }
 ```
 
-### Basic Checkout with Single Item
+### Creating a Virtual Card
 
 ```typescript
-const checkout = await bloque.checkout.create({
-  name: 'E-book Purchase',
-  description: 'Learn TypeScript in 30 Days',
-  items: [
-    {
-      name: 'TypeScript E-book',
-      amount: 19_99,
-      quantity: 1,
-    },
-  ],
-  success_url: 'https://yourapp.com/success',
-  cancel_url: 'https://yourapp.com/cancel',
+import { SDK } from '@bloque/sdk';
+import type { CreateCardParams } from '@bloque/sdk/accounts';
+
+const bloque = new SDK({
+  apiKey: process.env.BLOQUE_API_KEY!,
+  mode: 'production',
 });
+
+// Create a virtual card
+const params: CreateCardParams = {
+  urn: 'did:bloque:user:123e4567',
+  name: 'My Business Card', // Optional
+};
+
+try {
+  const card = await bloque.accounts.card.create(params);
+
+  console.log('Card created:', card.urn);
+  console.log('Last four digits:', card.lastFour);
+  console.log('Card type:', card.cardType);
+  console.log('Status:', card.status);
+  console.log('Details URL:', card.detailsUrl);
+
+  // Check if card is ready to use
+  if (card.status === 'active') {
+    console.log('Card is active and ready to use!');
+  } else if (card.status === 'creation_in_progress') {
+    console.log('Card is being created...');
+  }
+} catch (error) {
+  console.error('Failed to create card:', error);
+}
 ```
 
-### Checkout with Multiple Items
+### Retrieving User Alias Information
 
 ```typescript
-const checkout = await bloque.checkout.create({
-  name: 'Shopping Cart',
-  description: 'Your selected items',
-  items: [
-    {
-      name: 'Wireless Mouse',
-      amount: 25_00,
-      quantity: 1,
-      image_url: 'https://example.com/mouse.jpg',
-    },
-    {
-      name: 'USB Cable',
-      amount: 10_00,
-      quantity: 2,
-      image_url: 'https://example.com/cable.jpg',
-    },
-  ],
-  success_url: 'https://yourapp.com/success',
-  cancel_url: 'https://yourapp.com/cancel',
+import { SDK } from '@bloque/sdk';
+
+const bloque = new SDK({
+  apiKey: process.env.BLOQUE_API_KEY!,
+  mode: 'production',
 });
+
+// Get alias information by email
+try {
+  const alias = await bloque.identity.aliases.get('user@example.com');
+
+  console.log('Alias ID:', alias.id);
+  console.log('Alias type:', alias.type);
+  console.log('Associated URN:', alias.urn);
+  console.log('Status:', alias.status);
+  console.log('Is primary:', alias.is_primary);
+  console.log('Is public:', alias.is_public);
+
+  if (alias.status === 'active') {
+    console.log('Alias is active');
+  }
+} catch (error) {
+  console.error('Failed to retrieve alias:', error);
+}
+
+// Get alias information by phone number
+try {
+  const phoneAlias = await bloque.identity.aliases.get('+1234567890');
+
+  console.log('Phone alias:', phoneAlias.alias);
+  console.log('Phone details:', phoneAlias.details.phone);
+} catch (error) {
+  console.error('Failed to retrieve phone alias:', error);
+}
 ```
 
-### Checkout with Metadata and Expiration
+### Using in an API Endpoint
 
 ```typescript
-const checkout = await bloque.checkout.create({
-  name: 'Limited Time Offer',
-  items: [
-    {
-      name: 'Premium Course',
-      amount: 99_00,
-      quantity: 1,
-    },
-  ],
-  success_url: 'https://yourapp.com/success',
-  cancel_url: 'https://yourapp.com/cancel',
-  metadata: {
-    user_id: '12345',
-    campaign: 'summer_sale',
-    discount_applied: true,
-  },
-  expires_at: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(), // 24 hours
+import { SDK } from '@bloque/sdk';
+import type { CreateOrgParams } from '@bloque/sdk/orgs';
+
+const bloque = new SDK({
+  apiKey: process.env.BLOQUE_API_KEY!,
+  mode: process.env.NODE_ENV === 'production' ? 'production' : 'sandbox',
+});
+
+app.post('/api/organizations', async (req, res) => {
+  try {
+    const params: CreateOrgParams = req.body;
+
+    const organization = await bloque.orgs.create(params);
+
+    res.json({
+      success: true,
+      organization,
+    });
+  } catch (error) {
+    console.error('Organization creation failed:', error);
+    res.status(500).json({
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
 });
 ```
 
@@ -417,15 +623,34 @@ const checkout = await bloque.checkout.create({
 The SDK uses standard JavaScript errors. Always wrap API calls in try-catch blocks:
 
 ```typescript
+import { SDK } from '@bloque/sdk';
+
+const bloque = new SDK({
+  apiKey: process.env.BLOQUE_API_KEY!,
+  mode: 'production',
+});
+
 try {
-  const checkout = await bloque.checkout.create({
-    name: 'Product',
-    items: [{ name: 'Item', amount: 1000, quantity: 1 }],
-    success_url: 'https://yourapp.com/success',
-    cancel_url: 'https://yourapp.com/cancel',
+  const organization = await bloque.orgs.create({
+    org_type: 'business',
+    profile: {
+      legal_name: 'Acme Corp',
+      tax_id: '123456789',
+      incorporation_date: '2020-01-01',
+      business_type: 'llc',
+      incorporation_country_code: 'US',
+      address_line1: '123 Main St',
+      postal_code: '12345',
+      city: 'San Francisco',
+    },
   });
+  console.log('Success:', organization);
 } catch (error) {
-  console.error('Failed to create checkout:', error);
+  if (error instanceof Error) {
+    console.error('Failed to create organization:', error.message);
+  } else {
+    console.error('Unknown error:', error);
+  }
 }
 ```
 
@@ -434,61 +659,89 @@ try {
 This SDK is written in TypeScript and includes complete type definitions. You'll get full autocomplete and type checking when using TypeScript or modern editors like VS Code:
 
 ```typescript
+import { SDK } from '@bloque/sdk';
 import type {
-  // Payment types
-  PaymentSubmitPayload,
-  PaymentResponse,
-  CreatePaymentParams,
-  // Checkout types
-  Checkout,
-  CheckoutStatus,
-  CheckoutItem,
-  CheckoutParams,
-} from '@bloque/payments';
-
-const item: CheckoutItem = {
-  name: 'Product',
-  amount: 5000,
-  quantity: 1,
+  BloqueConfig,
+  CreateOrgParams,
+  Organization,
+  OrgProfile,
+  OrgStatus,
+  OrgType,
+  Place,
+} from '@bloque/sdk/orgs';
+
+// Type-safe configuration
+const config: BloqueConfig = {
+  apiKey: 'your-api-key',
+  mode: 'sandbox',
 };
 
-// Type-safe payment data
-const cardPayment: PaymentSubmitPayload = {
-  type: 'card',
-  data: {
-    cardNumber: '4111111111111111',
-    cardholderName: 'John Doe',
-    expiryMonth: '12',
-    expiryYear: '2025',
-    cvv: '123',
+const bloque = new SDK(config);
+
+// Type-safe organization profile
+const profile: OrgProfile = {
+  legal_name: 'Tech Startup Inc.',
+  tax_id: '12-3456789',
+  incorporation_date: '2023-01-15',
+  business_type: 'llc',
+  incorporation_country_code: 'US',
+  incorporation_state: 'CA',
+  address_line1: '456 Innovation Dr',
+  postal_code: '94025',
+  city: 'Menlo Park',
+};
+
+// Type-safe organization creation
+const params: CreateOrgParams = {
+  org_type: 'business',
+  profile,
+  metadata: {
+    vertical: 'fintech',
+    employees: 50,
   },
 };
+
+// TypeScript infers the return type as Organization
+const org = await bloque.orgs.create(params);
 ```
 
-**Discriminated Union Types**:
+**Available Types**:
 
-The SDK uses TypeScript discriminated unions for payment types, which enables automatic type narrowing:
+The SDK exports all necessary types for type-safe development:
 
 ```typescript
-// Backend API handler
-async function handlePaymentFromFrontend(payment: PaymentSubmitPayload) {
-  switch (payment.type) {
-    case 'card':
-      // TypeScript knows payment.data is CardPaymentFormData
-      console.log('Card payment for:', payment.data.cardholderName);
-      break;
-    case 'pse':
-      // TypeScript knows payment.data is PSEPaymentFormData
-      console.log('PSE payment, bank:', payment.data.bankCode);
-      break;
-    case 'cash':
-      // TypeScript knows payment.data is CashPaymentFormData
-      console.log('Cash payment for:', payment.data.fullName);
-      break;
-  }
+// Main SDK types
+import type { SDK, BloqueConfig } from '@bloque/sdk';
 
-  return await bloque.payments.create({ payment });
-}
+// Organization types
+import type {
+  Organization,
+  CreateOrgParams,
+  CreateOrgResponse,
+  OrgProfile,
+  OrgType,
+  OrgStatus,
+  Place,
+} from '@bloque/sdk/orgs';
+
+// Compliance types
+import type {
+  KycVerificationParams,
+  KycVerificationResponse,
+  GetKycVerificationParams,
+  KycVerificationStatus,
+} from '@bloque/sdk/compliance';
+
+// Accounts types
+import type {
+  CardAccount,
+  CreateCardParams,
+} from '@bloque/sdk/accounts';
+
+// Identity types
+import type {
+  Alias,
+} from '@bloque/sdk/identity';
 ```
 
 ## Development
@@ -526,8 +779,19 @@ bun run check
 ## Links
 
 - [Homepage](https://www.bloque.app)
-- [GitHub Repository](git+https://github.com/bloque-app/bloque-payments.git)
-- [Issue Tracker](git+https://github.com/bloque-app/bloque-payments.git/issues)
+- [GitHub Repository](https://github.com/bloque-app/sdk)
+- [Issue Tracker](https://github.com/bloque-app/sdk/issues)
+
+## Package Structure
+
+This monorepo contains the following packages:
+
+- **`@bloque/sdk`**: Main SDK package
+- **`@bloque/sdk-core`**: Core utilities and HTTP client
+- **`@bloque/sdk-orgs`**: Organizations API client
+- **`@bloque/sdk-compliance`**: Compliance and KYC verification API client
+- **`@bloque/sdk-accounts`**: Accounts and virtual cards API client
+- **`@bloque/sdk-identity`**: Identity and aliases API client
 
 ## License
 

package/dist/accounts.d.ts

@@ -0,0 +1,3 @@
+export type { CardAccount, CreateCardParams, } from '@bloque/sdk-accounts';
+import { AccountsClient } from '@bloque/sdk-accounts';
+export declare const Accounts: AccountsClient;

package/dist/bloque.d.ts

@@ -0,0 +1,13 @@
+import { AccountsClient } from '@bloque/sdk-accounts';
+import { ComplianceClient } from '@bloque/sdk-compliance';
+import { type BloqueConfig } from '@bloque/sdk-core';
+import { IdentityClient } from '@bloque/sdk-identity';
+import { OrgsClient } from '@bloque/sdk-orgs';
+export declare class SDK {
+    private readonly httpClient;
+    readonly accounts: AccountsClient;
+    readonly compliance: ComplianceClient;
+    readonly identity: IdentityClient;
+    readonly orgs: OrgsClient;
+    constructor(config: BloqueConfig);
+}

package/dist/compliance.d.ts

@@ -0,0 +1,3 @@
+export type { GetKycVerificationParams, KycVerificationParams, KycVerificationResponse, } from '@bloque/sdk-compliance';
+import { ComplianceClient } from '@bloque/sdk-compliance';
+export declare const Compliance: ComplianceClient;

package/dist/config.d.ts

@@ -0,0 +1,3 @@
+import type { BloqueConfig } from '@bloque/sdk-core';
+export declare function setConfig(next: BloqueConfig): void;
+export declare function getConfig(): BloqueConfig;

package/dist/identity.d.ts

@@ -0,0 +1,3 @@
+export type { Alias } from '@bloque/sdk-identity';
+import { IdentityClient } from '@bloque/sdk-identity';
+export declare const Identity: IdentityClient;

package/dist/index.cjs

@@ -24,12 +24,30 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    sum: ()=>sum
+    SDK: ()=>SDK
 });
-const sum = (a, b)=>a + b;
-exports.sum = __webpack_exports__.sum;
+const sdk_accounts_namespaceObject = require("@bloque/sdk-accounts");
+const sdk_compliance_namespaceObject = require("@bloque/sdk-compliance");
+const sdk_core_namespaceObject = require("@bloque/sdk-core");
+const sdk_identity_namespaceObject = require("@bloque/sdk-identity");
+const sdk_orgs_namespaceObject = require("@bloque/sdk-orgs");
+class SDK {
+    httpClient;
+    accounts;
+    compliance;
+    identity;
+    orgs;
+    constructor(config){
+        this.httpClient = new sdk_core_namespaceObject.HttpClient(config);
+        this.accounts = new sdk_accounts_namespaceObject.AccountsClient(this.httpClient);
+        this.compliance = new sdk_compliance_namespaceObject.ComplianceClient(this.httpClient);
+        this.identity = new sdk_identity_namespaceObject.IdentityClient(this.httpClient);
+        this.orgs = new sdk_orgs_namespaceObject.OrgsClient(this.httpClient);
+    }
+}
+exports.SDK = __webpack_exports__.SDK;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "sum"
+    "SDK"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/index.d.ts

@@ -1 +1,2 @@
-export declare const sum: (a: number, b: number) => number;
+export { SDK } from './bloque';
+export type { BloqueConfig } from '@bloque/sdk-core';

package/dist/index.js

@@ -1,2 +1,20 @@
-const sum = (a, b)=>a + b;
-export { sum };
+import { AccountsClient } from "@bloque/sdk-accounts";
+import { ComplianceClient } from "@bloque/sdk-compliance";
+import { HttpClient } from "@bloque/sdk-core";
+import { IdentityClient } from "@bloque/sdk-identity";
+import { OrgsClient } from "@bloque/sdk-orgs";
+class SDK {
+    httpClient;
+    accounts;
+    compliance;
+    identity;
+    orgs;
+    constructor(config){
+        this.httpClient = new HttpClient(config);
+        this.accounts = new AccountsClient(this.httpClient);
+        this.compliance = new ComplianceClient(this.httpClient);
+        this.identity = new IdentityClient(this.httpClient);
+        this.orgs = new OrgsClient(this.httpClient);
+    }
+}
+export { SDK };

package/dist/init.d.ts

@@ -0,0 +1,2 @@
+import type { BloqueConfig } from '@bloque/sdk-core';
+export declare function init(config: BloqueConfig): void;

package/dist/orgs.d.ts

@@ -0,0 +1,3 @@
+export type { CreateOrgParams, CreateOrgResponse, Organization, OrgProfile, OrgStatus, OrgType, Place, } from '@bloque/sdk-orgs';
+import { OrgsClient } from '@bloque/sdk-orgs';
+export declare const Orgs: OrgsClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bloque/sdk",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Official Bloque SDK",
   "type": "module",
   "keywords": [
@@ -19,11 +19,37 @@
     "url": "git+https://github.com/bloque-app/sdk.git",
     "directory": "packages/sdk"
   },
+  "sideEffects": false,
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
+    },
+    "./init": {
+      "types": "./dist/init.d.ts",
+      "import": "./dist/init.js",
+      "require": "./dist/init.cjs"
+    },
+    "./accounts": {
+      "types": "./dist/accounts.d.ts",
+      "import": "./dist/accounts.js",
+      "require": "./dist/accounts.cjs"
+    },
+    "./compliance": {
+      "types": "./dist/compliance.d.ts",
+      "import": "./dist/compliance.js",
+      "require": "./dist/compliance.cjs"
+    },
+    "./identity": {
+      "types": "./dist/identity.d.ts",
+      "import": "./dist/identity.js",
+      "require": "./dist/identity.cjs"
+    },
+    "./orgs": {
+      "types": "./dist/orgs.d.ts",
+      "import": "./dist/orgs.js",
+      "require": "./dist/orgs.cjs"
     }
   },
   "main": "./dist/index.cjs",
@@ -42,7 +68,11 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@bloque/sdk-core": "workspace:*"
+    "@bloque/sdk-accounts": "workspace:*",
+    "@bloque/sdk-compliance": "workspace:*",
+    "@bloque/sdk-core": "workspace:*",
+    "@bloque/sdk-identity": "workspace:*",
+    "@bloque/sdk-orgs": "workspace:*"
   },
   "devDependencies": {
     "@rslib/core": "catalog:",