pi-spi-sdk 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2024-12-28
+
+[0.1.0]: https://github.com/lomiafrica/lomi./releases/tag/pi-spi-sdk-v0.1.0
+
+### Added
+
+- Initial release of PI-SPI SDK
+- Full TypeScript support with generated types from OpenAPI spec
+- OAuth2 + mTLS authentication support
+- Comprehensive API coverage for all PI-SPI endpoints
+- Query builder utility for filtering, pagination, and sorting
+- Custom error classes (`PiSpiError`, `PiSpiValidationError`, `PiSpiAuthError`, etc.)
+- Support for all PI-SPI services:
+  - Accounts (Comptes)
+  - Aliases
+  - Webhooks
+  - Payment requests (Demandes de Paiement)
+  - Bulk payment requests
+  - Immediate payments (Paiements)
+  - Bulk payments
+  - Fund returns (Retours de Fonds)
+  - Cancellation requests (Demandes Annulation)
+
+### Fixed
+
+- Empty type definitions in generated models
+- Type safety improvements for error handling

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 lomi.
+
+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,300 @@
+# @lomi/pi-spi-sdk
+
+> **This repository is a contribution from open-source payment processing company [lomi.](https://lomi.africa)**
+
+The Interoperable Platform for the Instant Payment System (π-SPI) is a regional payment infrastructure designed and operated by the Central Bank of West African States (BCEAO).
+
+It enables instant fund transfers between different financial institutions across the region, including banks, electronic money issuers, microfinance institutions, and payment establishments.
+
+
+## Installation
+
+```bash
+pnpm add pi-spi-sdk
+# or
+npm install pi-spi-sdk
+# or
+yarn add pi-spi-sdk
+```
+π-SPI enables **cross-border transactions** within the West African Economic and Monetary Union (UEMOA), which spans eight countries: Benin, Burkina Faso, Côte d'Ivoire, Guinea-Bissau, Mali, Niger, Senegal, and Togo. 
+
+The infrastructure operates on a single currency, the XOF (West African CFA Franc), and processes payments in real-time with instant confirmation. Users can send payments using alias-based methods, which means they don't need to share their actual account numbers.
+
+**Transaction types supported:**
+
+π-SPI supports seamless interoperability between different payment systems throughout the region. Payments can flow between traditional bank accounts across UEMOA countries, from bank accounts to mobile money wallets like MTN, Orange Money, and Moov, from mobile wallets back to bank accounts, and even between mobile money wallets regardless of which provider each person uses. All these transaction types work seamlessly through the unified infrastructure, enabling businesses and individuals to send and receive payments across different financial institutions and mobile money providers within the UEMOA region.
+
+## Usage example
+
+```typescript
+import { PiSpiSDK } from 'pi-spi-sdk';
+
+const sdk = new PiSpiSDK({
+  baseUrl: 'https://sandbox.api.pi-bceao.com/piz/v1',
+  accessToken: 'your-oauth2-access-token',
+});
+
+// Get account balance
+const account = await sdk.comptes.getAccount('CIC2344256727788288822');
+
+// Create a payment
+const payment = await sdk.paiements.create({
+  comptePayeur: 'CIC2344256727788288822',
+  payeAlias: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f', // SHID alias
+  montant: 150000, // 1,500 XOF (amounts are in centimes)
+  motif: 'Paiement de services',
+});
+```
+
+## Features
+
+This SDK provides full TypeScript support with types generated from the official OpenAPI specification, ensuring type safety throughout your integration. It includes secure authentication through OAuth2 and mTLS, comprehensive coverage of all SPI endpoints, and custom error classes with detailed messages for easier debugging. The codebase is auto-generated from the official specification and includes developer-friendly utilities and constants to streamline your implementation.
+
+## Utilities & Constants
+
+### Utilities
+
+```typescript
+import { formatAmount, xofToCentimes, isValidAccountNumber } from 'pi-spi-sdk';
+
+// Format amounts for display
+const displayAmount = formatAmount(150000); // "1 500 XOF"
+
+// Convert XOF to centimes
+const centimes = xofToCentimes(1500); // 150000
+
+// Validate inputs
+if (isValidAccountNumber(accountNumber)) {
+  // Valid account number
+}
+```
+
+### Constants
+
+```typescript
+import { PI_SPI_ENDPOINTS, PAYMENT_STATUS, CURRENCY } from 'pi-spi-sdk';
+
+// Use constants instead of magic strings
+const baseUrl = PI_SPI_ENDPOINTS.SANDBOX;
+if (payment.statut === PAYMENT_STATUS.IRREVOCABLE) {
+  // Payment is confirmed
+}
+```
+
+## Reference
+
+### Authentication
+
+```typescript
+const sdk = new PiSpiSDK({
+  baseUrl: process.env.PI_SPI_BASE_URL,
+  accessToken: process.env.PI_SPI_ACCESS_TOKEN,
+  // Optional: mTLS certificates
+  // clientCert: process.env.PI_SPI_CLIENT_CERT,
+  // clientKey: process.env.PI_SPI_CLIENT_KEY,
+});
+```
+
+### Services
+
+#### Accounts
+
+```typescript
+// Get account balance and details
+// Endpoint: GET /comptes/{numero}
+const account = await sdk.comptes.getAccount('CIC2344256727788288822');
+// Returns: {
+//   type: 'CACC', // Account type (CACC = Current Account)
+//   numero: 'CIC2344256727788288822',
+//   solde: 150000000, // Balance in centimes (1,500,000 XOF)
+//   statut: 'OUVERT', // Status: OUVERT, BLOQUE, or CLOTURE
+//   dateOuverture: '2023-02-21T15:30:01.250Z'
+// }
+
+// List operations with pagination
+await sdk.comptes.listOperations({
+  comptePayeur: 'CIC2344256727788288822',
+  page: 1,
+  size: 20,
+});
+
+// Transfer between accounts (using account numbers)
+await sdk.comptes.transfer({
+  comptePayeur: 'CIC2344256727788288822',
+  comptePaye: 'SNC2344256727788288822',
+  montant: 150000, // 1,500 XOF
+});
+
+// Transfer using aliases
+await sdk.comptes.transfer({
+  payeurAlias: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f',
+  payeAlias: '4r5ty499-3e50-435b-b757-ac7a83d67juio',
+  montant: 150000,
+});
+```
+
+#### Payments
+
+```typescript
+// Create immediate payment (no confirmation)
+await sdk.paiements.create({
+  comptePayeur: 'CIC2344256727788288822',
+  payeAlias: '9b1b2499-3e50-435b-b757-ac7a83d8aa8c', // SHID alias
+  montant: 150000, // 1,500 XOF
+  motif: 'Paiement de services',
+});
+
+// Create payment with confirmation
+await sdk.paiements.create({
+  comptePayeur: 'CIC2344256727788288822',
+  payeAlias: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f',
+  montant: 3000000, // 30,000 XOF
+  confirmation: true,
+});
+
+// Get payment details
+await sdk.paiements.get('23552722');
+
+// List payments with filters
+await sdk.paiements.list({
+  comptePayeur: 'CIC2344256727788288822',
+  statut: 'IRREVOCABLE',
+});
+```
+
+#### Aliases
+
+```typescript
+import { AliasType } from 'pi-spi-sdk';
+
+// Create SHID alias (available for all client types: P, C, B, G)
+// SHID is a system-generated UUID (36 characters)
+const shidAlias = await sdk.alias.create({
+  compte: 'CIC2344256727788288822',
+  type: AliasType.SHID,
+});
+// Returns: { cle: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f', type: 'SHID', ... }
+
+// Create MCOD alias (business clients only: C, B, G)
+// MCOD is a merchant code for USSD payments
+const mcodAlias = await sdk.alias.create({
+  compte: 'SNC2344256727788288822',
+  type: AliasType.MCOD,
+});
+// Returns: { cle: 'SNF00_2E4TY', type: 'MCOD', ... }
+
+// List all aliases for an account
+await sdk.alias.list('CIC2344256727788288822');
+
+// Delete an alias
+await sdk.alias.delete('8b1b2499-3e50-435b-b757-ac7a83d8aa7f');
+```
+
+#### Payment requests
+
+```typescript
+// Create payment request (bill/invoice)
+await sdk.demandesPaiement.create({
+  comptePaye: 'CIC2344256727788288822',
+  payeurAlias: '9b1b3499-3e50-435b-b757-ac7a83d8aa96', // Customer's alias
+  montant: 150000, // 1,500 XOF
+  categorie: '401', // Invoice category
+  dateLimitePaiement: '2023-12-31T23:59:59.999Z',
+  motif: 'Facture électricité mars 2023',
+  refDocType: 'CINV',
+  refDocNumero: 'FACT-ELEC-202303',
+});
+
+// Accept a payment request
+await sdk.demandesPaiement.accept('RTP-2023-001');
+
+// Reject a payment request
+await sdk.demandesPaiement.reject('RTP-2023-001');
+```
+
+#### Webhooks
+
+```typescript
+await sdk.webhooks.create({
+  url: 'https://your-domain.com/webhooks/pi-spi',
+  events: ['PAIEMENT_RECU'],
+});
+await sdk.webhooks.list();
+await sdk.webhooks.update(webhookId, { url: 'https://updated-url.com' });
+await sdk.webhooks.delete(webhookId);
+```
+
+### Error handling
+
+```typescript
+import { PiSpiError, PiSpiValidationError, PiSpiAuthError } from 'pi-spi-sdk';
+
+try {
+  await sdk.paiements.create({ ... });
+} catch (error) {
+  if (error instanceof PiSpiValidationError) {
+    console.error('Validation error:', error.errors);
+  } else if (error instanceof PiSpiAuthError) {
+    console.error('Authentication error:', error.message);
+  }
+}
+```
+
+### Filtering & pagination
+
+The SDK includes a QueryBuilder that allows you to construct complex queries with multiple filters, sorting, and pagination. You can chain filter conditions using various operators, sort results in ascending or descending order (use `-` prefix for descending), and control pagination with page number and size parameters.
+
+```typescript
+import { QueryBuilder } from 'pi-spi-sdk';
+
+const query = new QueryBuilder()
+  .filter('statut', 'eq', 'IRREVOCABLE')
+  .filter('montant', 'gte', 10000)
+  .sort('-dateCreation')
+  .page(1)
+  .size(50)
+  .build();
+
+const payments = await sdk.paiements.list(query);
+```
+
+The QueryBuilder supports these operators: `eq` (equals), `ne` (not equals), `gt` (greater than), `gte` (greater than or equal), `lt` (less than), `lte` (less than or equal), `in` (in array), `contains`, `notContains`, `beginsWith`, `endsWith`, and `exists`.
+
+## Alias types
+
+The SPI supports three types of account aliases that allow users to send and receive payments without sharing their full account numbers:
+
+**SHID (System-Hosted Identifier)** is a system-generated UUID (36 characters, such as `8b1b2499-3e50-435b-b757-ac7a83d8aa7f`) available for all client types and serves as a general-purpose payment address.
+
+**MCOD (Merchant Code)** is an alphanumeric code (like `SNF00_2E4TY`) that's system-generated and available exclusively for business clients (C, B, G), primarily used for USSD payment support.
+
+**MBNO (Mobile Number)** uses phone number format and is available only for individual clients (P), designed specifically for mobile money integration.
+
+**Example:**
+
+```typescript
+import { AliasType, getAvailableAliasTypes, isValidAliasType } from 'pi-spi-sdk';
+
+// Get available alias types for a business client
+const businessAliasTypes = getAvailableAliasTypes('B'); // Returns: ['SHID', 'MCOD']
+
+// Check if a string is a valid alias type
+if (isValidAliasType('SHID')) {
+  // Valid alias type
+}
+```
+
+## Documentation
+
+- **[Developer Guide](./DEVELOPER_GUIDE.md)** - For contributors and advanced usage
+- **[Changelog](./CHANGELOG.md)** - Version history
+
+## Support
+
+- **π-SPI API**: [pisfn-sandbox@bceao.int](mailto:pisfn-sandbox@bceao.int)
+- **SDK Support**: [hello@lomi.africa](mailto:hello@lomi.africa)
+- **Documentation**: [https://developers.pi-bceao.com](https://developers.pi-bceao.com)
+
+## License
+
+MIT

package/dist/config.d.ts

@@ -0,0 +1,35 @@
+/**
+ * PI-SPI SDK Configuration
+ */
+export interface PiSpiConfig {
+    /**
+     * Base URL for the PI-SPI API
+     * @default 'https://sandbox.api.pi-bceao.com/piz/v1'
+     */
+    baseUrl?: string;
+    /**
+     * OAuth2 access token for authentication
+     */
+    accessToken: string;
+    /**
+     * Optional: Client certificate path for mTLS
+     */
+    clientCert?: string;
+    /**
+     * Optional: Client key path for mTLS
+     */
+    clientKey?: string;
+    /**
+     * Optional: CA certificate path for mTLS
+     */
+    caCert?: string;
+    /**
+     * Optional: Additional headers to include in requests
+     */
+    headers?: Record<string, string>;
+    /**
+     * Optional: Request timeout in milliseconds
+     * @default 30000
+     */
+    timeout?: number;
+}

package/dist/config.js

@@ -0,0 +1,4 @@
+/**
+ * PI-SPI SDK Configuration
+ */
+export {};

package/dist/error-handler.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Error handler utility for converting API errors to SDK errors
+ */
+/**
+ * Convert a generated API error to a SDK error
+ */
+export declare function handleApiError(error: unknown): never;

package/dist/error-handler.js

@@ -0,0 +1,52 @@
+/**
+ * Error handler utility for converting API errors to SDK errors
+ */
+import { PiSpiError, PiSpiValidationError, PiSpiAuthError, PiSpiNotFoundError, PiSpiRateLimitError, } from './errors';
+/**
+ * Convert a generated API error to a SDK error
+ */
+export function handleApiError(error) {
+    // Check if it's an ApiError-like object (from generated code)
+    const isApiError = error &&
+        typeof error === 'object' &&
+        'status' in error &&
+        'statusText' in error &&
+        'body' in error;
+    if (isApiError) {
+        const apiError = error;
+        const status = apiError.status;
+        const body = apiError.body;
+        // Extract error details from RFC 7807 Problem format
+        const type = body?.type;
+        const title = body?.title || apiError.statusText;
+        const detail = body?.detail || apiError.message;
+        const instance = body?.instance;
+        // Handle validation errors (400)
+        if (status === 400) {
+            const invalidParams = body?.invalidParams || body?.errors;
+            throw new PiSpiValidationError(detail || title || 'Validation error', status, apiError.statusText, invalidParams, type, detail);
+        }
+        // Handle authentication errors (401)
+        if (status === 401) {
+            throw new PiSpiAuthError(detail || title || 'Authentication failed', status, apiError.statusText);
+        }
+        // Handle forbidden errors (403)
+        if (status === 403) {
+            throw new PiSpiError(detail || title || 'Forbidden', status, apiError.statusText, type, detail, instance);
+        }
+        // Handle not found errors (404)
+        if (status === 404) {
+            throw new PiSpiNotFoundError(detail || title || 'Resource not found', status, apiError.statusText);
+        }
+        // Handle rate limit errors (429)
+        if (status === 429) {
+            // Retry-After header would be in the response, but ApiError doesn't expose it
+            // This can be enhanced if needed
+            throw new PiSpiRateLimitError(detail || title || 'Rate limit exceeded', status, apiError.statusText);
+        }
+        // Handle other errors
+        throw new PiSpiError(detail || title || apiError.message || 'API error', status, apiError.statusText, type, detail, instance);
+    }
+    // Re-throw if it's not an API error
+    throw error;
+}

package/dist/errors.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Custom error classes for PI-SPI SDK
+ */
+export declare class PiSpiError extends Error {
+    readonly statusCode: number;
+    readonly statusText: string;
+    readonly type?: string;
+    readonly detail?: string;
+    readonly instance?: string;
+    constructor(message: string, statusCode: number, statusText: string, type?: string, detail?: string, instance?: string);
+}
+export declare class PiSpiValidationError extends PiSpiError {
+    readonly errors?: Record<string, string[]>;
+    constructor(message: string, statusCode: number, statusText: string, errors?: Record<string, string[]>, type?: string, detail?: string);
+}
+export declare class PiSpiAuthError extends PiSpiError {
+    constructor(message: string, statusCode: number, statusText: string);
+}
+export declare class PiSpiNotFoundError extends PiSpiError {
+    constructor(message: string, statusCode: number, statusText: string);
+}
+export declare class PiSpiRateLimitError extends PiSpiError {
+    readonly retryAfter?: number;
+    constructor(message: string, statusCode: number, statusText: string, retryAfter?: number);
+}

package/dist/errors.js

@@ -0,0 +1,40 @@
+/**
+ * Custom error classes for PI-SPI SDK
+ */
+export class PiSpiError extends Error {
+    constructor(message, statusCode, statusText, type, detail, instance) {
+        super(message);
+        this.name = 'PiSpiError';
+        this.statusCode = statusCode;
+        this.statusText = statusText;
+        this.type = type;
+        this.detail = detail;
+        this.instance = instance;
+    }
+}
+export class PiSpiValidationError extends PiSpiError {
+    constructor(message, statusCode, statusText, errors, type, detail) {
+        super(message, statusCode, statusText, type, detail);
+        this.name = 'PiSpiValidationError';
+        this.errors = errors;
+    }
+}
+export class PiSpiAuthError extends PiSpiError {
+    constructor(message, statusCode, statusText) {
+        super(message, statusCode, statusText);
+        this.name = 'PiSpiAuthError';
+    }
+}
+export class PiSpiNotFoundError extends PiSpiError {
+    constructor(message, statusCode, statusText) {
+        super(message, statusCode, statusText);
+        this.name = 'PiSpiNotFoundError';
+    }
+}
+export class PiSpiRateLimitError extends PiSpiError {
+    constructor(message, statusCode, statusText, retryAfter) {
+        super(message, statusCode, statusText);
+        this.name = 'PiSpiRateLimitError';
+        this.retryAfter = retryAfter;
+    }
+}

package/dist/examples.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Usage Examples for PI-SPI SDK
+ *
+ * These examples use production-like data from the PI-SPI OpenAPI specification.
+ *
+ * @see {@link https://developers.pi-bceao.com} Official PI-SPI Documentation
+ */
+export {};

package/dist/examples.js

@@ -0,0 +1,91 @@
+/**
+ * Usage Examples for PI-SPI SDK
+ *
+ * These examples use production-like data from the PI-SPI OpenAPI specification.
+ *
+ * @see {@link https://developers.pi-bceao.com} Official PI-SPI Documentation
+ */
+import { PiSpiSDK, QueryBuilder, AliasType } from './index';
+// Initialize the SDK
+const sdk = new PiSpiSDK({
+    baseUrl: 'https://sandbox.api.pi-bceao.com/piz/v1',
+    accessToken: process.env.PI_SPI_ACCESS_TOKEN,
+});
+// Example: Get account balance
+// Account numbers follow format: [CountryCode][AccountNumber]
+// Examples: 'CIC2344256727788288822' (Côte d'Ivoire), 'SNC2344256727788288822' (Senegal)
+async function getAccountBalance() {
+    const account = await sdk.comptes.getAccount('CIC2344256727788288822');
+    // @ts-expect-error - Service implementation pending code generation
+    console.log('Account balance:', account?.solde ?? 'N/A');
+    // @ts-expect-error
+    console.log('Account status:', account?.statut);
+}
+// Example: Create alias
+// SHID: System-generated UUID (36 chars) - available for all client types
+// MCOD: Merchant code for USSD - business clients only (C, B, G)
+// MBNO: Mobile number - individuals only (P)
+async function createAliasExample() {
+    // Create SHID alias (available for all client types)
+    const shidAlias = await sdk.alias.create({
+        compte: 'CIC2344256727788288822',
+        type: AliasType.SHID,
+    });
+    // Returns: { cle: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f', type: 'SHID', ... }
+    // Create MCOD alias (business clients only)
+    const mcodAlias = await sdk.alias.create({
+        compte: 'SNC2344256727788288822',
+        type: AliasType.MCOD,
+    });
+    // Returns: { cle: 'SNF00_2E4TY', type: 'MCOD', ... }
+}
+// Example: Query builder usage
+async function queryExample() {
+    const query = new QueryBuilder()
+        .filter('statut', 'eq', 'IRREVOCABLE')
+        .filter('montant', 'gte', 150000) // 1,500 XOF minimum
+        .sort('-dateCreation')
+        .page(1)
+        .size(50)
+        .build();
+    const payments = await sdk.paiements.list(query);
+}
+// Example: Create payment with realistic data
+async function createPaymentExample() {
+    const payment = await sdk.paiements.create({
+        comptePayeur: 'CIC2344256727788288822',
+        payeAlias: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f', // SHID alias (UUID format)
+        montant: 150000, // 1,500 XOF (amounts are in centimes)
+        motif: 'Paiement de services',
+        txId: '23552722', // Unique transaction ID
+    });
+}
+// Example: Error handling
+import { PiSpiError, PiSpiValidationError, PiSpiAuthError } from './index';
+async function errorHandlingExample() {
+    try {
+        await sdk.paiements.create({
+            comptePayeur: 'CIC2344256727788288822',
+            payeAlias: '9b1b2499-3e50-435b-b757-ac7a83d8aa8c', // SHID alias
+            montant: 150000, // 1,500 XOF
+            motif: 'Paiement de test',
+        });
+    }
+    catch (error) {
+        if (error instanceof PiSpiValidationError) {
+            console.error('Validation error:', error.errors);
+        }
+        else if (error instanceof PiSpiAuthError) {
+            console.error('Authentication error:', error.message);
+        }
+        else if (error instanceof PiSpiError) {
+            console.error('API error:', error.message, error.statusCode);
+        }
+        else if (error instanceof Error) {
+            console.error('Unexpected error:', error.message);
+        }
+        else {
+            console.error('Unknown error:', error);
+        }
+    }
+}

package/dist/generated/core/ApiError.d.ts

@@ -0,0 +1,10 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+export declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}

package/dist/generated/core/ApiError.js

@@ -0,0 +1,11 @@
+export class ApiError extends Error {
+    constructor(request, response, message) {
+        super(message);
+        this.name = 'ApiError';
+        this.url = response.url;
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.body = response.body;
+        this.request = request;
+    }
+}

package/dist/generated/core/ApiRequestOptions.d.ts

@@ -0,0 +1,13 @@
+export type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};

package/dist/generated/core/ApiRequestOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/core/ApiResult.d.ts

@@ -0,0 +1,7 @@
+export type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};

package/dist/generated/core/ApiResult.js

@@ -0,0 +1 @@
+export {};