@pabilo/sdk 0.1.5 → 0.1.7

package/README.md

@@ -13,8 +13,6 @@ TypeScript/JavaScript SDK for [pabilo.app](https://pabilo.app) — the Venezuela
 npm install @pabilo/sdk
 # or
 pnpm add @pabilo/sdk
-# or
-yarn add @pabilo/sdk
 ```
 
 ## Quick start
@@ -25,41 +23,168 @@ import { PabiloClient } from '@pabilo/sdk';
 const pabilo = new PabiloClient({ apiKey: 'YOUR_API_KEY' });
 ```
 
+The client exposes four namespaces:
+
+| Namespace | Description |
+|---|---|
+| `pabilo.me` | Current user and plan info |
+| `pabilo.bankAccounts` | Manage connected bank accounts |
+| `pabilo.paymentLinks` | Create and manage payment links |
+| `pabilo.payments` | Verify payments by bank reference |
+
+---
+
+## `pabilo.me`
+
+### `me.getMe(): Promise<User>`
+
+Returns the authenticated user's profile.
+
+```typescript
+const user = await pabilo.me.getMe();
+
+console.log(user.id);          // string
+console.log(user.email);       // string | undefined
+console.log(user.username);    // string | undefined
+console.log(user.fullName);    // string | undefined
+console.log(user.companyName); // string | undefined
+console.log(user.credits);     // number | undefined
+console.log(user.planIsActive);// boolean | undefined
+console.log(user.isDemo);      // boolean | undefined
+console.log(user.userType);    // 'user' | 'admin' | 'commerce' | ... | undefined
+```
+
+**Returns:** `User`
+
+```typescript
+interface User {
+  id: string;
+  email?: string;
+  username?: string;
+  fullName?: string;
+  companyName?: string;
+  credits?: number;
+  planIsActive?: boolean;
+  isDemo?: boolean;
+  userType?: UserType;
+}
+
+type UserType = 'system' | 'user' | 'admin' | 'test' | 'commerce' | string;
+```
+
 ---
 
-## Bank accounts
+### `me.getPlan(): Promise<Plan>`
 
-### List bank accounts
+Returns the current subscription plan for the authenticated account.
+
+```typescript
+const plan = await pabilo.me.getPlan();
+
+console.log(plan.name);              // e.g. 'Pro'
+console.log(plan.planType);          // 'credit' | 'unlimited' | 'counter'
+console.log(plan.period);            // 'month' | 'six_months' | 'year'
+console.log(plan.requestLimit);      // number (-1 = unlimited)
+console.log(plan.bankAccountLimit);  // number (-1 = unlimited)
+console.log(plan.initialCredits);    // number
+console.log(plan.price);             // number
+console.log(plan.benefits);          // PlanBenefit[]
+```
+
+**Returns:** `Plan`
+
+```typescript
+interface Plan {
+  id?: string;
+  name: string;
+  description?: string;
+  planType?: PlanType;      // 'credit' | 'unlimited' | 'counter'
+  period?: PlanPeriod;      // 'month' | 'six_months' | 'year'
+  price?: number;
+  requestLimit?: number;
+  bankAccountLimit?: number;
+  initialCredits?: number;
+  maxAcumulatedCredits?: number;
+  benefits?: PlanBenefit[];
+  salient?: boolean;
+  hidden?: boolean;
+}
+
+interface PlanBenefit {
+  description: string;
+  contain: boolean;
+}
+```
+
+---
+
+## `pabilo.bankAccounts`
+
+### `bankAccounts.list(): Promise<UserBank[]>`
+
+Returns all bank accounts connected to the authenticated user.
 
 ```typescript
 const banks = await pabilo.bankAccounts.list();
 
 for (const bank of banks) {
-  console.log(bank.id, bank.provider, bank.description);
-  // bank.bank_accounts → BankAccountEntry[]
+  console.log(bank.id);          // MongoDB ObjectId string
+  console.log(bank.provider);    // 'VE_BAN' | 'VE_BAN_EMP_V2' | 'BANK_TEST' | ...
+  console.log(bank.description); // display name set during creation
+  console.log(bank.bank_accounts); // BankAccountEntry[]
+  console.log(bank.to_trash);    // boolean — true if soft-deleted
+}
+```
+
+**Returns:** `UserBank[]`
+
+```typescript
+interface UserBank {
+  id: string;
+  description: string;
+  provider: BankProvider;
+  bank_accounts: BankAccountEntry[];
+  payment_link?: boolean;
+  to_trash?: boolean;
+}
+
+interface BankAccountEntry {
+  account_number: string;
+  account_type: string; // e.g. 'AHORRO', 'CORRIENTE'
 }
+
+type BankProvider =
+  | 'VE_BAN'           // BDV personal
+  | 'VE_BAN_EMP'       // BDV empresa v1
+  | 'VE_BAN_EMP_V2'    // BDV empresa v2
+  | 'VE_PROV'          // Provincial personal
+  | 'VE_PROV_EMP'      // Provincial empresa
+  | 'MERCANTIL_EMP_V1'      // Mercantil empresa
+  | 'MERCANTIL_EMP_TEST_V1' // Mercantil test
+  | 'BANK_TEST'        // Sandbox
+  | string;
 ```
 
-### Create a bank account
+---
+
+### `bankAccounts.create(req): Promise<UserBank>`
 
-Each provider has its own typed request shape — TypeScript will enforce the required fields.
+Creates a new bank account connection. Each provider has its own typed request — TypeScript enforces required fields per provider via a discriminated union on `bankProvider`.
 
-**BDV personal (`VE_BAN`)**
+**BDV personal — `VE_BAN`**
 
 ```typescript
 const bank = await pabilo.bankAccounts.create({
   bankProvider: 'VE_BAN',
-  description: 'Mi cuenta BDV',
+  description: 'Mi cuenta BDV personal',
   userBankPhone: '04241234567',
   userBankDni: '12345678',
   username: 'usuario_portal_bdv',
   password: 'contraseña_portal_bdv',
 });
-
-console.log(bank.id); // use this id when creating payment links
 ```
 
-**BDV empresa (`VE_BAN_EMP_V2`)**
+**BDV empresa — `VE_BAN_EMP_V2`**
 
 ```typescript
 const bank = await pabilo.bankAccounts.create({
@@ -67,7 +192,7 @@ const bank = await pabilo.bankAccounts.create({
   description: 'Cuenta empresa BDV',
   userBankPhone: '04241234567',
   userBankDni: '12345678',
-  accountNumber: '0102000000000000000',  // account number
+  accountNumber: '01020000000000000000',
   apiKey: 'bdv_api_key_here',
   metadata: [
     { key_name: 'SHOW_DATE_IN_GENERIC_MOVEMENTS', key_value: 'true' },
@@ -75,13 +200,19 @@ const bank = await pabilo.bankAccounts.create({
 });
 ```
 
-**Test bank (`BANK_TEST`)**
+**Test bank — `BANK_TEST`**
+
+A sandboxed bank for testing. Always has a payment with reference `67890` available.
 
 ```typescript
 const bank = await pabilo.bankAccounts.create({ bankProvider: 'BANK_TEST' });
 ```
 
-### Delete a bank account
+---
+
+### `bankAccounts.delete(id): Promise<void>`
+
+Soft-deletes a bank account. The bank no longer appears in `list()` results.
 
 ```typescript
 await pabilo.bankAccounts.delete(bank.id);
@@ -89,9 +220,53 @@ await pabilo.bankAccounts.delete(bank.id);
 
 ---
 
-## Payment links
+## `pabilo.paymentLinks`
+
+### `paymentLinks.list(req?): Promise<PaymentLinksPage>`
+
+Returns a paginated list of the authenticated user's payment links.
 
-### Create a payment link
+```typescript
+const page = await pabilo.paymentLinks.list({
+  limit: 10,
+  page: 1,
+  status: 'pending',   // filter by status
+  type: 'default',     // filter by type
+  search: 'orden',     // search by name/description
+});
+
+console.log(page.total);   // total count
+console.log(page.page);    // current page
+console.log(page.limit);   // page size
+console.log(page.items);   // PaymentLink[]
+```
+
+**Request fields (all optional):**
+
+| Field | Type | Default | Description |
+|---|---|---|---|
+| `page` | `number` | `1` | Page number |
+| `limit` | `number` | `10` | Items per page |
+| `status` | `PaymentLinkStatus` | — | Filter by status |
+| `type` | `PaymentLinkType` | — | Filter by type |
+| `search` | `string` | — | Text search |
+
+**Returns:** `PaymentLinksPage`
+
+```typescript
+interface PaymentLinksPage {
+  items: PaymentLink[];
+  total: number;
+  page: number;
+  limit: number;
+}
+```
+
+---
+
+### `paymentLinks.create(req): Promise<PaymentLink>`
+
+Creates a new payment link that customers can use to pay via Pago Móvil.
 
 ```typescript
 const link = await pabilo.paymentLinks.create({
@@ -99,38 +274,102 @@ const link = await pabilo.paymentLinks.create({
   description: 'Orden #1234',
   userBankId: bank.id,
   // optional
+  name: 'Servicio mensual',
   redirectUrl: 'https://myapp.com/gracias',
   webhookUrl: 'https://myapp.com/webhook/pabilo',
   notificationByWhatsapp: true,
-  name: 'Pago por servicio',
   isUsd: false,
+  currency: 'VES',
 });
 
 console.log(link.url);    // https://pabilo.app/pay/...
 console.log(link.id);
-console.log(link.status); // 'pending' | 'paid' | 'active' | 'expired' | 'cancelled'
+console.log(link.status); // 'pending' | 'active' | 'paid' | 'failed' | 'canceled' | 'expired' | 'stopped'
 ```
 
-### Get payment link info
+**Request fields:**
+
+| Field | Type | Required | Description |
+|---|---|---|---|
+| `amount` | `number` | yes | Amount in the payment currency |
+| `description` | `string` | yes | Internal description |
+| `userBankId` | `string` | yes | ID of the bank account to receive payment |
+| `name` | `string` | no | Customer-facing name shown on the payment page |
+| `currency` | `string` | no | Defaults to `'VES'` |
+| `isUsd` | `boolean` | no | Whether the amount is in USD |
+| `redirectUrl` | `string` | no | URL to redirect after payment |
+| `webhookUrl` | `string` | no | URL to receive payment event webhooks |
+| `notificationByWhatsapp` | `boolean` | no | Send WhatsApp notification on payment |
+| `metadata` | `Record<string, unknown>` | no | Arbitrary key/value data |
+
+**Returns:** `PaymentLink`
 
 ```typescript
-const link = await pabilo.paymentLinks.getInfo(linkId);
-console.log(link.status, link.amount);
+interface PaymentLink {
+  id: string;
+  url: string;
+  amount?: number;
+  status?: PaymentLinkStatus;
+  statusDetail?: string;
+  type?: PaymentLinkType;
+  userId?: string;
+  userBankId?: string;
+  withSubscriptionId?: string;
+  name?: string;
+  description?: string;
+  isUsd?: boolean;
+  redirectUrl?: string;
+  webhookUrl?: string;
+  webhookMethod?: string;
+  notificationByWhatsapp?: boolean;
+  expirationTime?: number;
+  paymentLinkOrigin?: PaymentLinkOrigin;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+type PaymentLinkStatus = 'pending' | 'active' | 'paid' | 'failed' | 'canceled' | 'expired' | 'stopped' | string;
+type PaymentLinkType   = 'default' | 'fixed' | 'subscription' | 'donation' | string;
+type PaymentLinkOrigin = 'pabilo' | 'api' | string;
 ```
 
-### Check if a payment link was paid
+---
+
+### `paymentLinks.getInfo(id): Promise<PaymentLink>`
+
+Fetches current state of a payment link.
 
 ```typescript
-const paid = await pabilo.paymentLinks.isPaid(linkId);
+const link = await pabilo.paymentLinks.getInfo('69d0083b691af50b78e07921');
+
+console.log(link.status);       // 'paid'
+console.log(link.statusDetail); // string — reason for current status
+console.log(link.amount);
+console.log(link.createdAt);
+```
+
+---
+
+### `paymentLinks.isPaid(id): Promise<boolean>`
+
+Returns `true` if the payment link's status is `'paid'`.
+
+```typescript
+const paid = await pabilo.paymentLinks.isPaid(link.id);
+
 if (paid) {
   // fulfill the order
 }
 ```
 
-### Update a payment link
+---
+
+### `paymentLinks.update(id, req): Promise<PaymentLink>`
+
+Updates a payment link's amount or description.
 
 ```typescript
-const updated = await pabilo.paymentLinks.update(linkId, {
+const updated = await pabilo.paymentLinks.update(link.id, {
   amount: 5000,
   description: 'Orden actualizada',
 });
@@ -138,29 +377,51 @@ const updated = await pabilo.paymentLinks.update(linkId, {
 
 ---
 
-## Verify a payment by bank reference
+## `pabilo.payments`
 
-Used to confirm that a specific bank transfer exists and matches the expected amount.
+### `payments.verify(userBankId, req): Promise<VerifyPaymentResult>`
+
+Checks whether a specific bank transfer exists in a connected bank account.
 
 ```typescript
-const result = await pabilo.payments.verify(userBankId, {
+const result = await pabilo.payments.verify(bank.id, {
   amount: 4000,
   bankReference: '12345678',
-  movementType: 'GENERIC', // optional
+  movementType: 'GENERIC', // 'GENERIC' | 'MOVIL_PAY' | 'TRANSFER' | 'C2P'
 });
 
 if (result.found) {
-  console.log('Payment found!');
-  console.log(result.isNew);         // true if first time seen
+  console.log(result.isNew);
   console.log(result.data.credit_cost);
-  console.log(result.data.user_bank_payment); // full payment object
+
+  const payment = result.data.user_bank_payment;
+  if (payment) {
+    console.log(payment.id);
+    console.log(payment.amount);
+    console.log(payment.status); // 'pending' | 'paid' | 'failed'
+    console.log(payment.bank_reference_id);
+    console.log(payment.payment_params.fecha_pago);
+    console.log(payment.payment_params.banco_origen);
+    console.log(payment.payment_params.telefono_pagador);
+  }
 } else {
   // result.reason → 'BANK_NOT_AVAILABLE' | 'PAYMENT_NOT_FOUND'
-  console.log('Not found:', result.reason);
+  if (result.reason === 'BANK_NOT_AVAILABLE') {
+    // bank is offline or credentials expired
+  }
 }
 ```
 
-The result is a **discriminated union** on `found`:
+**`movementType` values:**
+
+| Value | Description |
+|---|---|
+| `'GENERIC'` | Default — any movement type (default) |
+| `'MOVIL_PAY'` | Pago Móvil |
+| `'TRANSFER'` | Bank transfer |
+| `'C2P'` | Cuenta a Persona (C2P) |
+
+**Returns:** `VerifyPaymentResult` — a discriminated union on `found`:
 
 ```typescript
 type VerifyPaymentResult =
@@ -168,49 +429,123 @@ type VerifyPaymentResult =
   | { found: true; isNew: boolean; data: PaymentData };
 ```
 
+> The API returns HTTP 200 for `BANK_NOT_AVAILABLE` and `PAYMENT_NOT_FOUND`. The SDK handles this transparently — these cases are never thrown as errors.
+
+---
+
+## Webhooks
+
+When a payment link is paid, the API sends a `POST` to the `webhookUrl` with the following payload. Import `PaymentLinkWebhookPayload` to type your webhook handler:
+
+```typescript
+import type { PaymentLinkWebhookPayload } from '@pabilo/sdk';
+
+// Next.js App Router
+export async function POST(req: Request) {
+  const payload: PaymentLinkWebhookPayload = await req.json();
+
+  console.log(payload.payment_link_id);
+  console.log(payload.status);           // 'paid'
+  console.log(payload.credit_balance);
+
+  const payment = payload.user_bank_payment;
+  if (payment) {
+    console.log(payment.amount);
+    console.log(payment.bank_reference_id);
+    console.log(payment.payment_params.fecha_pago);
+  }
+
+  return Response.json({ ok: true });
+}
+```
+
+**`PaymentLinkWebhookPayload` shape:**
+
+```typescript
+interface PaymentLinkWebhookPayload {
+  id: string;
+  created_at: string;
+  updated_at: string;
+  payment_link_id: string;
+  status: PaymentLinkStatus;
+  payment_link?: PaymentLink;
+  user_bank_payment?: UserBankPayment;
+  credit_balance: number;
+  metadata: Array<{ key: string; value: string }>;
+}
+```
+
 ---
 
 ## Error handling
 
-SDK methods throw `PabiloError` on API or network failures.
+All methods throw `PabiloError` on API errors or network failures.
 
 ```typescript
 import { PabiloClient, PabiloError } from '@pabilo/sdk';
 
 try {
-  await pabilo.paymentLinks.create({ ... });
+  const link = await pabilo.paymentLinks.create({ ... });
 } catch (err) {
   if (err instanceof PabiloError) {
-    console.error(err.code);    // 'BAD_REQUEST' | 'UNAUTHORIZED' | 'NOT_FOUND' | ...
-    console.error(err.message); // human-readable message from the API
-    console.error(err.raw);     // raw API response body
+    console.error(err.code);       // PabiloErrorCode string
+    console.error(err.message);    // human-readable message from the API
+    console.error(err.statusCode); // HTTP status code
+    console.error(err.raw);        // raw API response body
   }
 }
 ```
 
-Common error codes: `BAD_REQUEST`, `UNAUTHORIZED`, `NOT_FOUND`, `USER_BANK_ALREADY_EXISTS`, `INTERNAL_SERVER_ERROR`, `NETWORK_ERROR`.
+**Common error codes:**
+
+| Code | Description |
+|---|---|
+| `BAD_REQUEST` | Invalid request body or parameters |
+| `UNAUTHORIZED` | API key is missing or invalid |
+| `FORBIDDEN` | Action not permitted |
+| `NOT_FOUND` | Resource not found |
+| `USER_BANK_ALREADY_EXISTS` | Bank account is already connected |
+| `USER_BANCK_BAD_PASSWORD` | Wrong bank portal credentials |
+| `USER_BANCK_PASSWORD_EXPIRED` | Bank portal password expired |
+| `NOT_ENOUGH_CREDITS` | Insufficient credits in the account |
+| `PLAN_IS_NOT_ACTIVE` | Account plan is inactive |
+| `REQUEST_LIMIT_REACHED` | Plan request limit exceeded |
+| `BANK_ACCOUNT_LIMIT_REACHED` | Plan bank account limit exceeded |
+| `BANK_NOT_AVAILABLE` | Bank is temporarily offline |
+| `BANK_TEMPORARILY_INACTIVE` | Bank is temporarily disabled |
+| `BANK_TOO_MANY_REQUESTS` | Rate limit from the bank |
+| `PAYMENT_NOT_FOUND` | Transfer reference not found |
+| `PAYMENT_ALREADY_EXISTS` | Transfer already verified |
+| `INTERNAL_ERROR` | API server error |
+| `NETWORK_ERROR` | Request could not reach the API |
 
 ---
 
-## Custom HTTP client
+## Testing with BANK_TEST
 
-The SDK accepts an `IHttpClient` implementation for custom fetch behavior (retries, logging, etc.).
+Use `BANK_TEST` to test the full payment flow without connecting a real bank. Reference `67890` always returns a found payment.
 
 ```typescript
-import { PabiloClient, FetchHttpClient, PabiloHttpClient } from '@pabilo/sdk';
+// 1. Create test bank
+const bank = await pabilo.bankAccounts.create({ bankProvider: 'BANK_TEST' });
 
-// Default — uses globalThis.fetch
-const pabilo = new PabiloClient({ apiKey: 'YOUR_API_KEY' });
+// 2. Create a payment link
+const link = await pabilo.paymentLinks.create({
+  amount: 100,
+  description: 'Test payment',
+  userBankId: bank.id,
+  webhookUrl: 'https://myapp.com/webhook',
+});
 
-// Custom base URL (e.g. for a proxy or staging environment)
-const pabilo = new PabiloClient({
-  apiKey: 'YOUR_API_KEY',
-  baseUrl: 'https://staging.api.pabilo.app',
+// 3. Verify the test payment
+const result = await pabilo.payments.verify(bank.id, {
+  amount: 0,
+  bankReference: '67890',
 });
+// result.found === true
 
-// Bring your own HTTP client
-class MyHttpClient extends FetchHttpClient { /* override request() */ }
-const pabilo = new PabiloClient({ apiKey: 'YOUR_API_KEY', httpClient: new MyHttpClient() });
+// 4. Clean up
+await pabilo.bankAccounts.delete(bank.id);
 ```
 
 ---
@@ -229,20 +564,73 @@ export const pabilo = new PabiloClient({
 ```typescript
 // app/api/checkout/route.ts
 import { pabilo } from '@/lib/pabilo';
+import { PabiloError } from '@pabilo/sdk';
 
 export async function POST(req: Request) {
   const { bankId, amount } = await req.json();
 
-  const link = await pabilo.paymentLinks.create({
-    amount,
-    description: 'Checkout',
-    userBankId: bankId,
-    redirectUrl: `${process.env.NEXT_PUBLIC_URL}/gracias`,
-    webhookUrl: `${process.env.NEXT_PUBLIC_URL}/api/webhook/pabilo`,
-  });
+  try {
+    const link = await pabilo.paymentLinks.create({
+      amount,
+      description: 'Checkout',
+      userBankId: bankId,
+      redirectUrl: `${process.env.NEXT_PUBLIC_URL}/gracias`,
+      webhookUrl: `${process.env.NEXT_PUBLIC_URL}/api/webhook/pabilo`,
+    });
+
+    return Response.json({ url: link.url, id: link.id });
+  } catch (err) {
+    if (err instanceof PabiloError) {
+      return Response.json({ error: err.message }, { status: 400 });
+    }
+    throw err;
+  }
+}
+```
+
+```typescript
+// app/api/webhook/pabilo/route.ts
+import type { PaymentLinkWebhookPayload } from '@pabilo/sdk';
+import { pabilo } from '@/lib/pabilo';
+
+export async function POST(req: Request) {
+  const payload: PaymentLinkWebhookPayload = await req.json();
+
+  if (payload.status === 'paid') {
+    // fulfill the order linked to payload.payment_link_id
+  }
+
+  return Response.json({ ok: true });
+}
+```
+
+---
+
+## Advanced: custom HTTP client
+
+```typescript
+import { PabiloClient, FetchHttpClient, type RequestOptions } from '@pabilo/sdk';
 
-  return Response.json({ url: link.url, id: link.id });
+class LoggingHttpClient extends FetchHttpClient {
+  async request<T>(opts: RequestOptions): Promise<T> {
+    console.log('[pabilo]', opts.method, opts.path);
+    return super.request<T>(opts);
+  }
 }
+
+const pabilo = new PabiloClient({
+  apiKey: 'YOUR_API_KEY',
+  httpClient: new LoggingHttpClient(),
+});
+```
+
+Custom base URL:
+
+```typescript
+const pabilo = new PabiloClient({
+  apiKey: 'YOUR_API_KEY',
+  baseUrl: 'https://staging.api.pabilo.app',
+});
 ```
 
 ---
@@ -251,19 +639,56 @@ export async function POST(req: Request) {
 
 ```typescript
 import type {
+  // Client
+  PabiloClientOptions,
+
+  // Resources
+  User,
+  Plan,
+  PlanBenefit,
   UserBank,
   BankAccountEntry,
   PaymentLink,
-  PaymentLinkStatus,   // 'pending' | 'paid' | 'active' | 'expired' | 'cancelled'
-  PaymentLinkType,     // 'default' | 'fixed'
-  VerifyPaymentResult,
+  PaymentLinksPage,
   PaymentData,
   UserBankPayment,
+  PaymentParams,
+
+  // Requests
   CreateUserBankRequest,
   CreateVeBanRequest,
   CreateVeBanEmpV2Request,
   CreateBankTestRequest,
+  UserBankMetadataEntry,
+  CreatePaymentLinkRequest,
+  UpdatePaymentLinkRequest,
+  ListPaymentLinksRequest,
+  VerifyPaymentRequest,
+
+  // Results & Webhooks
+  VerifyPaymentResult,
+  PaymentLinkWebhookPayload,
+
+  // Literals / enums
+  PaymentLinkStatus,    // 'pending' | 'active' | 'paid' | 'failed' | 'canceled' | 'expired' | 'stopped'
+  PaymentLinkType,      // 'default' | 'fixed' | 'subscription' | 'donation'
+  PaymentLinkOrigin,    // 'pabilo' | 'api'
+  BankProvider,         // 'VE_BAN' | 'VE_BAN_EMP_V2' | ...
+  MovementType,         // 'GENERIC' | 'MOVIL_PAY' | 'TRANSFER' | 'C2P'
+  UserBankPaymentStatus,// 'pending' | 'paid' | 'failed'
+  UserType,             // 'user' | 'admin' | 'commerce' | ...
+  PlanType,             // 'credit' | 'unlimited' | 'counter'
+  PlanPeriod,           // 'month' | 'six_months' | 'year'
+  AccountType,
   PabiloErrorCode,
+
+  // Ports (for DI / testing)
+  IHttpClient,
+  RequestOptions,
+  IBankAccountsPort,
+  IPaymentLinksPort,
+  IPaymentsPort,
+  IMePort,
 } from '@pabilo/sdk';
 ```