pi-spi-sdk 0.1.3 → 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,4940 @@
+declare const PISPI_AMBER_LOGO_DATA_URL: string;
+declare const PISPI_QRCODE_LOGO_DATA_URL: string;
+declare const DEFAULT_PISPI_LOGO_DATA_URL: string;
+
+type QrType = 'STATIC' | 'DYNAMIC';
+interface QrPayloadInput {
+    alias: string;
+    countryCode: string;
+    qrType: QrType;
+    referenceLabel: string;
+    amount?: number | string;
+}
+interface AdditionalDataOverrides {
+    merchantChannel?: string;
+    purposeOfTransaction?: string;
+    /**
+     * Free form additional data embedded inside template 62 (id => value)
+     * Keys must be 2-digit strings according to EMV specification.
+     */
+    custom?: Record<string, string>;
+}
+interface QrPayloadOptions {
+    /**
+     * Override default Additional Data tags.
+     */
+    additionalData?: AdditionalDataOverrides;
+}
+interface QrPayloadResult {
+    payload: string;
+}
+interface QrValidationResult {
+    valid: boolean;
+    errors: string[];
+    data?: QrPayloadInput;
+}
+interface QrCodeSvgOptions {
+    size?: number;
+    margin?: number;
+    logoDataUrl?: string;
+    logoSizeRatio?: number;
+    logoPaddingRatio?: number;
+    logoBackgroundColor?: string;
+    logoBorderRadiusRatio?: number;
+    dotColor?: string;
+    backgroundColor?: string;
+}
+/**
+ * Génère la payload EMV conforme PI-SPI pour un QR Code.
+ */
+declare function createQrPayload(input: QrPayloadInput, options?: QrPayloadOptions): QrPayloadResult;
+declare function computeCrc16(input: string): string;
+declare function buildPayloadString(params: QrPayloadInput, options?: QrPayloadOptions): string;
+declare function generateQrCodeSvg(input: QrPayloadInput, options?: QrCodeSvgOptions): Promise<string>;
+declare const QRCode: {
+    createQrPayload: typeof createQrPayload;
+    buildPayloadString: typeof buildPayloadString;
+    computeCrc16: typeof computeCrc16;
+    generateQrCodeSvg: typeof generateQrCodeSvg;
+    isValidPispiQrPayload: typeof isValidPispiQrPayload;
+    payload: typeof buildPayloadString;
+    svg: typeof generateQrCodeSvg;
+    validate: typeof isValidPispiQrPayload;
+    raw: typeof createQrPayload;
+};
+
+declare function isValidPispiQrPayload(value: string): QrValidationResult;
+
+/**
+ * Error handler utility for converting API errors to SDK errors
+ */
+/**
+ * Convert a generated API error to a SDK error
+ */
+declare function handleApiError(error: unknown): never;
+
+/**
+ * PI-SPI SDK Configuration
+ */
+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: undici/fetch dispatcher (e.g. mTLS Agent)
+     */
+    dispatcher?: unknown;
+    /**
+     * 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;
+}
+
+/**
+ * Base service class with common error handling and HTTP request capability
+ */
+interface ApiConfig {
+    BASE: string;
+    TOKEN?: string;
+    HEADERS?: Record<string, string>;
+    dispatcher?: unknown;
+}
+declare abstract class BaseService {
+    protected config: ApiConfig;
+    constructor(config: ApiConfig);
+    /**
+     * Wrap an async operation with error handling
+     */
+    protected execute<T>(operation: () => Promise<T>): Promise<T>;
+    /**
+     * Make an HTTP request
+     */
+    protected request<T>(method: string, path: string, body?: any, params?: Record<string, any>): Promise<T>;
+}
+
+/**
+ * Query builder utility for constructing filter, pagination, and sorting parameters
+ */
+type FilterOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'contains' | 'notContains' | 'beginsWith' | 'endsWith' | 'exists';
+interface QueryParams {
+    [key: string]: string | number | undefined;
+}
+declare class QueryBuilder {
+    private params;
+    private filters;
+    private sortField?;
+    private sortOrder;
+    /**
+     * Add a filter condition
+     * @param field - Field name to filter on
+     * @param operator - Filter operator (default: 'eq')
+     * @param value - Filter value
+     */
+    filter(field: string, operatorOrValue: FilterOperator | string | number | boolean, value?: string | number | boolean | string[]): this;
+    /**
+     * Add an equality filter (shorthand)
+     */
+    eq(field: string, value: string | number | boolean): this;
+    /**
+     * Add a "not equal" filter (shorthand)
+     */
+    ne(field: string, value: string | number | boolean): this;
+    /**
+     * Add a "greater than" filter (shorthand)
+     */
+    gt(field: string, value: string | number): this;
+    /**
+     * Add a "greater than or equal" filter (shorthand)
+     */
+    gte(field: string, value: string | number): this;
+    /**
+     * Add a "less than" filter (shorthand)
+     */
+    lt(field: string, value: string | number): this;
+    /**
+     * Add a "less than or equal" filter (shorthand)
+     */
+    lte(field: string, value: string | number): this;
+    /**
+     * Add an "in" filter (shorthand)
+     */
+    in(field: string, values: string[]): this;
+    /**
+     * Add a "contains" filter (shorthand)
+     */
+    contains(field: string, value: string): this;
+    /**
+     * Set sort field and order
+     * @param field - Field to sort by
+     * @param order - Sort order ('asc' or 'desc', default: 'asc')
+     */
+    sort(field: string, order?: 'asc' | 'desc'): this;
+    /**
+     * Sort in descending order (shorthand)
+     */
+    sortDesc(field: string): this;
+    /**
+     * Set page number
+     */
+    page(page: number | string): this;
+    /**
+     * Set page size
+     */
+    size(size: number): this;
+    /**
+     * Add a custom parameter
+     */
+    param(key: string, value: string | number): this;
+    /**
+     * Build the query parameters object
+     */
+    build(): QueryParams;
+    /**
+     * Build query string
+     */
+    buildQueryString(): string;
+    /**
+     * Reset the builder
+     */
+    reset(): this;
+    private isOperator;
+}
+
+/**
+ * Accounts (Comptes) service wrapper
+ *
+ * Provides methods for managing accounts, viewing balances,
+ * listing operations, and performing intra-account transfers.
+ *
+ * @example
+ * ```typescript
+ * // Get account balance and details
+ * const account = await sdk.comptes.getAccount('CIC2344256727788288822');
+ * console.log('Balance:', account.solde); // Amount in centimes
+ * console.log('Status:', account.statut); // 'OUVERT', 'BLOQUE', or 'CLOTURE'
+ *
+ * // List operations with pagination
+ * const operations = await sdk.comptes.listOperations({
+ *   comptePayeur: 'CIC2344256727788288822',
+ *   page: 1,
+ *   size: 20
+ * });
+ * ```
+ */
+
+declare class ComptesService$1 extends BaseService {
+    /**
+     * Get account details and balance
+     *
+     * **Returns:**
+     * - Account type (CACC, SVGS, etc.)
+     * - Account number
+     * - Current balance (`solde` in centimes)
+     * - Account status (OUVERT, BLOQUE, CLOTURE)
+     * - Opening date
+     * - Pre-confirmation indicator
+     *
+     * @param numero - Account number (e.g., 'CIC2344256727788288822')
+     * @returns Account details including balance
+     * @throws {PiSpiNotFoundError} If account not found
+     * @throws {PiSpiAuthError} If authentication fails
+     *
+     * @example
+     * ```typescript
+     * const account = await sdk.comptes.getAccount('CIC2344256727788288822');
+     * // Returns: {
+     * //   type: 'CACC',
+     * //   numero: 'CIC2344256727788288822',
+     * //   solde: 150000000, // 1,500,000 XOF in centimes
+     * //   statut: 'OUVERT',
+     * //   dateOuverture: '2023-02-21T15:30:01.250Z'
+     * // }
+     * ```
+     */
+    getAccount(numero: string): Promise<{
+        type?: string;
+        numero?: string;
+        solde?: number;
+        balance?: number;
+        statut?: string;
+        dateOuverture?: string;
+    }>;
+    /**
+     * List account operations (transactions)
+     *
+     * **Filtering Options:**
+     * - Filter by account number (`comptePayeur`, `comptePaye`)
+     * - Filter by status (`statut`: INITIE, ENVOYE, IRREVOCABLE, REJETE)
+     * - Filter by dates (`dateEnvoi`, `dateIrrevocabilite`)
+     * - Use QueryBuilder for advanced filtering
+     *
+     * @param params - Query parameters for filtering and pagination
+     * @param params.comptePayeur - Filter by payer account number
+     * @param params.comptePaye - Filter by payee account number
+     * @param params.statut - Filter by transaction status
+     * @param params.dateEnvoi - Filter by send date
+     * @param params.dateIrrevocabilite - Filter by irrevocability date
+     * @param params.page - Page number (default: 1)
+     * @param params.size - Page size (default: 20, max: 100)
+     * @returns Paginated list of operations
+     *
+     * @example
+     * ```typescript
+     * // List all operations for an account
+     * const operations = await sdk.comptes.listOperations({
+     *   comptePayeur: 'CIC2344256727788288822',
+     *   page: 1,
+     *   size: 20
+     * });
+     *
+     * // Filter by status
+     * const completed = await sdk.comptes.listOperations({
+     *   comptePayeur: 'CIC2344256727788288822',
+     *   statut: 'IRREVOCABLE'
+     * });
+     * ```
+     */
+    listOperations(params?: QueryParams & {
+        comptePayeur?: string;
+        comptePaye?: string;
+        statut?: string;
+        dateEnvoi?: string;
+        dateIrrevocabilite?: string;
+    }): Promise<unknown>;
+    /**
+     * Transfer funds between accounts owned by the same client
+     *
+     * **Intra-Account Transfer:**
+     * - Transfers between accounts owned by the same legal entity
+     * - Accounts must be at the same financial institution
+     * - Can use account numbers or aliases
+     *
+     * **Transfer Methods:**
+     * - Using account numbers: `comptePayeur` and `comptePaye`
+     * - Using aliases: `payeurAlias` and `payeAlias`
+     *
+     * @param transfer - Transfer request details
+     * @param transfer.comptePayeur - Payer account number (if using account numbers)
+     * @param transfer.comptePaye - Payee account number (if using account numbers)
+     * @param transfer.payeurAlias - Payer alias (if using aliases)
+     * @param transfer.payeAlias - Payee alias (if using aliases)
+     * @param transfer.montant - Amount in centimes (e.g., 150000 = 1,500 XOF)
+     * @param transfer.motif - Transfer reason/description
+     * @param transfer.txId - Unique transaction ID (optional, auto-generated if not provided)
+     * @returns Transfer response with status
+     * @throws {PiSpiValidationError} If transfer fails validation
+     * @throws {PiSpiError} If account blocked or insufficient funds
+     *
+     * @example
+     * ```typescript
+     * // Transfer using account numbers
+     * await sdk.comptes.transfer({
+     *   comptePayeur: 'CIC2344256727788288822',
+     *   comptePaye: 'SNC2344256727788288822',
+     *   montant: 150000, // 1,500 XOF
+     *   motif: 'Transfert de fonds',
+     *   txId: '23511722'
+     * });
+     *
+     * // Transfer using aliases
+     * await sdk.comptes.transfer({
+     *   payeurAlias: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f',
+     *   payeAlias: '4r5ty499-3e50-435b-b757-ac7a83d67juio',
+     *   montant: 150000,
+     *   motif: 'Transfert entre comptes'
+     * });
+     * ```
+     */
+    transfer(transfer: {
+        comptePayeur?: string;
+        comptePaye?: string;
+        payeurAlias?: string;
+        payeAlias?: string;
+        montant: number;
+        motif?: string;
+        txId?: string;
+    }): Promise<unknown>;
+}
+
+/**
+ * Alias Types for PI-SPI
+ *
+ * The PI-SPI platform supports different types of account aliases:
+ *
+ * - **SHID**: A randomly generated 36-character unique payment address (UUID format).
+ *   Generated by the system when created. Available for all client types (P, C, B, G).
+ *   Example: `8b1b2499-3e50-435b-b757-ac7a83d8aa7f`
+ *
+ * - **MCOD**: Merchant code identifier for USSD payment support.
+ *   Available for business clients only (C, B, G). Format: alphanumeric code.
+ *   Example: `SNF00_2E4TY`
+ *
+ * - **MBNO**: Mobile phone number alias.
+ *   Available for individual clients (P) only. Format: phone number.
+ *   Example: `+221771234567`
+ *
+ * **Client Type Restrictions:**
+ * - Type P (Individuals): Can create MBNO and SHID aliases
+ * - Types C, B, G (Businesses): Can create SHID and MCOD aliases
+ *
+ * **Limits:**
+ * - Default limit: 20 aliases per account
+ * - Limit can be increased based on client needs
+ */
+/**
+ * Alias type values as defined in the PI-SPI API specification
+ */
+declare const AliasType: {
+    /**
+     * SHID - System-generated unique payment address (UUID format, 36 characters)
+     * Available for all client types: P, C, B, G
+     */
+    readonly SHID: "SHID";
+    /**
+     * MCOD - Merchant code for USSD payment support
+     * Available for business clients only: C, B, G
+     */
+    readonly MCOD: "MCOD";
+    /**
+     * MBNO - Mobile phone number alias
+     * Available for individual clients only: P
+     */
+    readonly MBNO: "MBNO";
+};
+/**
+ * Type representing a valid alias type
+ */
+type AliasType = (typeof AliasType)[keyof typeof AliasType];
+/**
+ * Valid alias types as a tuple for runtime validation
+ */
+declare const ALIAS_TYPES: readonly ["SHID", "MCOD", "MBNO"];
+/**
+ * Check if a string is a valid alias type
+ */
+declare function isValidAliasType(value: string): value is AliasType;
+/**
+ * Get available alias types for a client type
+ *
+ * @param clientType - Client type: 'P' (Individual), 'C' (Merchant), 'B' (Business), 'G' (Government)
+ * @returns Array of available alias types for the client type
+ */
+declare function getAvailableAliasTypes(clientType: 'P' | 'C' | 'B' | 'G'): AliasType[];
+
+/**
+ * Aliases service wrapper
+ *
+ * Provides methods for managing account aliases.
+ *
+ * @example
+ * ```typescript
+ * // Create a SHID alias (available for all client types)
+ * const alias = await sdk.alias.create({
+ *   compte: 'CIC2344256727788288822',
+ *   type: AliasType.SHID
+ * });
+ * // Returns: { cle: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f', type: 'SHID', ... }
+ *
+ * // Create an MCOD alias (business clients only)
+ * const merchantAlias = await sdk.alias.create({
+ *   compte: 'SNC2344256727788288822',
+ *   type: AliasType.MCOD
+ * });
+ * // Returns: { cle: 'SNF00_2E4TY', type: 'MCOD', ... }
+ * ```
+ */
+
+declare class AliasService$1 extends BaseService {
+    /**
+     * Create an account alias
+     *
+     * **Alias Types:**
+     * - `SHID`: System-generated unique payment address (UUID format, 36 chars). Available for all client types (P, C, B, G)
+     * - `MCOD`: Merchant code for USSD payments. Available for business clients only (C, B, G)
+     * - `MBNO`: Mobile phone number. Available for individuals only (P)
+     *
+     * **Limits:**
+     * - Default: 20 aliases per account
+     * - Limit can be increased based on client needs
+     *
+     * @param alias - Alias creation data
+     * @param alias.compte - Account number (e.g., 'CIC2344256727788288822')
+     * @param alias.type - Alias type: 'SHID', 'MCOD', or 'MBNO'
+     * @returns Created alias with generated `cle` (key) value
+     * @throws {PiSpiError} If account not found or limit exceeded
+     *
+     * @example
+     * ```typescript
+     * // For business clients (C, B, G)
+     * await sdk.alias.create({
+     *   compte: 'SNC2344256727788288822',
+     *   type: AliasType.SHID
+     * });
+     * ```
+     */
+    create(alias: {
+        compte: string;
+        type: AliasType;
+    }): Promise<{
+        cle?: string;
+        type?: string;
+        compte?: string;
+    }>;
+    /**
+     * List aliases for an account
+     *
+     * @param compte - Account number
+     * @param params - Query parameters for pagination
+     * @returns Paginated list of aliases
+     */
+    list(compte: string, params?: QueryParams): Promise<unknown>;
+    /**
+     * Delete an alias
+     *
+     * @param alias - Alias identifier
+     */
+    delete(alias: string, compte?: string): Promise<unknown>;
+}
+
+/**
+ * Webhooks (Notifications) service wrapper
+ *
+ * Provides methods for managing webhook configurations to receive real-time notifications
+ * about payment events, payment requests, and fund returns.
+ *
+ * **Supported Events:**
+ * - Payment events: `PAIEMENT_RECU`, `PAIEMENT_ENVOYE`, `PAIEMENT_REJETE`
+ * - Payment request events: `RTP_RECU`, `RTP_REJETE`
+ * - Fund return events: `RETOUR_ENVOYE`, `RETOUR_REJETE`, `RETOUR_RECU`
+ * - Cancellation events: `ANNULATION_DEMANDE`, `ANNULATION_REJETE`
+ *
+ * **Webhook Security:**
+ * - All communications must use SSL/TLS
+ * - mTLS authentication required (certificate from BCEAO CA)
+ * - Events are signed with HMAC for data integrity
+ *
+ * @example
+ * ```typescript
+ * // Create webhook for payment notifications
+ * const webhook = await sdk.webhooks.create({
+ *   callbackUrl: 'https://business.example.com/api/webhooks/pi-spi',
+ *   events: ['PAIEMENT_RECU', 'PAIEMENT_ENVOYE']
+ * });
+ * ```
+ */
+
+declare class WebhooksService extends BaseService {
+    /**
+     * Create a webhook configuration
+     *
+     * **Webhook Setup:**
+     * - URL must be HTTPS
+     * - Server must support mTLS with BCEAO-issued certificate
+     * - Server must validate HMAC signatures
+     * - Server must respond with 2xx status code
+     *
+     * **Event Types:**
+     * - `PAIEMENT_RECU`: Payment received
+     * - `PAIEMENT_ENVOYE`: Payment sent (irreversible)
+     * - `PAIEMENT_REJETE`: Payment rejected
+     * - `RTP_RECU`: Payment request received
+     * - `RTP_REJETE`: Payment request rejected
+     * - `RETOUR_ENVOYE`: Fund return sent
+     * - `RETOUR_REJETE`: Fund return rejected
+     * - `RETOUR_RECU`: Fund return received
+     * - `ANNULATION_DEMANDE`: Cancellation request received
+     * - `ANNULATION_REJETE`: Cancellation request rejected
+     *
+     * @param webhook - Webhook configuration
+     * @param webhook.callbackUrl - HTTPS URL to receive notifications (must support mTLS)
+     * @param webhook.events - Array of event types to subscribe to
+     * @param webhook.alias - Optional: Alias-specific webhook (only notifications for this alias)
+     * @returns Created webhook configuration
+     * @throws {PiSpiValidationError} If URL is invalid or events array is empty
+     *
+     * @example
+     * ```typescript
+     * // Webhook for all payment events
+     * await sdk.webhooks.create({
+     *   callbackUrl: 'https://business.example.com/api/webhooks/pi-spi',
+     *   events: ['PAIEMENT_RECU', 'PAIEMENT_ENVOYE', 'PAIEMENT_REJETE']
+     * });
+     *
+     * // Alias-specific webhook
+     * await sdk.webhooks.create({
+     *   callbackUrl: 'https://business.example.com/api/webhooks/pi-spi',
+     *   events: ['PAIEMENT_RECU'],
+     *   alias: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f'
+     * });
+     * ```
+     */
+    create(webhook: {
+        callbackUrl: string;
+        events: string[];
+        alias?: string;
+    }): Promise<{
+        id?: string;
+        callbackUrl?: string;
+        events?: string[];
+    }>;
+    /**
+     * List all configured webhooks
+     *
+     * @param params - Query parameters for pagination
+     * @returns Paginated list of webhooks
+     *
+     * @example
+     * ```typescript
+     * const webhooks = await sdk.webhooks.list({ page: 1, size: 20 });
+     * ```
+     */
+    list(params?: QueryParams): Promise<unknown>;
+    /**
+     * Get webhook details by ID
+     *
+     * @param id - Webhook ID
+     * @returns Webhook details
+     * @throws {PiSpiNotFoundError} If webhook not found
+     */
+    get(id: string): Promise<unknown>;
+    /**
+     * Update webhook configuration
+     *
+     * @param id - Webhook ID
+     * @param webhook - Updated webhook configuration
+     * @param webhook.callbackUrl - New callback URL (optional)
+     * @param webhook.events - New event subscriptions (optional)
+     * @param webhook.alias - New alias filter (optional)
+     * @returns Updated webhook configuration
+     * @throws {PiSpiNotFoundError} If webhook not found
+     * @throws {PiSpiValidationError} If update fails validation
+     *
+     * @example
+     * ```typescript
+     * await sdk.webhooks.update('webhook-001', {
+     *   callbackUrl: 'https://updated-url.com/webhooks/pi-spi',
+     *   events: ['PAIEMENT_RECU', 'RTP_RECU']
+     * });
+     * ```
+     */
+    update(id: string, webhook: {
+        callbackUrl?: string;
+        events?: string[];
+        alias?: string;
+    }): Promise<unknown>;
+    /**
+     * Delete a webhook configuration
+     *
+     * @param id - Webhook ID
+     * @throws {PiSpiNotFoundError} If webhook not found
+     */
+    delete(id: string): Promise<unknown>;
+}
+
+/**
+ * Payment Requests (Demandes de Paiement) service wrapper
+ *
+ * Provides methods for creating and managing payment requests (bills, invoices, etc.).
+ *
+ * **Payment Request Types:**
+ * - **E-commerce** (`categorie: 521`): Online payment requests with 3-minute expiry
+ * - **Point of Sale** (`categorie: 500`): Physical store payment requests
+ * - **Invoice/Bill** (`categorie: 401`): Invoice payment requests with due dates
+ * - **PICO**: Purchase with cash withdrawal (combined purchase + cashback)
+ * - **PICASH**: Cash withdrawal only
+ *
+ * **Payment Request Flow:**
+ * 1. Business creates payment request
+ * 2. Customer receives request (via alias)
+ * 3. Customer can: Accept & Pay Now, Accept & Pay Later, Reject, or Ignore
+ * 4. If accepted, payment is processed automatically
+ *
+ * @example
+ * ```typescript
+ * // Create invoice payment request
+ * const request = await sdk.demandesPaiement.create({
+ *   comptePaye: 'CIC2344256727788288822',
+ *   payeurAlias: '9b1b3499-3e50-435b-b757-ac7a83d8aa96',
+ *   montant: 150000,
+ *   categorie: '401',
+ *   dateLimitePaiement: '2023-12-31T23:59:59.999Z',
+ *   motif: 'Facture électricité mars 2023'
+ * });
+ * ```
+ */
+
+declare class DemandesPaiementService extends BaseService {
+    /**
+     * Create a payment request
+     *
+     * **Request Types:**
+     * - **E-commerce** (`categorie: 521`): Max 3 minutes validity
+     * - **POS** (`categorie: 500`): Max 24 hours validity
+     * - **Invoice** (`categorie: 401`): Custom due date (up to 90 days)
+     *
+     * **Confirmation Options:**
+     * - `confirmation: false`: Request sent immediately (default for POS)
+     * - `confirmation: true`: Returns payer info for verification before sending
+     *
+     * **Customer Actions:**
+     * - Accept & Pay Now: Payment processed immediately
+     * - Accept & Pay Later: Payment scheduled (if dateLimiteReponse > 24h)
+     * - Reject: Request rejected with reason
+     * - Ignore: Request expires after dateLimiteReponse
+     *
+     * @param request - Payment request creation data
+     * @param request.comptePaye - Business account number (payee)
+     * @param request.payeurAlias - Customer alias (payer)
+     * @param request.montant - Amount in centimes (e.g., 150000 = 1,500 XOF)
+     * @param request.categorie - Request category: '500' (POS), '521' (E-commerce), '401' (Invoice)
+     * @param request.motif - Payment reason/description
+     * @param request.txId - Unique transaction ID (optional)
+     * @param request.dateLimitePaiement - Payment due date (required for e-commerce and invoices)
+     * @param request.dateLimiteReponse - Response deadline (default: 90 days from creation)
+     * @param request.confirmation - Whether to require confirmation (default: false for POS, true for invoices)
+     * @param request.refDocType - Reference document type (e.g., 'CINV' for invoice)
+     * @param request.refDocNumero - Reference document number (e.g., invoice number)
+     * @returns Payment request response
+     * @throws {PiSpiValidationError} If request fails validation
+     *
+     * @example
+     * ```typescript
+     * // E-commerce payment request (3-minute expiry)
+     * await sdk.demandesPaiement.create({
+     *   comptePaye: 'CIC2344256727788288822',
+     *   payeurAlias: '9b1b3499-3e50-435b-b757-ac7a83d8aa96',
+     *   montant: 25000, // 250 XOF
+     *   categorie: '521',
+     *   dateLimitePaiement: '2023-02-21T15:37:00.000Z', // 3 minutes from now
+     *   motif: 'Paiement du livre Manuel des écritures comptables'
+     * });
+     *
+     * // Invoice payment request
+     * await sdk.demandesPaiement.create({
+     *   comptePaye: 'CIC2344256727788288822',
+     *   payeurAlias: '9b1b3499-3e50-435b-b757-ac7a83d8aa96',
+     *   montant: 150000, // 1,500 XOF
+     *   categorie: '401',
+     *   dateLimitePaiement: '2023-12-31T23:59:59.999Z',
+     *   motif: 'Facture électricité mars 2023',
+     *   refDocType: 'CINV',
+     *   refDocNumero: 'FACT-ELEC-202303',
+     *   confirmation: true
+     * });
+     * ```
+     */
+    create(request: {
+        comptePaye: string;
+        payeurAlias: string;
+        montant: number;
+        categorie: string;
+        motif: string;
+        txId?: string;
+        dateLimitePaiement?: string;
+        dateLimiteReponse?: string;
+        confirmation?: boolean;
+        refDocType?: string;
+        refDocNumero?: string;
+    }): Promise<{
+        statut?: string;
+        txId?: string;
+        dateLimiteReponse?: string;
+    }>;
+    /**
+     * List payment requests with filtering and pagination
+     *
+     * @param params - Query parameters for filtering and pagination
+     * @returns Paginated list of payment requests
+     */
+    list(params?: QueryParams): Promise<unknown>;
+    /**
+     * Get payment request details
+     *
+     * @param id - Payment request transaction ID
+     * @returns Payment request details
+     * @throws {PiSpiNotFoundError} If request not found
+     */
+    get(id: string): Promise<{
+        statut?: string;
+        txId?: string;
+        montant?: number;
+        dateEnvoi?: string;
+        dateIrrevocabilite?: string;
+        dateRejet?: string;
+        dateLimiteReponse?: string;
+    }>;
+    /**
+     * Accept a payment request
+     *
+     * **Note:** This is typically called by the customer's payment app, not the business.
+     * The business receives notification when customer accepts.
+     *
+     * @param id - Payment request transaction ID
+     * @param immediate - Whether to pay immediately (true) or schedule payment (false)
+     * @returns Payment confirmation response
+     */
+    accept(id: string, immediate?: boolean): Promise<unknown>;
+    /**
+     * Reject a payment request
+     *
+     * **Note:** This is typically called by the customer's payment app, not the business.
+     * The business receives notification when customer rejects.
+     *
+     * @param id - Payment request transaction ID
+     * @param reason - Rejection reason code (optional)
+     * @returns Rejection confirmation response
+     */
+    reject(id: string, reason?: string): Promise<unknown>;
+    /**
+     * Confirm sending a payment request created with confirmation: true
+     */
+    confirm(txId: string, decision: boolean): Promise<unknown>;
+}
+
+/**
+ * Bulk Payment Requests (Demandes de Paiement en Masse) service wrapper
+ *
+ * Provides methods for creating and managing bulk payment requests.
+ */
+
+declare class DemandesPaiementEnMasseService extends BaseService {
+    /**
+     * Create bulk payment requests
+     */
+    create(request: {
+        comptePaye: string;
+        transactions: Array<{
+            txId: string;
+            payeurAlias: string;
+            montant: number;
+            motif: string;
+            categorie?: string;
+            dateLimitePaiement?: string;
+            refDocType?: string;
+            refDocNumero?: string;
+        }>;
+        confirmation?: boolean;
+    }): Promise<unknown>;
+    /**
+     * Get bulk payment request details and status
+     */
+    get(instructionId: string): Promise<unknown>;
+    /**
+     * Confirm and send bulk payment requests
+     */
+    confirm(instructionId: string): Promise<unknown>;
+}
+
+/**
+ * Payments (Paiements) service wrapper
+ *
+ * Provides methods for creating and managing immediate payments.
+ *
+ * **Payment Types Supported:**
+ * - **Bank-to-Bank**: Payments between bank accounts via API (`categorie: 733`)
+ * - **Bank-to-Wallet**: Payments from bank accounts to mobile wallets
+ * - **Wallet-to-Wallet**: Payments between mobile wallets
+ * - **Wallet-to-Bank**: Payments from mobile wallets to bank accounts
+ *
+ * All payment types are interoperable across the UEMOA region (8 countries).
+ *
+ * @example
+ * ```typescript
+ * // Create immediate payment
+ * const payment = await sdk.paiements.create({
+ *   comptePayeur: 'CIC2344256727788288822',
+ *   payeAlias: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f',
+ *   montant: 150000, // 1,500 XOF
+ *   motif: 'Paiement de services'
+ * });
+ * ```
+ */
+
+declare class PaiementsService extends BaseService {
+    /**
+     * Create an immediate payment
+     *
+     * **Payment Flow:**
+     * - If `confirmation: false`: Payment is sent immediately (default)
+     * - If `confirmation: true`: Payment is initiated, returns payee info for confirmation
+     *
+     * **Supported Transaction Types:**
+     * - Bank-to-Bank (`categorie: 733`)
+     * - Bank-to-Wallet (via alias lookup)
+     * - Wallet-to-Wallet (via alias lookup)
+     * - Wallet-to-Bank (via alias lookup)
+     *
+     * **Status Values:**
+     * - `INITIE`: Waiting for confirmation (if confirmation: true)
+     * - `ENVOYE`: Payment sent successfully
+     * - `IRREVOCABLE`: Payment confirmed and cannot be reversed
+     * - `REJETE`: Payment rejected (check `statutRaison` for error code)
+     *
+     * @param payment - Payment creation data
+     * @param payment.comptePayeur - Payer account number (e.g., 'CIC2344256727788288822')
+     * @param payment.payeAlias - Payee alias (SHID, MCOD, or MBNO format)
+     * @param payment.montant - Amount in centimes (e.g., 150000 = 1,500 XOF)
+     * @param payment.motif - Payment reason/description
+     * @param payment.txId - Unique transaction ID (optional, auto-generated if not provided)
+     * @param payment.confirmation - Whether to require confirmation before sending (default: false)
+     * @param payment.categorie - Payment category/canal (default: 733 for API Business)
+     * @returns Payment response with status
+     * @throws {PiSpiValidationError} If payment fails validation (e.g., invalid alias, duplicate txId)
+     * @throws {PiSpiError} If account blocked or insufficient funds
+     *
+     * @example
+     * ```typescript
+     * // Immediate payment (no confirmation)
+     * const payment = await sdk.paiements.create({
+     *   comptePayeur: 'CIC2344256727788288822',
+     *   payeAlias: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f', // SHID alias
+     *   montant: 150000, // 1,500 XOF
+     *   motif: 'Paiement de services',
+     *   txId: '23552722'
+     * });
+     *
+     * // Payment with confirmation (returns payee info)
+     * const paymentWithConfirmation = await sdk.paiements.create({
+     *   comptePayeur: 'CIC2344256727788288822',
+     *   payeAlias: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f',
+     *   montant: 3000000, // 30,000 XOF
+     *   confirmation: true
+     * });
+     * ```
+     */
+    create(payment: {
+        comptePayeur?: string;
+        payeurAlias?: string;
+        payeAlias: string;
+        comptePaye?: string;
+        montant: number;
+        motif: string;
+        txId?: string;
+        confirmation?: boolean;
+        categorie?: string;
+    }): Promise<{
+        statut?: string;
+        txId?: string;
+        statutRaison?: string;
+    }>;
+    /**
+     * Get payment details by transaction ID
+     *
+     * @param txId - Transaction ID
+     * @returns Payment details including status and history
+     * @throws {PiSpiNotFoundError} If payment not found
+     *
+     * @example
+     * ```typescript
+     * const payment = await sdk.paiements.get('23552722');
+     * console.log('Status:', payment.statut); // 'IRREVOCABLE'
+     * console.log('Amount:', payment.montant); // 150000
+     * ```
+     */
+    get(txId: string): Promise<{
+        statut?: string;
+        txId?: string;
+        montant?: number;
+        dateEnvoi?: string;
+        dateIrrevocabilite?: string;
+        dateRejet?: string;
+    }>;
+    /**
+     * List payments with filtering and pagination
+     *
+     * **Filter Options:**
+     * - Filter by account: `comptePayeur`
+     * - Filter by status: `statut` (INITIE, ENVOYE, IRREVOCABLE, REJETE)
+     * - Filter by dates: `dateEnvoi`, `dateIrrevocabilite`
+     * - Use QueryBuilder for advanced filtering
+     *
+     * @param params - Query parameters for filtering and pagination
+     * @returns Paginated list of payments
+     *
+     * @example
+     * ```typescript
+     * // List all payments for an account
+     * const payments = await sdk.paiements.list({
+     *   comptePayeur: 'CIC2344256727788288822',
+     *   page: 1,
+     *   size: 20
+     * });
+     *
+     * // Filter by status
+     * const completed = await sdk.paiements.list({
+     *   comptePayeur: 'CIC2344256727788288822',
+     *   statut: 'IRREVOCABLE'
+     * });
+     * ```
+     */
+    list(params?: QueryParams & {
+        comptePayeur?: string;
+        statut?: string;
+    }): Promise<unknown>;
+    /**
+     * Confirm a payment that was created with confirmation: true
+     */
+    confirm(txId: string, decision: boolean, body?: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Verify payment status by end-to-end ID
+     */
+    verifyStatus(end2endId: string): Promise<unknown>;
+}
+
+/**
+ * Bulk Payments (Paiements en Masse) service wrapper
+ *
+ * Provides methods for creating and managing bulk payment operations.
+ *
+ * **Bulk Payment Features:**
+ * - Process multiple payments in a single request
+ * - Linked by unique `instructionId`
+ * - Can retry failed payments
+ * - Supports up to 10,000 transactions per bulk (recommended: 500-5,000)
+ *
+ * **Transaction Size:**
+ * - Max size per transaction: ~310 bytes
+ * - Max bulk size: ~3.1 MB for 10,000 transactions
+ * - Recommended: 500-5,000 transactions per bulk
+ *
+ * **Use Cases:**
+ * - Salary payments
+ * - Vendor payments
+ * - Bulk disbursements
+ * - Mass refunds
+ *
+ * @example
+ * ```typescript
+ * // Create bulk payment
+ * const bulkPayment = await sdk.paiementsEnMasse.createBulk({
+ *   comptePayeur: 'CIC2344256727788288822',
+ *   instructionId: 'BULK-2023-001',
+ *   transactions: [
+ *     { txId: 'TX001', payeAlias: 'alias1', montant: 100000, motif: 'Salaire' },
+ *     { txId: 'TX002', payeAlias: 'alias2', montant: 150000, motif: 'Salaire' }
+ *   ]
+ * });
+ * ```
+ */
+
+declare class PaiementsEnMasseService extends BaseService {
+    /**
+     * Create bulk payments
+     *
+     * **Bulk Processing:**
+     * - All transactions share the same `instructionId`
+     * - Each transaction needs unique `txId`
+     * - Transactions are processed in parallel
+     * - Failed transactions can be retried
+     *
+     * **Performance Considerations:**
+     * - Larger bulks take longer to process
+     * - May hit HTTP timeout for very large bulks
+     * - Recommended: 500-5,000 transactions per bulk
+     * - For >10,000 transactions, split into multiple bulks
+     *
+     * **Response Status:**
+     * - `INITIE`: Bulk created, awaiting confirmation
+     * - `ENVOYE`: Bulk sent, transactions processing
+     * - `IRREVOCABLE`: All transactions completed
+     * - `PARTIEL`: Some transactions succeeded, some failed
+     * - `REJETE`: Bulk rejected (validation failed)
+     *
+     * @param payment - Bulk payment creation data
+     * @param payment.comptePayeur - Payer account number
+     * @param payment.instructionId - Unique bulk instruction ID
+     * @param payment.transactions - Array of payment transactions
+     * @param payment.transactions[].txId - Unique transaction ID (must be unique within bulk)
+     * @param payment.transactions[].payeAlias - Payee alias (SHID, MCOD, or MBNO)
+     * @param payment.transactions[].montant - Amount in centimes
+     * @param payment.transactions[].motif - Payment reason/description
+     * @param payment.transactions[].refDocType - Reference document type (optional)
+     * @param payment.transactions[].refDocNumero - Reference document number (optional)
+     * @returns Bulk payment response with status and summary
+     * @throws {PiSpiValidationError} If bulk fails validation (e.g., duplicate txId, invalid alias)
+     * @throws {PiSpiError} If account blocked or insufficient funds
+     *
+     * @example
+     * ```typescript
+     * // Create bulk payment for salary disbursement
+     * await sdk.paiementsEnMasse.createBulk({
+     *   comptePayeur: 'CIC2344256727788288822',
+     *   instructionId: 'SALARY-2023-03',
+     *   transactions: [
+     *     {
+     *       txId: 'SAL-001',
+     *       payeAlias: '8b1b2499-3e50-435b-b757-ac7a83d8aa7f',
+     *       montant: 500000, // 5,000 XOF
+     *       motif: 'Salaire mars 2023'
+     *     },
+     *     {
+     *       txId: 'SAL-002',
+     *       payeAlias: '4r5ty499-3e50-435b-b757-ac7a83d67juio',
+     *       montant: 750000, // 7,500 XOF
+     *       motif: 'Salaire mars 2023'
+     *     }
+     *   ]
+     * });
+     * ```
+     */
+    createBulk(payment: {
+        comptePayeur: string;
+        instructionId: string;
+        transactions: Array<{
+            txId: string;
+            payeAlias: string;
+            montant: number;
+            motif: string;
+            refDocType?: string;
+            refDocNumero?: string;
+        }>;
+        confirmation?: boolean;
+    }): Promise<unknown>;
+    /**
+     * Get bulk payment details and status
+     *
+     * **Response Includes:**
+     * - Overall bulk status
+     * - Transaction counts (total, succeeded, failed)
+     * - Individual transaction statuses
+     * - Failed transaction details
+     *
+     * @param instructionId - Bulk instruction ID
+     * @returns Bulk payment details with transaction statuses
+     * @throws {PiSpiNotFoundError} If bulk payment not found
+     *
+     * @example
+     * ```typescript
+     * const bulk = await sdk.paiementsEnMasse.get('SALARY-2023-03');
+     * console.log('Status:', bulk.statut); // 'IRREVOCABLE'
+     * console.log('Succeeded:', bulk.nombreSuccess); // 98
+     * console.log('Failed:', bulk.nombreEchec); // 2
+     * ```
+     */
+    get(instructionId: string): Promise<unknown>;
+    /**
+     * Confirm or retry a bulk payment
+     */
+    confirm(instructionId: string, decision?: boolean): Promise<unknown>;
+    /**
+     * Retry failed payments in a bulk payment
+     *
+     * **Retry Process:**
+     * - Only failed transactions are retried
+     * - Successful transactions are not affected
+     * - Uses same `instructionId`
+     * - Can retry multiple times if needed
+     *
+     * @param instructionId - Bulk instruction ID
+     * @returns Retry response with updated status
+     * @throws {PiSpiNotFoundError} If bulk payment not found
+     * @throws {PiSpiError} If no failed transactions to retry
+     *
+     * @example
+     * ```typescript
+     * // Retry failed transactions
+     * await sdk.paiementsEnMasse.retry('SALARY-2023-03');
+     * ```
+     */
+    retry(instructionId: string): Promise<unknown>;
+}
+
+/**
+ * Fund Returns (Retours de Fonds) service wrapper
+ *
+ * Provides methods for returning funds from received payments.
+ *
+ * **Return Rules:**
+ * - Can only return funds from payments received
+ * - Must be initiated within 90 days of original payment
+ * - After 90 days, returns are no longer possible
+ * - Returns are processed instantly when sent
+ *
+ * **Use Cases:**
+ * - Refunds for returned goods
+ * - Cancellation of services
+ * - Error corrections
+ * - Customer disputes
+ *
+ * @example
+ * ```typescript
+ * // Return funds from a received payment
+ * const returnFunds = await sdk.retoursFonds.create({
+ *   comptePaye: 'CIC2344256727788288822',
+ *   txId: '23552722', // Original payment transaction ID
+ *   montant: 150000, // Amount to return (1,500 XOF)
+ *   motif: 'CUST' // Customer request reason code
+ * });
+ * ```
+ */
+
+declare class RetoursFondsService extends BaseService {
+    /**
+     * Create a fund return
+     *
+     * **Return Process:**
+     * 1. Business identifies original payment transaction
+     * 2. Creates return request (must be within 90 days)
+     * 3. Return is processed immediately
+     * 4. Funds are returned to original payer
+     *
+     * **Status Values:**
+     * - `ENVOYE`: Return sent successfully
+     * - `IRREVOCABLE`: Return confirmed and cannot be reversed
+     * - `REJETE`: Return rejected (check `statutRaison` for error code)
+     *
+     * **Rejection Reasons:**
+     * - `AM04`: Insufficient guarantee funds
+     * - `AM09`: Wrong amount
+     * - `AC06`: Blocked account
+     * - `FR01`: Fraud suspicion
+     * - `RR04`: Regulatory reason
+     *
+     * @param returnRequest - Fund return request data
+     * @param returnRequest.comptePaye - Business account number (original payee)
+     * @param returnRequest.txId - Original payment transaction ID
+     * @param returnRequest.montant - Amount to return in centimes (e.g., 150000 = 1,500 XOF)
+     * @param returnRequest.motif - Return reason code (e.g., 'CUST' for customer request)
+     * @returns Fund return response
+     * @throws {PiSpiValidationError} If return fails validation (e.g., > 90 days, invalid txId)
+     * @throws {PiSpiError} If account blocked or insufficient funds
+     *
+     * @example
+     * ```typescript
+     * // Return full payment amount
+     * await sdk.retoursFonds.create({
+     *   comptePaye: 'CIC2344256727788288822',
+     *   txId: '23552722', // Original payment ID
+     *   montant: 150000, // 1,500 XOF
+     *   motif: 'CUST' // Customer request
+     * });
+     * ```
+     */
+    create(returnRequest: {
+        comptePaye?: string;
+        txId?: string;
+        end2endId?: string;
+        montant?: number;
+        motif?: string;
+    }): Promise<unknown>;
+    /**
+     * Get fund return details by end-to-end ID
+     */
+    get(end2endId: string): Promise<unknown>;
+    /**
+     * List payments with fund return status filter
+     */
+    list(params?: QueryParams & {
+        retourStatut?: string;
+    }): Promise<unknown>;
+}
+
+/**
+ * Cancellation Requests (Demandes d'Annulation) service wrapper
+ *
+ * Provides methods for requesting cancellation of sent payments.
+ *
+ * **Cancellation Rules:**
+ * - Can only request cancellation of payments sent by the business
+ * - Must be requested within 90 days of original payment
+ * - Payee must accept the cancellation for funds to be returned
+ * - Payee can reject the cancellation request
+ * - Multiple cancellation requests can be sent for the same payment
+ *
+ * **Cancellation Flow:**
+ * 1. Business requests cancellation of a sent payment
+ * 2. Payee receives cancellation request
+ * 3. Payee can accept (triggers fund return) or reject
+ * 4. Business receives notification of payee's decision
+ *
+ * **Use Cases:**
+ * - Payment sent to wrong recipient
+ * - Duplicate payment
+ * - Service cancellation
+ * - Agreement cancellation
+ *
+ * @example
+ * ```typescript
+ * // Request cancellation of a sent payment
+ * const cancellation = await sdk.demandesAnnulation.create({
+ *   comptePayeur: 'CIC2344256727788288822',
+ *   txId: '23552722', // Original payment transaction ID
+ *   motif: 'CUST' // Cancellation reason code
+ * });
+ * ```
+ */
+
+declare class DemandesAnnulationService extends BaseService {
+    /**
+     * Create a cancellation request
+     *
+     * **Cancellation Process:**
+     * 1. Business identifies payment to cancel
+     * 2. Creates cancellation request (must be within 90 days)
+     * 3. Payee receives cancellation request
+     * 4. Payee accepts or rejects
+     * 5. If accepted, funds are returned via fund return mechanism
+     *
+     * **Status Values:**
+     * - `INITIE`: Cancellation request sent, awaiting payee response
+     * - `ACCEPTE`: Payee accepted cancellation (funds returned)
+     * - `REJETE`: Payee rejected cancellation request
+     *
+     * **Rejection Reasons:**
+     * - `CUST`: Customer rejection (payee refuses cancellation)
+     * - `AM09`: Wrong amount
+     * - `AC06`: Blocked account
+     * - `FR01`: Fraud suspicion
+     *
+     * @param request - Cancellation request data
+     * @param request.comptePayeur - Business account number (original payer)
+     * @param request.txId - Original payment transaction ID to cancel
+     * @param request.motif - Cancellation reason code (e.g., 'CUST' for customer request)
+     * @returns Cancellation request response
+     * @throws {PiSpiValidationError} If cancellation fails validation (e.g., > 90 days, invalid txId)
+     * @throws {PiSpiNotFoundError} If payment not found
+     *
+     * @example
+     * ```typescript
+     * // Request cancellation
+     * await sdk.demandesAnnulation.create({
+     *   comptePayeur: 'CIC2344256727788288822',
+     *   txId: '23552722', // Payment to cancel
+     *   motif: 'CUST' // Customer request
+     * });
+     * ```
+     */
+    create(request: {
+        comptePayeur?: string;
+        txId?: string;
+        end2endId?: string;
+        motif: string;
+    }): Promise<unknown>;
+    /**
+     * Get cancellation request details by end-to-end ID
+     */
+    get(end2endId: string): Promise<unknown>;
+    /**
+     * List payments with cancellation status filter
+     */
+    list(params?: QueryParams & {
+        annulationStatut?: string;
+    }): Promise<unknown>;
+    /**
+     * Respond to a cancellation request (accept or reject)
+     */
+    respond(end2endId: string, decision: boolean): Promise<unknown>;
+}
+
+declare class PiSpiSDK {
+    /**
+     * Accounts service
+     * Handles account-related operations: balance, operations, transfers
+     */
+    readonly comptes: ComptesService$1;
+    /**
+     * Aliases service
+     * Handles account alias management
+     */
+    readonly alias: AliasService$1;
+    /**
+     * Webhooks service
+     * Handles webhook configuration and management
+     */
+    readonly webhooks: WebhooksService;
+    /**
+     * Payment requests service
+     * Handles payment request creation and management
+     */
+    readonly demandesPaiement: DemandesPaiementService;
+    /**
+     * Bulk payment requests service
+     * Handles bulk payment request operations
+     */
+    readonly demandesPaiementEnMasse: DemandesPaiementEnMasseService;
+    /**
+     * Payments service
+     * Handles immediate payment operations
+     */
+    readonly paiements: PaiementsService;
+    /**
+     * Bulk payments service
+     * Handles bulk payment operations
+     */
+    readonly paiementsEnMasse: PaiementsEnMasseService;
+    /**
+     * Fund returns service
+     * Handles fund return operations
+     */
+    readonly retoursFonds: RetoursFondsService;
+    /**
+     * Cancellation requests service
+     * Handles payment cancellation requests
+     */
+    readonly demandesAnnulation: DemandesAnnulationService;
+    /**
+     * QR Code utilities
+     * Generate and validate BCEAO compatible QR codes
+     */
+    readonly qr: {
+        createQrPayload: typeof createQrPayload;
+        buildPayloadString: typeof buildPayloadString;
+        computeCrc16: typeof computeCrc16;
+        generateQrCodeSvg: typeof generateQrCodeSvg;
+        isValidPispiQrPayload: typeof isValidPispiQrPayload;
+        payload: typeof buildPayloadString;
+        svg: typeof generateQrCodeSvg;
+        validate: typeof isValidPispiQrPayload;
+        raw: typeof createQrPayload;
+    };
+    private _config;
+    /**
+     * Initialize the PI-SPI SDK
+     *
+     * @param config - SDK configuration
+     *
+     * @example
+     * ```typescript
+     * const sdk = new PiSpiSDK({
+     *   baseUrl: 'https://sandbox.api.pi-bceao.com/piz/v1',
+     *   accessToken: 'your-oauth2-token',
+     * });
+     * ```
+     */
+    constructor(config: PiSpiConfig);
+    /**
+     * Update the access token
+     * Useful when tokens are refreshed
+     */
+    setAccessToken(token: string): void;
+    /**
+     * Get the current base URL
+     */
+    getBaseUrl(): string;
+}
+
+type LomiCustomerAliasType = 'SHID' | 'MBNO' | 'MCOD';
+type LomiCustomerQr = {
+    t: 'lomi.cust';
+    v: 1;
+    alias: string;
+    aliasType: LomiCustomerAliasType;
+};
+declare function buildLomiCustomerQr(input: {
+    alias: string;
+    aliasType?: LomiCustomerAliasType;
+}): LomiCustomerQr;
+declare function serializeLomiCustomerQr(qr: LomiCustomerQr): string;
+declare function parseLomiCustomerQr(raw: string): LomiCustomerQr | null;
+
+/**
+ * Custom error classes for PI-SPI SDK
+ */
+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);
+}
+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);
+}
+declare class PiSpiAuthError extends PiSpiError {
+    constructor(message: string, statusCode: number, statusText: string);
+}
+declare class PiSpiNotFoundError extends PiSpiError {
+    constructor(message: string, statusCode: number, statusText: string);
+}
+declare class PiSpiRateLimitError extends PiSpiError {
+    readonly retryAfter?: number;
+    constructor(message: string, statusCode: number, statusText: string, retryAfter?: number);
+}
+
+/**
+ * Utility functions for PI-SPI operations
+ *
+ * Common helper functions for formatting amounts, validating inputs,
+ * and other utility operations.
+ */
+/**
+ * Format amount from centimes to XOF
+ * @param centimes - Amount in centimes
+ * @returns Formatted amount string (e.g., "1 500 XOF")
+ */
+declare function formatAmount(centimes: number): string;
+/**
+ * Convert XOF to centimes
+ * @param xof - Amount in XOF
+ * @returns Amount in centimes
+ */
+declare function xofToCentimes(xof: number): number;
+/**
+ * Convert centimes to XOF
+ * @param centimes - Amount in centimes
+ * @returns Amount in XOF
+ */
+declare function centimesToXof(centimes: number): number;
+/**
+ * Validate account number format
+ * @param accountNumber - Account number to validate
+ * @returns True if valid format
+ */
+declare function isValidAccountNumber(accountNumber: string): boolean;
+/**
+ * Validate SHID alias format (UUID)
+ * @param alias - Alias to validate
+ * @returns True if valid UUID format
+ */
+declare function isValidShidAlias(alias: string): boolean;
+/**
+ * Validate phone number format (for MBNO alias)
+ * @param phoneNumber - Phone number to validate
+ * @returns True if valid format
+ */
+declare function isValidPhoneNumber(phoneNumber: string): boolean;
+/**
+ * Extract country code from account number
+ * @param accountNumber - Account number
+ * @returns Country code or null
+ */
+declare function getCountryFromAccount(accountNumber: string): string | null;
+/**
+ * Sleep/delay utility
+ * @param ms - Milliseconds to wait
+ */
+declare function sleep(ms: number): Promise<void>;
+/**
+ * Retry a function with exponential backoff
+ * @param fn - Function to retry
+ * @param maxRetries - Maximum number of retries
+ * @param initialDelay - Initial delay in milliseconds
+ */
+declare function retryWithBackoff<T>(fn: () => Promise<T>, maxRetries?: number, initialDelay?: number): Promise<T>;
+
+/**
+ * PI-SPI Constants
+ *
+ * Centralized constants for API endpoints, status codes, and configuration values
+ */
+declare const PI_SPI_ENDPOINTS: {
+    /** Production API endpoint */
+    PRODUCTION: string;
+    /** Sandbox API endpoint */
+    SANDBOX: string;
+    /** Default endpoint (sandbox) */
+    DEFAULT: string;
+};
+declare const PAYMENT_STATUS: {
+    /** Payment initiated (awaiting confirmation after alias lookup) */
+    INITIE: string;
+    /** Payment sent (validations passed, PSP has sent the request) */
+    ENVOYE: string;
+    /** Payment is confirmed/irreversible */
+    IRREVOCABLE: string;
+    /** Payment has been rejected */
+    REJETE: string;
+};
+declare const ACCOUNT_STATUS: {
+    /** Account is open */
+    OPEN: string;
+    /** Account is blocked */
+    BLOCKED: string;
+    /** Account is closed */
+    CLOSED: string;
+};
+declare const ACCOUNT_TYPE: {
+    /** Current account */
+    CURRENT: string;
+    /** Savings account */
+    SAVINGS: string;
+};
+declare const CLIENT_TYPE: {
+    /** Individual person */
+    INDIVIDUAL: string;
+    /** Merchant */
+    MERCHANT: string;
+    /** Business */
+    BUSINESS: string;
+    /** Government */
+    GOVERNMENT: string;
+};
+declare const UEMOA_COUNTRIES: {
+    BENIN: string;
+    BURKINA_FASO: string;
+    IVORY_COAST: string;
+    GUINEA_BISSAU: string;
+    MALI: string;
+    NIGER: string;
+    SENEGAL: string;
+    TOGO: string;
+};
+declare const CURRENCY: {
+    /** West African CFA Franc */
+    XOF: string;
+    /** Amounts are specified in centimes (1 XOF = 100 centimes) */
+    CENTIMES_PER_XOF: number;
+};
+declare const DEFAULT_LIMITS: {
+    /** Maximum page size for paginated requests */
+    MAX_PAGE_SIZE: number;
+    /** Default page size */
+    DEFAULT_PAGE_SIZE: number;
+    /** Default aliases per account */
+    DEFAULT_ALIASES_PER_ACCOUNT: number;
+};
+declare const WEBHOOK_EVENTS: {
+    /** Payment received */
+    PAIEMENT_RECU: string;
+    /** Payment sent */
+    PAIEMENT_ENVOYE: string;
+    /** Payment rejected */
+    PAIEMENT_REJETE: string;
+    /** Payment request (RTP) received */
+    RTP_RECU: string;
+    /** Payment request (RTP) rejected */
+    RTP_REJETE: string;
+    /** Cancellation requested */
+    ANNULATION_DEMANDE: string;
+    /** Cancellation rejected */
+    ANNULATION_REJETE: string;
+    /** Fund return sent */
+    RETOUR_ENVOYE: string;
+    /** Fund return rejected */
+    RETOUR_REJETE: string;
+    /** Fund return received */
+    RETOUR_RECU: string;
+};
+
+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>;
+};
+
+type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};
+
+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);
+}
+
+declare class CancelError extends Error {
+    constructor(message: string);
+    get isCancelled(): boolean;
+}
+interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+declare class CancelablePromise<T> implements Promise<T> {
+    #private;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}
+
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>;
+type OpenAPIConfig = {
+    BASE: string;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    TOKEN?: string | Resolver<string> | undefined;
+    USERNAME?: string | Resolver<string> | undefined;
+    PASSWORD?: string | Resolver<string> | undefined;
+    HEADERS?: Headers | Resolver<Headers> | undefined;
+    ENCODE_PATH?: ((path: string) => string) | undefined;
+};
+declare const OpenAPI: OpenAPIConfig;
+
+type AliasCreationReponse = {
+    /**
+     * Le valeur de l'alias créé
+     */
+    cle?: string;
+    /**
+     * Le type de l'alias
+     */
+    type?: string;
+    /**
+     * Le numéro de compte rattaché à l'alias
+     */
+    compte?: string;
+    /**
+     * Date au format ISO 8601
+     */
+    dateCreation?: string;
+    /**
+     * Date au format ISO 8601
+     */
+    dateModification?: string;
+};
+
+type AliasCreationRequest = {
+    /**
+     * Le client doit spécifier le type d'alias qu'il souhaite créer.
+     * Les types disponibles sont:
+     * - SHID: Adresse de paiement générée (disponible pour tous les types de clients: P, C, B, G)
+     * - MCOD: Identifiant de compte marchand pour USSD (disponible pour les clients business: C, B, G)
+     * - MBNO: Numéro de téléphone mobile (disponible pour les particuliers: P)
+     *
+     */
+    type: string;
+};
+
+type AliasReponseListe = {
+    data?: Array<AliasCreationReponse>;
+    meta?: {
+        /**
+         * total d'éléments correspondants à la recherche
+         */
+        total?: number;
+        /**
+         * nombre d'éléments retournés
+         */
+        size?: number;
+        /**
+         * numéro ou identifiant de la page suivante
+         */
+        page?: string;
+        /**
+         * numéro ou identifiant de la page suivante
+         */
+        next?: string;
+        /**
+         * numéro ou identifiant de la page précédente
+         */
+        prev?: string;
+    };
+};
+
+/**
+ * - `INITIE` si la demande d'annulation est initiée
+ * - `ENVOYE` si la demande d'annulation est envoyée
+ * - `IRREVOCABLE` lorsque le retour de fonds est irrévocable
+ * - `REJETE` lorsque la demande d'annulation est rejetée
+ *
+ */
+declare enum AnnulationStatut {
+    INITIE = "INITIE",
+    ENVOYE = "ENVOYE",
+    IRREVOCABLE = "IRREVOCABLE",
+    REJETE = "REJETE"
+}
+
+type Champs = {};
+
+type CompteOperation = {
+    /**
+     * Identifiant de la transaction dans le SI du client
+     */
+    txId: string;
+    /**
+     * Le montant du transfert à effectuer.
+     */
+    montant: number;
+    /**
+     * Le motif du transfert
+     */
+    motif?: string;
+    /**
+     * Le numéro de compte du payeur. Requis si `payeurAlias` n'est pas fourni.
+     */
+    payeurNumero: string;
+    /**
+     * Le numéro de compte du payé. Requis si `payeAlias` n'est pas fourni.
+     */
+    payeNumero: string;
+    /**
+     * - `INITIE` Le transfert est en cours de traitement
+     * - `IRREVOCABLE` Le tranfert à été effectué avec succès
+     * - `REJETE` Le tranfert à été rejeté
+     *
+     */
+    statut: CompteOperation.statut;
+    /**
+     * Raisons du rejet d'un tranfert':
+     * - SOLDE_INSUFFISANT le solde du compte debiteur est insuffisant pour effectuer l'opération.
+     * - COMPTE_BLOQUE le compte debiteur ou le compte crediteur est bloqué
+     * - COMPTE_CLOTURE le compte debiteur ou le compte crediteur est cloturé
+     *
+     */
+    statutRaison?: CompteOperation.statutRaison;
+    /**
+     * Identifiant unique de bout en bout de la transaction
+     */
+    end2endId?: string;
+    /**
+     * Date d'envoi du transfert de fonds: date et heure à laquelle le transfert à été initié
+     *
+     */
+    dateEnvoi: string;
+    /**
+     * Date d'irrévocabilité du transfert de fonds: date et heure à laquelle le transfert à été irrévocable
+     *
+     */
+    dateIrrevocabilite?: string;
+};
+declare namespace CompteOperation {
+    /**
+     * - `INITIE` Le transfert est en cours de traitement
+     * - `IRREVOCABLE` Le tranfert à été effectué avec succès
+     * - `REJETE` Le tranfert à été rejeté
+     *
+     */
+    enum statut {
+        INITIE = "INITIE"
+    }
+    /**
+     * Raisons du rejet d'un tranfert':
+     * - SOLDE_INSUFFISANT le solde du compte debiteur est insuffisant pour effectuer l'opération.
+     * - COMPTE_BLOQUE le compte debiteur ou le compte crediteur est bloqué
+     * - COMPTE_CLOTURE le compte debiteur ou le compte crediteur est cloturé
+     *
+     */
+    enum statutRaison {
+        SOLDE_INSUFFISANT = "SOLDE_INSUFFISANT"
+    }
+}
+
+type CompteOperationListe = {
+    data?: Array<CompteOperation>;
+    meta?: {
+        /**
+         * total d'éléments correspondants à la recherche
+         */
+        length?: number;
+        /**
+         * numéro ou identifiant de la page suivante
+         */
+        page?: string;
+        /**
+         * nombre d'éléments retournés
+         */
+        limit?: number;
+    };
+};
+
+type CompteSolde = {
+    /**
+     * Le type du compte.
+     * Types de comptes disponibles :
+     * - **CACC** (Current Account) : Compte courant utilisé pour enregistrer les débits et crédits lorsqu'aucun compte spécifique n'a été désigné.
+     * - **CARD** (Card Account) : Compte utilisé pour les paiements par carte de crédit.
+     * - **CASH** (Cash Payment) : Compte utilisé pour le paiement en espèces.
+     * - **CHAR** (Charges) : Compte utilisé pour les frais s'il diffère du compte de paiement.
+     * - **CISH** (Cash Income) : Compte utilisé pour le paiement des revenus s'il diffère du compte courant en espèces.
+     * - **COMM** (Commission) : Compte utilisé pour les commissions s'il diffère du compte de paiement.
+     * - **CPAC** (Clearing Participant Settlement Account) : Compte utilisé pour enregistrer les écritures de règlement débit et crédit au nom d'un participant de compensation désigné.
+     * - **LLSV** (Limited Liquidity Savings Account) : Compte utilisé pour l'épargne avec des conditions spéciales d'intérêt et de retrait.
+     * - **LOAN** (Loan) : Compte utilisé pour les prêts.
+     * - **MGLD** (Marginal Lending) : Compte utilisé pour une facilité de prêt marginal.
+     * - **MOMA** (Money Market) : Compte utilisé pour les marchés monétaires s'il diffère du compte en espèces.
+     * - **NREX** (Non Resident External) : Compte utilisé pour les non-résidents externes.
+     * - **ODFT** (Overdraft) : Compte utilisé pour les découverts.
+     * - **ONDP** (Over Night Deposit) : Compte utilisé pour les dépôts au jour le jour.
+     * - **SACC** (Settlement Account) : Compte utilisé pour enregistrer les écritures débit et crédit résultant de transactions compensées et réglées via un système spécifique de compensation et de règlement.
+     * - **SLRY** (Salary) : Comptes utilisés pour les paiements de salaires.
+     * - **SVGS** (Savings) : Compte utilisé pour l'épargne.
+     * - **TAXE** (Tax) : Compte utilisé pour les taxes s'il diffère du compte de paiement.
+     * - **TRAN** (Transacting Account) : Compte de transaction, le type de compte bancaire le plus basique. La principale différence entre les comptes de transaction et les comptes chèques est qu'il n'y a généralement pas de chéquier ni de facilité de découvert.
+     * - **TRAS** (Cash Trading) : Compte utilisé pour le trading s'il diffère du compte en espèces courant.
+     * - **VACC** (Virtual Account) : Compte créé virtuellement pour faciliter la collecte et le rapprochement.
+     * - **OTHR** (Other Account) : Type de compte non spécifié
+     *
+     */
+    type?: CompteSolde.type;
+    /**
+     * Le numéro de compte
+     */
+    numero?: string;
+    /**
+     * La date d'ouverture du compte au format ISO8601 (YYYY-MM-DD)
+     */
+    dateOuverture?: string;
+    /**
+     * Le solde du compte
+     */
+    solde?: number;
+    /**
+     * Le statut actuel du compte.
+     *
+     * Statuts disponibles :
+     *
+     * - **OUVERT** : Le compte est actif et opérationnel. Toutes les opérations sont autorisées.
+     * - **BLOQUE** : Le compte est temporairement bloqué. Aucune opération n'est autorisée.
+     * - **CLOTURE** : Le compte est fermé définitivement. Aucune opération n'est possible.
+     *
+     */
+    statut?: CompteSolde.statut;
+    /**
+     * Indique si l'attribut preConfirmation est présent.
+     * PreConfirmation est un attribut optionnel.
+     * Par défaut, pour les clients business (entreprises et les gouvernements), PI marque l'irrévocabilité du transfert de fonds sans demander une confirmation au participant payé.
+     * La valeur par défaut est false pour indiquer que le compte reçoit des transferts sans préconfirmation.
+     *
+     */
+    preConfirmation?: boolean;
+};
+declare namespace CompteSolde {
+    /**
+     * Le type du compte.
+     * Types de comptes disponibles :
+     * - **CACC** (Current Account) : Compte courant utilisé pour enregistrer les débits et crédits lorsqu'aucun compte spécifique n'a été désigné.
+     * - **CARD** (Card Account) : Compte utilisé pour les paiements par carte de crédit.
+     * - **CASH** (Cash Payment) : Compte utilisé pour le paiement en espèces.
+     * - **CHAR** (Charges) : Compte utilisé pour les frais s'il diffère du compte de paiement.
+     * - **CISH** (Cash Income) : Compte utilisé pour le paiement des revenus s'il diffère du compte courant en espèces.
+     * - **COMM** (Commission) : Compte utilisé pour les commissions s'il diffère du compte de paiement.
+     * - **CPAC** (Clearing Participant Settlement Account) : Compte utilisé pour enregistrer les écritures de règlement débit et crédit au nom d'un participant de compensation désigné.
+     * - **LLSV** (Limited Liquidity Savings Account) : Compte utilisé pour l'épargne avec des conditions spéciales d'intérêt et de retrait.
+     * - **LOAN** (Loan) : Compte utilisé pour les prêts.
+     * - **MGLD** (Marginal Lending) : Compte utilisé pour une facilité de prêt marginal.
+     * - **MOMA** (Money Market) : Compte utilisé pour les marchés monétaires s'il diffère du compte en espèces.
+     * - **NREX** (Non Resident External) : Compte utilisé pour les non-résidents externes.
+     * - **ODFT** (Overdraft) : Compte utilisé pour les découverts.
+     * - **ONDP** (Over Night Deposit) : Compte utilisé pour les dépôts au jour le jour.
+     * - **SACC** (Settlement Account) : Compte utilisé pour enregistrer les écritures débit et crédit résultant de transactions compensées et réglées via un système spécifique de compensation et de règlement.
+     * - **SLRY** (Salary) : Comptes utilisés pour les paiements de salaires.
+     * - **SVGS** (Savings) : Compte utilisé pour l'épargne.
+     * - **TAXE** (Tax) : Compte utilisé pour les taxes s'il diffère du compte de paiement.
+     * - **TRAN** (Transacting Account) : Compte de transaction, le type de compte bancaire le plus basique. La principale différence entre les comptes de transaction et les comptes chèques est qu'il n'y a généralement pas de chéquier ni de facilité de découvert.
+     * - **TRAS** (Cash Trading) : Compte utilisé pour le trading s'il diffère du compte en espèces courant.
+     * - **VACC** (Virtual Account) : Compte créé virtuellement pour faciliter la collecte et le rapprochement.
+     * - **OTHR** (Other Account) : Type de compte non spécifié
+     *
+     */
+    enum type {
+        CACC = "CACC",
+        CARD = "CARD",
+        CASH = "CASH",
+        CHAR = "CHAR",
+        CISH = "CISH",
+        COMM = "COMM",
+        CPAC = "CPAC",
+        LLSV = "LLSV",
+        LOAN = "LOAN",
+        MGLD = "MGLD",
+        MOMA = "MOMA",
+        NREX = "NREX",
+        ODFT = "ODFT",
+        ONDP = "ONDP",
+        OTHR = "OTHR",
+        SACC = "SACC",
+        SLRY = "SLRY",
+        SVGS = "SVGS",
+        TAXE = "TAXE",
+        TRAN = "TRAN",
+        TRAS = "TRAS",
+        VACC = "VACC"
+    }
+    /**
+     * Le statut actuel du compte.
+     *
+     * Statuts disponibles :
+     *
+     * - **OUVERT** : Le compte est actif et opérationnel. Toutes les opérations sont autorisées.
+     * - **BLOQUE** : Le compte est temporairement bloqué. Aucune opération n'est autorisée.
+     * - **CLOTURE** : Le compte est fermé définitivement. Aucune opération n'est possible.
+     *
+     */
+    enum statut {
+        OUVERT = "OUVERT",
+        BLOQUE = "BLOQUE",
+        CLOTURE = "CLOTURE"
+    }
+}
+
+type CompteTransfertIntraRequest = {
+    txId: string;
+    montant: number;
+    motif?: string;
+    payeurNumero?: string;
+    payeNumero?: string;
+    payeurAlias?: string;
+    payeAlias?: string;
+};
+
+type CompteTransfertIntraReponse = (CompteTransfertIntraRequest & {
+    /**
+     * - `INITIE` Le transfert est en cours de traitement
+     * - `IRREVOCABLE` Le tranfert à été effectué avec succès
+     *
+     */
+    statut?: CompteTransfertIntraReponse.statut;
+    /**
+     * Identifiant unique de bout en bout de la transaction
+     */
+    end2endId?: string;
+    /**
+     * Date d'envoi du transfert de fonds: date et heure à laquelle le transfert à été initié
+     *
+     */
+    dateEnvoi?: string;
+    /**
+     * Date d'irrévocabilité du transfert de fonds: date et heure à laquelle le transfert à été irrévocable
+     *
+     */
+    dateIrrevocabilite?: string;
+});
+declare namespace CompteTransfertIntraReponse {
+    /**
+     * - `INITIE` Le transfert est en cours de traitement
+     * - `IRREVOCABLE` Le tranfert à été effectué avec succès
+     *
+     */
+    enum statut {
+        INITIE = "INITIE"
+    }
+}
+
+/**
+ * Raisons de l'annulation ou du rejet de la demande de paiement:
+ * - ERREUR_ALIAS le client s'est trompé sur l'alias
+ * - ERREUR_MONTANT le client s'est trompé sur le montant
+ * - ERREUR_TXID le client s'est trompé sur le txId
+ * - PAYEUR_INCONNU les informations du client payeur retournées suite à la recherche d'alias ne sont pas ceux attendues par le client.
+ *
+ */
+declare enum DemandePaiementConfirmationAnnulationRaison {
+    ERREUR_ALIAS = "ERREUR_ALIAS",
+    ERREUR_MONTANT = "ERREUR_MONTANT",
+    ERREUR_TXID = "ERREUR_TXID",
+    PAYEUR_INCONNU = "PAYEUR_INCONNU"
+}
+
+/**
+ * Le type de document justificatif associé à la transaction. Les types de documents disponibles sont :
+ * - **QUOT** (Quotation) : Devis commercial détaillant les conditions d'offre.
+ * - **PROF** (Proforma Invoice) : Facture pro forma, engagement préliminaire du vendeur (prix/conditions), sans enregistrement comptable réel.
+ * - **CINV** (Commercial Invoice) : Facture commerciale standard pour la vente de biens ou services. Utilisée pour les paiements directs d'une facture émise par le vendeur.
+ * - **CMCN** (Commercial Contract) : Contrat commercial entre les parties, stipulant les termes et conditions de la livraison de biens ou de services.
+ * - **DISP** (Dispatch Advice) : Avis d'expédition ou bon de livraison.
+ * - **PUOR** (Purchase Order) : Bon de commande émis par l'acheteur.
+ * - **CONT** (Contract) : Document contractuel prouvant un accord entre vendeur et acheteur pour biens ou services.
+ * - **HIRI** (Hire Invoice) : Facture pour location de ressources humaines (ex : intérim) ou biens/équipements.
+ * - **INVS** (Invoice Signed) : Facture signée, validée électroniquement ou physiquement. Indique une approbation formelle avant paiement.
+ * - **MSIN** (Metered Service Invoice) : Facture pour services mesurés (ex : gaz, électricité via compteur fixe). Inclut la consommation réelle.
+ * - **SPRR** (Seller Presentment) : Document de présentation par le vendeur pour supporter l'acquisition (ex : preuve de livraison ou justificatif).
+ * - **TISH** (Time Sheet) : Feuille de temps enregistrant les heures pour services/prestations ou livraison. Pour paiements basés sur le temps (ex : consulting, freelance).
+ * - **USAR** (Usage Report) : Rapport d'utilisation indiquant le pattern de consommation (ex : SaaS, télécoms). Similaire à MSIN mais plus large (non forcément mesuré).
+ * - **BOLD** (Bill Of Lading) : Document de transport maritime ou logistique (connaissement) prouvant l'expédition des marchandises. Spécifique au transport multimodal (ex : maritime, aérien).
+ * - **SOAC** (Statement Of Account) : Relevé de compte émis par le fournisseur, listant les transactions enregistrées pour le débiteur (ex : factures, paiements, ajustements).
+ * - **VCHR** (Voucher) : Document électronique de paiement (bon ou coupon) représentant une obligation ou un droit de paiement. Souvent utilisé pour des paiements préautorisés ou des remises spécifiques.
+ *
+ */
+declare enum RefDocType {
+    CINV = "CINV",
+    CMCN = "CMCN",
+    DISP = "DISP",
+    PUOR = "PUOR",
+    CONT = "CONT",
+    HIRI = "HIRI",
+    INVS = "INVS",
+    MSIN = "MSIN",
+    PROF = "PROF",
+    QUOT = "QUOT",
+    SPRR = "SPRR",
+    TISH = "TISH",
+    USAR = "USAR",
+    BOLD = "BOLD",
+    SOAC = "SOAC",
+    VCHR = "VCHR"
+}
+
+type DemandePaiementRequestBase = {
+    /**
+     * Identifiant de la demande de paiement dans le SI du client
+     */
+    txId: string;
+    /**
+     * Alias de compte du client payeur à qui est adressée la demande
+     */
+    payeurAlias: string;
+    /**
+     * L'alias de compte dans lequel le client payé souhaite recevoir les paiements
+     */
+    payeAlias: string;
+    /**
+     * L'URL du logo du business ou d'un produit du business qui sera affiché au client payeur
+     */
+    logoUrl?: string;
+    /**
+     * Lorsque le PSP reçoit la demande, il effectue une recherche d'alias en vue d'obtenir les informations de compte du client payeur.
+     *
+     * L'attribut `confirmation` permet au client d'indiquer à son PSP si celui-ci doit lui retourner les résultats de la recherche d'alias pour confirmation:
+     *
+     * * La valeur `true` de la confirmation indique au PSP qu'il doit retourner le résultat de la recherche d'alias au client et attendre une confirmation
+     * * La valeur `false` indique qu'une confirmation n'est pas requise pour la demande, de ce fait le PSP transmet directement la demande à PI
+     *
+     */
+    confirmation: boolean;
+    /**
+     * Le montant total du paiement à effectuer
+     */
+    montant: number;
+    /**
+     * Le motif de la demande de paiement
+     */
+    motif?: string;
+    /**
+     * Le numéro / la référence du document justificatif
+     */
+    refDocNumero?: string;
+    refDocType?: RefDocType;
+};
+
+type DemandePaiementRequest = (({
+    categorie: DemandePaiementRequest.categorie;
+} & DemandePaiementRequestBase) | ({
+    categorie: DemandePaiementRequest.categorie;
+    /**
+     * Montant de l'achat
+     */
+    montantAchat: number;
+    /**
+     * Montant du retrait d'espèces (Inclus le montant des frais)
+     */
+    montantRetrait: number;
+    /**
+     * Frais de retrait
+     */
+    montantFrais: number;
+} & DemandePaiementRequestBase) | ({
+    categorie: DemandePaiementRequest.categorie;
+    /**
+     * Montant du retrait d'espèces
+     */
+    montantRetrait: number;
+    /**
+     * Frais de retrait
+     */
+    montantFrais: number;
+} & DemandePaiementRequestBase) | ({
+    categorie: DemandePaiementRequest.categorie;
+    /**
+     * Indique que le paiement est différé (Acheter maintenant, payer plus tard)
+     */
+    debitDiffere: boolean;
+    /**
+     * Remise appliquée sur la facture
+     */
+    remise?: {
+        montant?: number;
+        taux?: number;
+    };
+} & DemandePaiementRequestBase) | ({
+    categorie: DemandePaiementRequest.categorie;
+    /**
+     * Date limite de paiement (2 minutes après création)
+     */
+    dateLimitePaiement: string;
+} & DemandePaiementRequestBase) | ({
+    categorie: DemandePaiementRequest.categorie;
+    /**
+     * Indique que le paiement est différé
+     */
+    debitDiffere: boolean;
+    /**
+     * Remise appliquée
+     */
+    remise: {
+        /**
+         * Montant de la remise
+         */
+        montant?: number;
+        /**
+         * Taux de remise
+         */
+        taux?: number;
+    };
+} & DemandePaiementRequestBase) | ({
+    categorie: DemandePaiementRequest.categorie;
+    /**
+     * Date limite de paiement de la facture (ex "A payer avant")
+     */
+    dateLimitePaiement: string;
+    /**
+     * Date limite de réponse
+     */
+    dateLimiteReponse?: string;
+} & DemandePaiementRequestBase) | ({
+    categorie: DemandePaiementRequest.categorie;
+    /**
+     * Date limite de paiement
+     */
+    dateLimitePaiement: string;
+    /**
+     * Date limite de réponse
+     */
+    dateLimiteReponse: string;
+    /**
+     * Remise appliquée sur la facture - la remise n'est pas appliquée après la date limite de paiement
+     */
+    remise?: {
+        montant?: number;
+        taux?: number;
+    };
+} & DemandePaiementRequestBase));
+declare namespace DemandePaiementRequest {
+    enum categorie {
+        _500 = "500"
+    }
+}
+
+type DemandePaiementConfirmationReponse = (DemandePaiementRequest & {
+    /**
+     * - `ENVOYE` si les validations sont concluantes et que le PSP a envoyé la demande
+     * - `ANNULE` si la demande n'est pas envoye pour une raison
+     *
+     */
+    statut?: DemandePaiementConfirmationReponse.statut;
+    statutRaison?: DemandePaiementConfirmationAnnulationRaison;
+    /**
+     * Le nom du payeur
+     */
+    payeurNom?: string;
+    /**
+     * Le pays de residence du payeur
+     */
+    payeurPays?: string;
+    /**
+     * Date d'envoie de la demande: date et heure à laquelle la demande de paiement est envoyée par le PSP
+     *
+     */
+    dateEnvoie?: string;
+    /**
+     * Date de confirmation de la demande si le client avait requis la confirmation de la demande de paiement.
+     * Il s'agit de la date et heure à laquelle le client a confirmé la demande.
+     *
+     */
+    dateConfirmation?: string;
+});
+declare namespace DemandePaiementConfirmationReponse {
+    /**
+     * - `ENVOYE` si les validations sont concluantes et que le PSP a envoyé la demande
+     * - `ANNULE` si la demande n'est pas envoye pour une raison
+     *
+     */
+    enum statut {
+        ENVOYE = "ENVOYE",
+        ANNULE = "ANNULE"
+    }
+}
+
+/**
+ * Confirmation de la demande de paiement
+ */
+type DemandePaiementConfirmationRequestAccepter = {
+    /**
+     * La décision à `true` indique la confirmation de la demande de paiement.
+     */
+    decision: boolean;
+};
+
+/**
+ * Annulation de la demande de paiement
+ */
+type DemandePaiementConfirmationRequestRejeter = {
+    /**
+     * La décision  à `false`  indique l'annulation de la demande de paiement.
+     */
+    decision: boolean;
+};
+
+type DemandePaiementConfirmationRequest = (DemandePaiementConfirmationRequestAccepter | DemandePaiementConfirmationRequestRejeter);
+
+/**
+ *
+ * **Raisons de rejet ou d'echec des demandes de paiement :**
+ * - **BE23** (Alias invalid) : L'alias du payeur n'existe pas ou est invalide.
+ * - **DU03** (Duplicate Transaction) : Le txId n'est pas unique
+ *
+ * - **AC04** (Closed Account Number) : Le compte du client payeur est clôturé.
+ * - **AC06** (Blocked Account) : Le compte du client payeur est bloqué.
+ * - **AEXR** (Already Expired RTP) : La demande de paiement a déjà expiré.
+ * - **AG03** (Transaction Not Supported) : Le client n'est pas autorisé à payer en mode débit différé.
+ * - **AG10** (Agent Suspended) : Le participant payeur est suspendu.
+ * - **AG11** (Creditor Agent Suspended) : Le participant payé est désactivé.
+ * - **ALAC** (Already Accepted RTP) : La demande de paiement a déjà été acceptée.
+ * - **AM02** (Not Allowed Amount) : Le montant spécifique de la transaction dépasse le montant maximum autorisé.
+ * - **AM09** (Wrong Amount) : Le montant reçu ne correspond pas au montant convenu ou attendu.
+ * - **AM14** (Amount Exceeds Agreed Limit) : Le montant de la transaction fait dépasser le plafond de débit différé du client.
+ * - **APAR** (Already Paid RTP) : Le paiement demandé a déjà été effectué par le payeur.
+ * - **ARFR** (Already Refused RTP) : La demande de paiement a déjà été refusée.
+ * - **ARJR** (Already Rejected RTP) : La demande de paiement a déjà été rejetée.
+ * - **BE01** (Inconsistent With End Customer) : L'identification du client final n'est pas liée au numéro de compte associé.
+ * - **BE05** (Unrecognised Initiating Party) : La partie qui a initié le message n'est pas reconnue par le client final.
+ * - **FR01** (Fraud) : Rejeté pour suspicion de fraude.
+ * - **RR07** (Remittance Information Invalid) : Le justificatif de la demande de paiement est invalide (par exemple, le numéro de facture est invalide).
+ *
+ */
+declare enum DemandePaiementStatutRaison {
+    BE23 = "BE23",
+    DU03 = "DU03",
+    AC04 = "AC04",
+    AC06 = "AC06",
+    AEXR = "AEXR",
+    AG03 = "AG03",
+    AG10 = "AG10",
+    AG11 = "AG11",
+    ALAC = "ALAC",
+    AM02 = "AM02",
+    AM09 = "AM09",
+    AM14 = "AM14",
+    APAR = "APAR",
+    ARFR = "ARFR",
+    ARJR = "ARJR",
+    BE01 = "BE01",
+    BE05 = "BE05",
+    FR01 = "FR01",
+    RR07 = "RR07"
+}
+
+type DemandePaiementConsultationReponse = {
+    /**
+     * Identifiant de la demande de paiement dans le SI du client
+     */
+    txId?: string;
+    /**
+     * Categorie de la demande de paiement
+     */
+    categorie?: DemandePaiementConsultationReponse.categorie;
+    /**
+     * L'alias de compte dans lequel le client payé souhaite recevoir les paiements
+     */
+    payeAlias?: string;
+    /**
+     * L'URL du logo du business ou d'un produit du business qui sera affiché au client payeur
+     */
+    logoUrl?: string;
+    /**
+     * Alias de compte du client payeur à qui est adressée la demande
+     */
+    payeurAlias?: string;
+    /**
+     * Lorsque le PSP reçoit la demande, il effectue une recherche d'alias en vue d'obtenir les informations de compte du client payeur.
+     *
+     * L'attribut `confirmation` permet au client d'indiquer à son PSP si celui-ci doit lui retourner les résultats de la recherche d'alias pour confirmation:
+     *
+     * * La valeur `true` de la confirmation indique au PSP qu'il doit retourner le résultat de la recherche d'alias au client et attendre une confirmation
+     * * La valeur `false` indique qu'une confirmation n'est pas requise pour la demande, de ce fait le PSP transmet directement la demande à PI
+     *
+     */
+    confirmation?: boolean;
+    /**
+     * Remise appliquée sur la demande de paiement
+     */
+    remise?: {
+        /**
+         * Le montant de la remise
+         */
+        montant?: number;
+        /**
+         * Le taux de la remise
+         */
+        taux?: number;
+    };
+    /**
+     * Indique si le client peut acheter maintenant et payer plus tard.
+     */
+    debitDiffere?: boolean;
+    /**
+     * Le montant total du paiement à effectuer
+     */
+    montant?: number;
+    /**
+     * Le montant de l'achat
+     */
+    montantAchat?: number;
+    /**
+     * Le montant du retrait
+     */
+    montantRetrait?: number;
+    /**
+     * Les frais de retrait
+     */
+    montantFrais?: number;
+    /**
+     * Le motif de la demande de paiement
+     */
+    motif?: string;
+    /**
+     * Le numéro / la référence du document justificatif
+     */
+    refDocNumero?: string;
+    refDocType?: RefDocType;
+    /**
+     * - `INITIE` si la confirmation du client est attendue suite à la recherche d'alias,
+     * - `ENVOYE` si les validations sont concluantes et que le PSP a envoyé la demande
+     * - `IRREVOCABLE` si le payeur a accepté la demande
+     * - `REJETE` si le payeur rejète la demande
+     *
+     */
+    statut?: DemandePaiementConsultationReponse.statut;
+    statutRaison?: DemandePaiementStatutRaison;
+    /**
+     * Le nom du payeur
+     */
+    payeurNom?: string;
+    /**
+     * Le pays de residence du payeur
+     */
+    payeurPays?: string;
+    /**
+     * Date limite de paiement
+     */
+    dateLimitePaiement?: string;
+    /**
+     * Date limite de réponse
+     */
+    dateLimiteReponse?: string;
+    /**
+     * Date de la demande de paiement
+     *
+     */
+    dateDemande?: string;
+    /**
+     * Date de confirmation de la demande si le client avait requis la confirmation de la demande de paiement.
+     * Il s'agit de la date et heure à laquelle le client a confirmé la demande.
+     *
+     */
+    dateConfirmation?: string;
+    /**
+     * Date d'envoi de la demande: date et heure à laquelle la demande de paiement est envoyée par le PSP
+     *
+     */
+    dateEnvoi?: string;
+    /**
+     * Date à laquelle le payeur à repondu à la demande de paiement
+     *
+     */
+    dateReponse?: string;
+    /**
+     * Date à laquelle le paiement accepté est irrévocable
+     *
+     */
+    dateIrrevocabilite?: string;
+};
+declare namespace DemandePaiementConsultationReponse {
+    /**
+     * Categorie de la demande de paiement
+     */
+    enum categorie {
+        _631 = "631",
+        _500 = "500",
+        _521 = "521",
+        _401 = "401"
+    }
+    /**
+     * - `INITIE` si la confirmation du client est attendue suite à la recherche d'alias,
+     * - `ENVOYE` si les validations sont concluantes et que le PSP a envoyé la demande
+     * - `IRREVOCABLE` si le payeur a accepté la demande
+     * - `REJETE` si le payeur rejète la demande
+     *
+     */
+    enum statut {
+        INITIE = "INITIE",
+        ENVOYE = "ENVOYE",
+        IRREVOCABLE = "IRREVOCABLE",
+        REJETE = "REJETE"
+    }
+}
+
+/**
+ * Confirmation de la demande de paiement en masse
+ */
+type DemandePaiementEnMasseConfirmationRequestAccepter = {
+    /**
+     * La décision à `true` indique la confirmation de la demande de paiement en masse.
+     */
+    decision: boolean;
+};
+
+/**
+ * Annulation de la demande de paiement en masse
+ */
+type DemandePaiementEnMasseConfirmationRequestRejeter = {
+    /**
+     * La décision à `false` indique l'annulation de la demande de paiement en masse.
+     */
+    decision: boolean;
+};
+
+type DemandePaiementEnMasseConfirmationRequest = (DemandePaiementEnMasseConfirmationRequestAccepter | DemandePaiementEnMasseConfirmationRequestRejeter);
+
+type DemandePaiementEnMasseRequest = {
+    /**
+     * L'alias de compte dans lequel le client souhaite recevoir les paiements
+     *
+     */
+    payeAlias: string;
+    /**
+     * Indique si une confirmation du business est requise avant d'envoyer les demandes de paiement.
+     *
+     * - `true` : Le PSP effectue la recherche d'alias pour tous les payeurs, retourne leurs noms et pays, et attend la confirmation du business avant d'envoyer les demandes de paiement.
+     * - `false` : Le PSP envoie directement les demandes de paiement sans attendre de confirmation.
+     *
+     * **Note :** Si `true`, le business doit confirmer via `PUT /demandes-paiements-groupes/{instructionId}/confirmations` dans un délai adaptatif (24h, 48h ou 72h selon le nombre de transactions).
+     *
+     */
+    confirmation?: boolean;
+    /**
+     * Identifiant de la demande de paiement en masse dans le SI du client
+     */
+    instructionId: string;
+    /**
+     * Le motif commun à toutes les demandes de paiement du groupe.
+     * Si toutes les demandes de paiement du groupe ont le même motif, ce champ peut être utilisé pour optimiser la taille du lot.
+     * Dans le cas contraire, chaque demande de paiement doit avoir son propre motif.
+     *
+     */
+    motif?: string;
+    transactions: Array<{
+        /**
+         * Identifiant de la transaction dans le SI du client
+         */
+        txId: string;
+        /**
+         * L'alias du client payeur.
+         */
+        payeurAlias: string;
+        /**
+         * Le montant à payer
+         */
+        montant: number;
+        /**
+         * Remise appliquée sur la facture - la remise n'est pas appliquée après la date limite de paiement
+         */
+        remise?: {
+            montant?: number;
+            taux?: number;
+        };
+        /**
+         * La date limite à laquelle le payeur doit avoir effectué le paiement.
+         *
+         * Dans le cas d'une demande de paiement de facture, il s'agit en général de la date indiquée avec la mention "À payer avant".
+         *
+         */
+        dateLimitePaiement: string;
+        /**
+         * C'est la date limite avant laquelle une réponse doit être fournie par le payeur.
+         * La demande de paiement expire à cette date. Le client payé ne peut pas envoyer
+         *
+         */
+        dateLimiteReponse?: string;
+        /**
+         * Le motif de la demande de paiement.
+         * Si toutes les demandes de paiement du groupe ont le même motif, ce champ doit être omis, et le motif du groupe doit être utilisé.
+         *
+         */
+        motif?: string;
+        /**
+         * Le numéro / la référence du document justificatif
+         */
+        refDocNumero?: string;
+        refDocType?: RefDocType;
+    }>;
+};
+
+type DemandePaiementEnMasseStatutReponse = {
+    /**
+     * Identifiant de la demande de paiement en masse
+     */
+    instructionId?: string;
+    /**
+     * Statut global de la demande de paiement en masse:
+     * - `INITIE`: Créée avec confirmation demandée, en attente de confirmation
+     * - `CONFIRME`: Confirmée par le business ( pour savoir si le traitement est terminé, vérifiez que `transactionsIrrevocables + transactionsRejetees = transactionsTotal`)
+     * - `ANNULE`: Annulée par le business
+     *
+     * **Évolution selon le mode de création :**
+     * - Si créée **avec confirmation** (`confirmation: true`) : `INITIE` → `CONFIRME` (après PUT /confirmations) ou `ANNULE`
+     * - Si créée **sans confirmation** (`confirmation: false`) : Directement `CONFIRME` (aucune action requise du business)
+     *
+     */
+    statut?: DemandePaiementEnMasseStatutReponse.statut;
+    /**
+     * Date d'expiration de la confirmation (délai adaptatif selon nombre de transactions).
+     * Présent uniquement si statut = INITIE.
+     *
+     * Délais :
+     * - 1 à 500 transactions : 24 heures
+     * - 501 à 1000 transactions : 48 heures
+     * - Plus de 1000 transactions : 72 heures
+     *
+     */
+    dateExpiration?: string;
+    /**
+     * Nombre total de transactions dans la demande de paiement en masse
+     */
+    transactionsTotal?: number;
+    /**
+     * Nombre de transactions à l'état `INITIE` (validées avec succès, prêtes à être envoyées).
+     *
+     * Si créée avec `confirmation: true`, ces transactions ont passé toutes les validations :
+     * - txId unique (pas de duplication)
+     * - Alias du payeur valide (recherche d'alias réussie)
+     * - Nom et pays du payeur disponibles
+     *
+     * Ce sont ces transactions qui seront envoyées lors de la confirmation.
+     *
+     * **Vérification de fin de validation :** La validation est terminée quand `transactionsInitiees + transactionsRejetees = transactionsTotal`.
+     *
+     */
+    transactionsInitiees?: number;
+    /**
+     * Nombre de transactions à l'état `ENVOYE` (demandes envoyées au payeur)
+     */
+    transactionsEnvoyees?: number;
+    /**
+     * Nombre de transactions à l'état `IRREVOCABLE` (demandes acceptées et payées par le payeur)
+     */
+    transactionsIrrevocables?: number;
+    /**
+     * Nombre de transactions à l'état `REJETE` (échecs de validation ou refus du payeur).
+     *
+     * Comprend :
+     * - Rejets de validation (avant envoi) : BE23 (alias invalide), DU03 (txId dupliqué)
+     * - Rejets d'envoi (après confirmation) : Alias du payeur indisponible, etc.
+     * - Refus du payeur (le payeur a rejeté la demande)
+     *
+     * **Note :** Les transactions rejetées à la validation ne sont jamais envoyées, même si le bulk est confirmé.
+     *
+     */
+    transactionsRejetees?: number;
+    /**
+     * Date de création de la demande de paiement en masse (date de la demande)
+     */
+    dateDemande?: string;
+    /**
+     * Date de confirmation par le business (date d'acceptation de la demande).
+     * Présent uniquement si statut = CONFIRME.
+     *
+     * - Si créée avec confirmation: Date du PUT /confirmations avec decision: true
+     * - Si créée sans confirmation: Correspond à dateDemande (confirmation automatique)
+     *
+     */
+    dateConfirmation?: string;
+};
+declare namespace DemandePaiementEnMasseStatutReponse {
+    /**
+     * Statut global de la demande de paiement en masse:
+     * - `INITIE`: Créée avec confirmation demandée, en attente de confirmation
+     * - `CONFIRME`: Confirmée par le business ( pour savoir si le traitement est terminé, vérifiez que `transactionsIrrevocables + transactionsRejetees = transactionsTotal`)
+     * - `ANNULE`: Annulée par le business
+     *
+     * **Évolution selon le mode de création :**
+     * - Si créée **avec confirmation** (`confirmation: true`) : `INITIE` → `CONFIRME` (après PUT /confirmations) ou `ANNULE`
+     * - Si créée **sans confirmation** (`confirmation: false`) : Directement `CONFIRME` (aucune action requise du business)
+     *
+     */
+    enum statut {
+        INITIE = "INITIE",
+        CONFIRME = "CONFIRME",
+        ANNULE = "ANNULE"
+    }
+}
+
+type DemandePaiementListeItem = {
+    /**
+     * Identifiant de la demande de paiement dans le SI du client
+     */
+    txId?: string;
+    /**
+     * Categorie de la demande de paiement
+     */
+    categorie?: DemandePaiementListeItem.categorie;
+    /**
+     * L'alias de compte dans lequel le client payé souhaite recevoir les paiements
+     */
+    payeAlias?: string;
+    /**
+     * L'URL du logo du business ou d'un produit du business qui sera affiché au client payeur
+     */
+    logoUrl?: string;
+    /**
+     * Alias de compte du client payeur à qui est adressée la demande
+     */
+    payeurAlias?: string;
+    /**
+     * Lorsque le PSP reçoit la demande, il effectue une recherche d'alias en vue d'obtenir les informations de compte du client payeur.
+     *
+     * L'attribut `confirmation` permet au client d'indiquer à son PSP si celui-ci doit lui retourner les résultats de la recherche d'alias pour confirmation:
+     *
+     * * La valeur `true` de la confirmation indique au PSP qu'il doit retourner le résultat de la recherche d'alias au client et attendre une confirmation
+     * * La valeur `false` indique qu'une confirmation n'est pas requise pour la demande, de ce fait le PSP transmet directement la demande à PI
+     *
+     */
+    confirmation?: boolean;
+    /**
+     * Remise appliquée sur la demande de paiement
+     */
+    remise?: {
+        /**
+         * Le montant de la remise
+         */
+        montant?: number;
+        /**
+         * Le taux de la remise
+         */
+        taux?: number;
+    };
+    /**
+     * Indique si le client peut acheter maintenant et payer plus tard.
+     */
+    debitDiffere?: boolean;
+    /**
+     * Le montant total du paiement à effectuer
+     */
+    montant?: number;
+    /**
+     * Le montant de l'achat
+     */
+    montantAchat?: number;
+    /**
+     * Le montant du retrait
+     */
+    montantRetrait?: number;
+    /**
+     * Les frais de retrait
+     */
+    montantFrais?: number;
+    /**
+     * Le motif de la demande de paiement
+     */
+    motif?: string;
+    /**
+     * Le numéro / la référence du document justificatif
+     */
+    refDocNumero?: string;
+    refDocType?: RefDocType;
+    /**
+     * - `INITIE` si la confirmation du client est attendue suite à la recherche d'alias
+     * - `ENVOYE` si les validations sont concluantes et que le PSP a envoyé la demande
+     * - `IRREVOCABLE` si le payeur a accepté la demande
+     * - `REJETE` si le payeur rejette la demande
+     *
+     */
+    statut?: DemandePaiementListeItem.statut;
+    statutRaison?: DemandePaiementStatutRaison;
+    /**
+     * Identifiant unique de bout en bout de la transaction
+     */
+    end2endId?: string;
+    /**
+     * Le nom du payeur
+     */
+    payeurNom?: string;
+    /**
+     * Le pays de residence du payeur
+     */
+    payeurPays?: string;
+    /**
+     * Le nom du payé (Retourné dans le cas d'un RTP reçu)
+     */
+    payeNom?: string;
+    /**
+     * Le pays de residence du payé (Retourné dans le cas d'un RTP reçu)
+     */
+    payePays?: string;
+    /**
+     * Date limite de paiement
+     */
+    dateLimitePaiement?: string;
+    /**
+     * Date limite de réponse
+     */
+    dateLimiteReponse?: string;
+    /**
+     * Date de la demande de paiement
+     *
+     */
+    dateDemande?: string;
+    /**
+     * Date de confirmation de la demande si le client avait requis la confirmation de la demande de paiement.
+     * Il s'agit de la date et heure à laquelle le client a confirmé la demande.
+     *
+     */
+    dateConfirmation?: string;
+    /**
+     * Date d'envoi de la demande: date et heure à laquelle la demande de paiement est envoyée par le PSP
+     *
+     */
+    dateEnvoi?: string;
+    /**
+     * Date à laquelle le payeur à repondu à la demande de paiement
+     *
+     */
+    dateReponse?: string;
+    /**
+     * Date à laquelle le paiement accepté est irrévocable
+     *
+     */
+    dateIrrevocabilite?: string;
+};
+declare namespace DemandePaiementListeItem {
+    /**
+     * Categorie de la demande de paiement
+     */
+    enum categorie {
+        _631 = "631",
+        _500 = "500",
+        _521 = "521",
+        _401 = "401"
+    }
+    /**
+     * - `INITIE` si la confirmation du client est attendue suite à la recherche d'alias
+     * - `ENVOYE` si les validations sont concluantes et que le PSP a envoyé la demande
+     * - `IRREVOCABLE` si le payeur a accepté la demande
+     * - `REJETE` si le payeur rejette la demande
+     *
+     */
+    enum statut {
+        INITIE = "INITIE",
+        ENVOYE = "ENVOYE",
+        IRREVOCABLE = "IRREVOCABLE",
+        REJETE = "REJETE"
+    }
+}
+
+type DemandePaiementListe = {
+    data: Array<DemandePaiementListeItem>;
+    meta: {
+        /**
+         * Nombre total de demandes de paiement correspondant aux critères
+         */
+        total?: number;
+        /**
+         * Nombre d'éléments par page
+         */
+        size?: number;
+        /**
+         * Identifiant de la page actuelle
+         */
+        page?: string;
+        /**
+         * Identifiant de la page suivante
+         */
+        next?: string;
+        /**
+         * Identifiant de la page précédente
+         */
+        prev?: string;
+    };
+};
+
+/**
+ * Catégorie de la demande de paiement
+ * - `500` Demande de Paiement marchand sur site
+ * - `521` Demande de Paiement e-commerce immédiat
+ * - `401` Autres demandes de paiement de facture
+ *
+ */
+declare enum DemandePaiementRequestCategorie {
+    _500 = "500",
+    _521 = "521",
+    _401 = "401"
+}
+
+/**
+ * - `INITIE` si la confirmation du client est attendue suite à la recherche d'alias
+ * - `ENVOYE` si les validations sont concluantes et que le PSP a envoyé la demande
+ * - `IRREVOCABLE` si le payeur a accepté la demande
+ * - `REJETE` si le payeur rejette la demande
+ *
+ */
+declare enum DemandePaiementStatut {
+    INITIE = "INITIE",
+    ENVOYE = "ENVOYE",
+    IRREVOCABLE = "IRREVOCABLE",
+    REJETE = "REJETE"
+}
+
+type DemandePaiementReponse = {
+    /**
+     * Identifiant de la demande de paiement dans le SI du client
+     */
+    txId?: string;
+    /**
+     * Alias de compte du client payeur à qui est adressé la demande
+     */
+    payeurAlias?: string;
+    /**
+     * L'alias de compte dans lequel le client payé souhaite recevoir les paiements
+     */
+    payeAlias?: string;
+    /**
+     * Lorsque le PSP recoit la demande, il effectue une recherche d'alias en vue d'obtenir les informations de compte du client payeur.
+     *
+     * L'attribut `confirmation` permet au client d'indiquer à son PSP si celui-ci doit lui retourner les resultats de la recherche d'alias pour confirmation:
+     *
+     * * La valeur `true` de la confirmation indique au PSP qu'il doit retourner le resultat de la recherche d'alias au client et attendre une confirmation
+     * * La valeur `false` indique qu'une confirmation n'est pas requise pour la demande, de ce fait le PSP transmet directement la demande à PI
+     *
+     */
+    confirmation?: boolean;
+    categorie?: DemandePaiementRequestCategorie;
+    /**
+     * La date limite à laquelle le payeur doit avoir effectuer le paiement.
+     * Dans le cas d'une demande de paiement de facture, il s'agit en général de la date indiquée avec la mention "A payer avant".
+     *
+     */
+    dateLimitePaiement?: string;
+    /**
+     * C'est la date limite avant laquelle une réponse doit être fournie par le payeur.
+     * La demande de paiement expire à cette date. Le client payé ne peut ni accepter ni refuser après cette date.
+     * Par défaut, la date limite de réponse est la date de la demande + 92 jours (3 mois).
+     *
+     */
+    dateLimiteReponse?: string;
+    /**
+     * Le montant du paiement à effectué
+     */
+    montant?: number;
+    /**
+     * Le montant de l'achat dans le cadre d'une demande de paiement PICO
+     */
+    montantAchat?: number;
+    /**
+     * Le montant du retrait dans le cadre d'une demande de paiement PICO ou PICASH
+     */
+    montantRetrait?: number;
+    /**
+     * Les frais de retrait dans le cadre d'une demande de paiement PICO
+     */
+    montantFrais?: number;
+    /**
+     * Remise appliquée pour un paiement immédiat dés réception de la demande
+     *
+     */
+    remise?: {
+        /**
+         * Le montant de la remise
+         */
+        montant?: number;
+        /**
+         * Le taux de la remise
+         */
+        taux?: number;
+    };
+    /**
+     * Indique si le payeur peut acheter maintenant et payer plus tard.
+     *
+     * La valeur est true pour un paiement immédiat avec débit différé (Acheter maintenant, payer plus tard).
+     * Dans le cas du débit différé, le participant du client payeur paye le montant demandé prenant en compte la remise.
+     *
+     */
+    debitDiffere?: boolean;
+    /**
+     * Le motif de la demande de paiement
+     */
+    motif?: string;
+    /**
+     * Le numéro / la reference du document justificatif
+     */
+    refDocNumero?: string;
+    refDocType?: RefDocType;
+    statut?: DemandePaiementStatut;
+    statutRaison?: DemandePaiementStatutRaison;
+    /**
+     * Le nom du payeur.
+     *
+     * **Présence selon le statut :**
+     * - `INITIE` (avec confirmation) : Présent ✅
+     * - `ENVOYE` (sans confirmation) : Présent ✅
+     * - `REJETE` avec BE23 ou DU03 : Absent ❌
+     *
+     */
+    payeurNom?: string;
+    /**
+     * Le pays de résidence du payeur.
+     *
+     * **Présence selon le statut :**
+     * - `INITIE` (avec confirmation) : Présent ✅
+     * - `ENVOYE` (sans confirmation) : Présent ✅
+     * - `REJETE` avec BE23 ou DU03 : Absent ❌
+     *
+     */
+    payeurPays?: string;
+    /**
+     * Identifiant unique de bout en bout de la transaction
+     */
+    end2endId?: string;
+    /**
+     * Date d'envoi de la demande de paiement par le business
+     */
+    dateDemande?: string;
+    /**
+     * Date d'envoi de la demande de paiement par le participant
+     */
+    dateEnvoi?: string;
+    /**
+     * Date de confirmation de la demande si le client avait requis la confirmation de la demande de paiement.
+     * Il s'agit de la date et heure à laquelle le client a confirmé la demande.
+     *
+     */
+    dateConfirmation?: string;
+};
+
+type DemandePaiementReponseRequest = ({
+    /**
+     * La décision à `true` indique l'acception de la demande de paiement.
+     */
+    decision: boolean;
+} | {
+    /**
+     * La décision à `false` indique le rejet de la demande de paiement.
+     */
+    decision: boolean;
+    raison: DemandePaiementReponseRequest.raison;
+});
+declare namespace DemandePaiementReponseRequest {
+    enum raison {
+        BE05 = "BE05",
+        AM09 = "AM09",
+        APAR = "APAR",
+        RR07 = "RR07",
+        FR01 = "FR01"
+    }
+}
+
+type ListeMeta = {
+    /**
+     * total d'éléments correspondants à la recherche
+     */
+    length?: number;
+    /**
+     * numéro ou identifiant de la page suivante
+     */
+    page?: number;
+    /**
+     * nombre d'éléments retournés
+     */
+    limit?: number;
+};
+
+/**
+ *
+ * **Motifs d'annulation d'un paiement:**
+ * - **AC03** Erreur sur le destinataire
+ * - **AM09** Erreur sur le montant
+ * - **SVNR** Service non rendu
+ * - **DUPL** Transaction déjà payée
+ * - **FRAD** Suspicion de fraude
+ *
+ */
+declare enum PaiementAnnulationMotif {
+    AC03 = "AC03",
+    AM09 = "AM09",
+    SVNR = "SVNR",
+    DUPL = "DUPL",
+    FRAD = "FRAD"
+}
+
+/**
+ *
+ * **Raisons de rejet ou d'echec des demandes d'annulation :**
+ * - **CUST** (Customer Decision) : Lorsque la demande d'annulation (camt.056) est rejetée par le client payé.
+ * - **AC04** (Closed Account Number) : Le numéro de compte spécifié a été clôturé dans les livres du participant payé
+ * - **ARDT** (Already Returned) : La transaction a déjà été annulée
+ * - **AG10** (Agent Suspended) : Le participant payeur est désactivé.
+ * - **AG11** (Creditor Agent Suspended) : Le participant payé est désactivé.
+ * - **FR01** (Fraud) : Rejeté pour suspicion de fraude.
+ * - **RR04** (Regulatory Reason) : Raison règlementaire, notamment lorsque le bénéficiaire figure dans une liste d'interdiction.
+ *
+ */
+declare enum PaiementAnnulationStatutRaison {
+    CUST = "CUST",
+    AC04 = "AC04",
+    ARDT = "ARDT",
+    AG10 = "AG10",
+    AG11 = "AG11",
+    FR01 = "FR01",
+    RR04 = "RR04"
+}
+
+type PaiementRequest = {
+    /**
+     * Identifiant de la transaction dans le SI du client
+     */
+    txId: string;
+    /**
+     * Le client business a la possibilité de préciser le compte qui sera débité pour le paiement.
+     *
+     */
+    payeurAlias: string;
+    /**
+     * L'alias du client payé, bénéficiaire de l'ordre de paiement
+     */
+    payeAlias: string;
+    /**
+     * Le montant du transfert à effectuer
+     */
+    montant: number;
+    /**
+     * Le numéro / la référence du document justificatif
+     */
+    refDocNumero?: string;
+    refDocType?: RefDocType;
+    /**
+     * Le motif du paiement
+     */
+    motif?: string;
+    /**
+     * Indique si le paiement executé est un paiement programmé
+     */
+    programme?: boolean;
+};
+
+/**
+ * - `INITIE` si la confirmation du client est attendue suite à la recherche d'alias
+ * - `ENVOYE` si les validations sont concluantes et que le PSP a envoyé la demande
+ * - `IRREVOCABLE` si le payeur a accepté la demande
+ * - `REJETE` si le payeur rejette la demande
+ *
+ */
+declare enum PaiementStatut {
+    INITIE = "INITIE",
+    ENVOYE = "ENVOYE",
+    IRREVOCABLE = "IRREVOCABLE",
+    REJETE = "REJETE"
+}
+
+/**
+ *
+ * **Raisons de rejet ou d'echec des paiements :**
+ * - **BE23** (Alias invalid) : L'alias du payeur n'existe pas ou est invalide.
+ * - **DU03** (Duplicate Transaction) : Le txId n'est pas unique
+ *
+ * - **AB03** (Aborted Settlement Timeout) : Message en timeout lors du règlement.
+ * - **AB04** (Aborted Settlement Fatal Error) : Transaction rejetée à cause d'une erreur fatale.
+ * - **AB08** (Offline Creditor Agent) : Le système du participant payé n'est pas accessible.
+ * - **AB09** (Error Creditor Agent) : Transaction rejetée à cause d'une erreur chez le participant payé.
+ * - **AC03** (Invalid Creditor Account Number) : Le numéro de compte du payé est invalide.
+ * - **AC06** (Blocked Account) : Le compte spécifié est bloqué.
+ * - **AC07** (Closed Creditor Account Number) : Le compte du payé est clôturé.
+ * - **AG01** (Transaction Forbidden) : Transaction interdite sur ce type de compte.
+ * - **AG10** (Agent Suspended) : Le participant payeur est désactivé.
+ * - **AG11** (Creditor Agent Suspended) : Le participant payé est désactivé.
+ * - **AEXR** (Already Expired RTP) : La demande de paiement a déjà expiré.
+ * - **ALAC** (Already Accepted RTP) : La demande de paiement a déjà été acceptée.
+ * - **AM02** (Not Allowed Amount) : Le montant de la transaction est supérieur au maximum autorisé.
+ * - **AM04** (Insufficient Funds) : Le solde de garantie du participant payeur est insuffisant.
+ * - **AM09** (Wrong Amount) : Le montant du transfert est différent du montant attendu.
+ * - **AM21** (Limit Exceeded) : Le montant de la transaction dépasse les limites convenues entre le participant et le client.
+ * - **ARFR** (Already Refused RTP) : La demande de paiement a déjà été refusée.
+ * - **ARJR** (Already Rejected RTP) : La demande de paiement a déjà été rejetée.
+ * - **BE01** (Inconsistent With End Customer) : L'identification du client final n'est pas liée au numéro de compte associé.
+ * - **FR01** (Fraud) : Rejeté pour suspicion de fraude.
+ * - **IRNR** (Initial RTP Never Received) : La demande de paiement n'a jamais été reçue.
+ * - **RR04** (Regulatory Reason) : Raison règlementaire, notamment lorsque le bénéficiaire figure dans une liste d'interdiction.
+ *
+ */
+declare enum PaiementStatutRaison {
+    BE23 = "BE23",
+    DU03 = "DU03",
+    AB03 = "AB03",
+    AB04 = "AB04",
+    AB08 = "AB08",
+    AB09 = "AB09",
+    AC03 = "AC03",
+    AC06 = "AC06",
+    AC07 = "AC07",
+    AG01 = "AG01",
+    AG10 = "AG10",
+    AG11 = "AG11",
+    AEXR = "AEXR",
+    ALAC = "ALAC",
+    AM02 = "AM02",
+    AM04 = "AM04",
+    AM09 = "AM09",
+    AM21 = "AM21",
+    ARFR = "ARFR",
+    ARJR = "ARJR",
+    BE01 = "BE01",
+    FR01 = "FR01",
+    IRNR = "IRNR",
+    RR04 = "RR04"
+}
+
+/**
+ * - `INITIE` si l'envoi du retour de fonds est initié
+ * - `ENVOYE` si le participant a envoyé le retour de fonds
+ * - `IRREVOCABLE` lorsque le retour de fonds est irrévocable
+ * - `REJETE` Lorsque le retour de fonds est rejeté
+ *
+ */
+declare enum RetourStatut {
+    INITIE = "INITIE",
+    ENVOYE = "ENVOYE",
+    IRREVOCABLE = "IRREVOCABLE",
+    REJETE = "REJETE"
+}
+
+/**
+ *
+ * **Raisons de rejet ou d'echec des retours de fonds :**
+ * - **AB03** (Aborted Settlement Timeout) : Message en timeout lors du règlement.
+ * - **AB04** (Aborted Settlement Fatal Error) : Transaction rejetée à cause d'une erreur fatale.
+ * - **AC06** (Blocked Account) : Le compte spécifié est bloqué.
+ * - **AG10** (Agent Suspended) : Le participant payeur est désactivé.
+ * - **AG11** (Creditor Agent Suspended) : Le participant payé est désactivé.
+ * - **AM04** (Insufficient Funds) : Le solde de garantie du participant payé est insuffisant.
+ * - **AM09** (Wrong Amount) : Le montant du transfert est différent du montant attendu.
+ * - **FR01** (Fraud) : Rejeté pour suspicion de fraude.
+ * - **RR04** (Regulatory Reason) : Raison règlementaire, notamment lorsque le bénéficiaire figure dans une liste d'interdiction.
+ *
+ */
+declare enum RetourStatutRaison {
+    AB03 = "AB03",
+    AB04 = "AB04",
+    AC06 = "AC06",
+    AG10 = "AG10",
+    AG11 = "AG11",
+    AM04 = "AM04",
+    AM09 = "AM09",
+    FR01 = "FR01",
+    RR04 = "RR04"
+}
+
+type Paiement = (PaiementRequest & {
+    /**
+     * Lorsque le PSP recoit la demande, il effectue une recherche d'alias en vue d'obtenir les informations de compte du client payé.
+     *
+     * L'attribut `confirmation` permet au client d'indiquer à son PSP si celui-ci doit lui retourner les resultats de la recherche d'alias pour confirmation:
+     *
+     * - La valeur `true` de la validation indique au PSP qu'il doit retourner le resultat de la recherche d'alias au client et attendre une validation avant d'effectuer le paiement.
+     * - La valeur `false` indique qu'une validation n'est pas requise pour la demande, de ce fait, le PSP transmet la demande à PI sans attendre la validation du client business.
+     *
+     */
+    confirmation?: boolean;
+    /**
+     * Le nom du payé (Retourné dans le cas d'un paiement envoyé)
+     */
+    payeNom?: string;
+    /**
+     * Le pays de residence du payé (Retourné dans le cas d'un paiement envoyé)
+     */
+    payePays?: string;
+    /**
+     * Le nom du payeur (Retourné dans le cas d'un paiement reçu)
+     */
+    payeurNom?: string;
+    /**
+     * Le pays de residence du payeur (Retourné dans le cas d'un paiement reçu)
+     */
+    payeurPays?: string;
+    /**
+     * Le numéro de compte du payeur
+     */
+    payeurCompte?: string;
+    /**
+     * Le numéro de compte du payé
+     */
+    payeCompte?: string;
+    /**
+     * La catégorie du paiement / Canal de paiement
+     * - `631` Demande de paiement provenant d'un particulier
+     * - `000` Paiement par QR Code Statique
+     * - `400` Paiement par QR Code Dynamique
+     * - `733` Ordre de paiement via l'API Business
+     * - `300` Via le canal USSD
+     * - `999` Ordre de transfert bancaire
+     * - `500` Demande de Paiement sur site
+     * - `521` Demande de Paiement e-commerce
+     * - `401` Autres demandes de paiement de facture
+     *
+     */
+    categorie?: Paiement.categorie;
+    statut?: PaiementStatut;
+    statutRaison?: PaiementStatutRaison;
+    /**
+     * Identifiant unique de bout en bout de la transaction
+     */
+    end2endId?: string;
+    /**
+     * Identifiant du paiement en masse dans le SI du client
+     */
+    instructionId?: string;
+    /**
+     * Les frais appliqués par le participant (Optionnel - dépend du modèle de facturation utilisé par le participant)
+     */
+    montantFrais?: number;
+    /**
+     * Date de création du paiement: date et heure à laquelle le paiement a été initié par le client business.
+     *
+     */
+    dateDemande?: string;
+    /**
+     * Date de confirmation de la demande si le client payé avait requis la confirmation du paiement.
+     * Il s'agit de la date et heure à laquelle le client a confirmé la transaction.
+     *
+     * Pour un paiement reçu, cette date correspond à la date de confirmation du paiement par le payeur.
+     *
+     */
+    dateConfirmation?: string;
+    /**
+     * Date d'envoi de la demande: date et heure à laquelle le paiement est envoyé par le participant (PSP)
+     *
+     */
+    dateEnvoi?: string;
+    /**
+     * Date à laquelle le paiement est irrévocable
+     *
+     */
+    dateIrrevocabilite?: string;
+    /**
+     * Date à laquelle la réponse du paiement a été reçue
+     *
+     */
+    dateReponse?: string;
+    retourStatut?: RetourStatut;
+    retourStatutRaison?: RetourStatutRaison;
+    /**
+     * Date de création du paiement: date et heure à laquelle le retour de fonds a été initié par le client business.
+     *
+     */
+    retourDateDemande?: string;
+    /**
+     * Date à laquelle le retour de fonds est irrévocable
+     *
+     */
+    retourDateIrrevocabilite?: string;
+    /**
+     * Date à laquelle la réponse au retour de fonds a été reçue
+     *
+     */
+    retourDateReponse?: string;
+    annulationStatut?: AnnulationStatut;
+    annulationMotif?: PaiementAnnulationMotif;
+    annulationStatutRaison?: PaiementAnnulationStatutRaison;
+    /**
+     * Date de reception de la demande d'annulation par le participant
+     *
+     */
+    annulationDateDemande?: string;
+    /**
+     * Date à laquelle la réponse à la demande d'annulation a été reçue (Date de rejet de la demande)
+     *
+     */
+    annulationDateReponse?: string;
+});
+declare namespace Paiement {
+    /**
+     * La catégorie du paiement / Canal de paiement
+     * - `631` Demande de paiement provenant d'un particulier
+     * - `000` Paiement par QR Code Statique
+     * - `400` Paiement par QR Code Dynamique
+     * - `733` Ordre de paiement via l'API Business
+     * - `300` Via le canal USSD
+     * - `999` Ordre de transfert bancaire
+     * - `500` Demande de Paiement sur site
+     * - `521` Demande de Paiement e-commerce
+     * - `401` Autres demandes de paiement de facture
+     *
+     */
+    enum categorie {
+        _631 = "631",
+        _000 = "000",
+        _400 = "400",
+        _733 = "733",
+        _300 = "300",
+        _999 = "999",
+        _500 = "500",
+        _521 = "521",
+        _401 = "401"
+    }
+}
+
+/**
+ * Acceptation de la demande d'annulation
+ */
+type PaiementAnnulationReponseRequestAccepter = {
+    /**
+     * La décision à `true` indique l'acceptation de la demande d'annulation.
+     */
+    decision: boolean;
+};
+
+/**
+ * Refus de la demande d'annulation
+ */
+type PaiementAnnulationReponseRequestRejeter = {
+    /**
+     * La décision à `false` indique le refus de la demande d'annulation.
+     */
+    decision: boolean;
+};
+
+/**
+ * Réponse à une demande d'annulation de paiement.
+ *
+ * Le business peut accepter ou refuser la demande d'annulation :
+ * - `decision: true` : Accepte la demande d'annulation
+ * - `decision: false` : Refuse la demande d'annulation
+ *
+ */
+type PaiementAnnulationReponseRequest = (PaiementAnnulationReponseRequestAccepter | PaiementAnnulationReponseRequestRejeter);
+
+type PaiementAnnulationRequest = {
+    raison: PaiementAnnulationMotif;
+};
+
+/**
+ * Confirmation du paiement en masse
+ */
+type PaiementEnMasseConfirmationRequestAccepter = {
+    /**
+     * La décision à `true` indique la confirmation du paiement en masse.
+     */
+    decision: boolean;
+};
+
+/**
+ * Annulation du paiement en masse
+ */
+type PaiementEnMasseConfirmationRequestRejeter = {
+    /**
+     * La décision à `false` indique l'annulation du paiement en masse.
+     */
+    decision: boolean;
+};
+
+type PaiementEnMasseConfirmationRequest = (PaiementEnMasseConfirmationRequestAccepter | PaiementEnMasseConfirmationRequestRejeter);
+
+type PaiementEnMasseReponseStatut = {
+    /**
+     * Identifiant du paiement en masse
+     */
+    instructionId?: string;
+    /**
+     * Statut global du paiement en masse:
+     * - `INITIE`: Créé avec confirmation demandée, en attente de confirmation
+     * - `CONFIRME`: Confirmé et en cours de traitement (ou traitement terminé)
+     * - `ANNULE`: Annulé par le business avant confirmation
+     *
+     * **Évolution selon le mode de création :**
+     * - Si créé **avec confirmation** (`confirmation: true`) : `INITIE` → `CONFIRME` (après PUT /confirmations) ou `ANNULE`
+     * - Si créé **sans confirmation** (`confirmation: false`) : Directement `CONFIRME` (aucune action requise du business)
+     *
+     */
+    statut?: PaiementEnMasseReponseStatut.statut;
+    /**
+     * Date d'expiration de la confirmation (délai adaptatif selon nombre de transactions).
+     * Présent uniquement si statut = INITIE.
+     *
+     * Délais :
+     * - 1 à 500 transactions : 24 heures
+     * - 501 à 1000 transactions : 48 heures
+     * - Plus de 1000 transactions : 72 heures
+     *
+     */
+    dateExpiration?: string;
+    /**
+     * Nombre total de transactions dans le paiement en masse
+     */
+    transactionsTotal?: number;
+    /**
+     * Nombre de transactions à l'état `INITIE` (validées avec succès, prêtes à être envoyées).
+     *
+     * Si créé avec `confirmation: true`, ces transactions ont passé toutes les validations :
+     * - txId unique (pas de duplication)
+     * - Alias valide (recherche d'alias réussie)
+     * - Nom et pays du bénéficiaire disponibles
+     *
+     * Ce sont ces transactions qui seront envoyées lors de la confirmation.
+     *
+     * **Vérification de fin de validation :** La validation est terminée quand `transactionsInitiees + transactionsRejetees = transactionsTotal`.
+     *
+     */
+    transactionsInitiees?: number;
+    /**
+     * Nombre de transactions à l'état `ENVOYE` (en cours d'envoi vers le système bancaire)
+     */
+    transactionsEnvoyees?: number;
+    /**
+     * Nombre de transactions à l'état `IRREVOCABLE` (paiements réussis et finalisés)
+     */
+    transactionsIrrevocables?: number;
+    /**
+     * Nombre de transactions à l'état `REJETE` (échecs de validation ou d'envoi).
+     *
+     * Comprend :
+     * - Rejets de validation (avant envoi) : BE23 (alias invalide), DU03 (txId dupliqué)
+     * - Rejets d'envoi (après confirmation) : AM04 (solde insuffisant), AGNT (PSP indisponible), etc.
+     *
+     * **Note :** Les transactions rejetées à la validation ne sont jamais envoyées, même si le bulk est confirmé.
+     *
+     */
+    transactionsRejetees?: number;
+    /**
+     * Date de création du paiement en masse (date de la demande)
+     */
+    dateDemande?: string;
+    /**
+     * Date de confirmation par le business (date d'acceptation de la demande).
+     * Présent uniquement si statut = CONFIRME.
+     *
+     * - Si créé avec confirmation: Date du PUT /confirmations avec decision: true
+     * - Si créé sans confirmation: Correspond à dateDemande (confirmation automatique)
+     *
+     */
+    dateConfirmation?: string;
+};
+declare namespace PaiementEnMasseReponseStatut {
+    /**
+     * Statut global du paiement en masse:
+     * - `INITIE`: Créé avec confirmation demandée, en attente de confirmation
+     * - `CONFIRME`: Confirmé et en cours de traitement (ou traitement terminé)
+     * - `ANNULE`: Annulé par le business avant confirmation
+     *
+     * **Évolution selon le mode de création :**
+     * - Si créé **avec confirmation** (`confirmation: true`) : `INITIE` → `CONFIRME` (après PUT /confirmations) ou `ANNULE`
+     * - Si créé **sans confirmation** (`confirmation: false`) : Directement `CONFIRME` (aucune action requise du business)
+     *
+     */
+    enum statut {
+        INITIE = "INITIE",
+        CONFIRME = "CONFIRME",
+        ANNULE = "ANNULE"
+    }
+}
+
+type PaiementEnMasseRequest = {
+    /**
+     * Identifiant du paiement en masse dans le SI du client
+     */
+    instructionId: string;
+    /**
+     * L'alias du compte du client business qui sera débité pour le paiement.
+     *
+     */
+    payeurAlias: string;
+    /**
+     * Indique si une confirmation du business est requise avant d'exécuter les paiements.
+     *
+     * - `true` : Le PSP effectue la recherche d'alias pour tous les bénéficiaires, retourne leurs noms et pays, et attend la confirmation du business avant d'exécuter les paiements.
+     * - `false` : Le PSP exécute directement les paiements sans attendre de confirmation.
+     *
+     * **Note :** Si `true`, le business doit confirmer via `PUT /paiements-groupes/{instructionId}/confirmations` dans un délai adaptatif (24h, 48h ou 72h selon le nombre de transactions).
+     *
+     */
+    confirmation?: boolean;
+    /**
+     * Le motif commun à tous les paiements du groupe.
+     * Si tous les paiements du groupe ont le même motif, ce champ peut être utilisé pour optimiser la taille du lot.
+     * Dans le cas contraire, chaque transaction doit avoir son propre motif.
+     *
+     */
+    motif?: string;
+    transactions: Array<{
+        /**
+         * Identifiant de la transaction dans le SI du client
+         */
+        txId: string;
+        /**
+         * L'alias du client payé, bénéficiaire de l'ordre de paiement
+         */
+        payeAlias: string;
+        /**
+         * Le montant du transfert de fonds à effectuer
+         */
+        montant: number;
+        /**
+         * Le motif du paiement.
+         * Si tous les paiements du groupe ont le même motif, ce champ doit être omis, et le motif du groupe doit être utilisé.
+         *
+         */
+        motif?: string;
+        /**
+         * Le numéro / la référence du document justificatif
+         */
+        refDocNumero?: string;
+        refDocType?: RefDocType;
+    }>;
+};
+
+type PaiementImmediatRequest = (PaiementRequest & {
+    /**
+     * Lorsque le PSP recoit la demande, il effectue une recherche d'alias en vue d'obtenir les informations de compte du client payé.
+     *
+     * L'attribut `confirmation` permet au client d'indiquer à son PSP si celui-ci doit lui retourner les resultats de la recherche d'alias pour confirmation:
+     *
+     * - La valeur `true` de la validation indique au PSP qu'il doit retourner le resultat de la recherche d'alias au client et attendre une validation avant d'effectuer le paiement.
+     * - La valeur `false` indique qu'une validation n'est pas requise pour la demande, de ce fait, le PSP transmet la demande à PI sans attendre la validation du client business.
+     *
+     */
+    confirmation: boolean;
+});
+
+type PaiementImmediatConfirmationReponse = (PaiementImmediatRequest & {
+    statut?: PaiementImmediatConfirmationReponse.statut;
+    /**
+     * Identifiant unique de bout en bout de la transaction
+     */
+    end2endId?: string;
+    /**
+     * Le nom du payé
+     */
+    payeNom?: string;
+    /**
+     * Le pays de residence du payé
+     */
+    payePays?: string;
+    /**
+     * Date de création du paiement
+     */
+    dateDemande?: string;
+    /**
+     * Date de confirmation de la demande si le client payé avait requis la confirmation du paiement.
+     * Il s'agit de la date et heure à laquelle le business a confirmé l'envoi du paiement.
+     *
+     */
+    dateConfirmation?: string;
+});
+declare namespace PaiementImmediatConfirmationReponse {
+    enum statut {
+        ENVOYE = "ENVOYE"
+    }
+}
+
+/**
+ * Confirmation du paiement immédiat
+ */
+type PaiementImmediatConfirmationRequestAccepter = {
+    /**
+     * La décision à `true` indique la confirmation du paiement.
+     */
+    decision: boolean;
+};
+
+/**
+ * Annulation du paiement
+ */
+type PaiementImmediatConfirmationRequestRejeter = {
+    /**
+     * La décision  à `false`  indique l'annulation du paiement.
+     */
+    decision: boolean;
+};
+
+type PaiementImmediatConfirmationRequest = (PaiementImmediatConfirmationRequestAccepter | PaiementImmediatConfirmationRequestRejeter);
+
+type PaiementImmediatReponse = ((PaiementRequest & {
+    statut: PaiementImmediatReponse.statut;
+    confirmation: boolean;
+    /**
+     * Le nom du payé
+     */
+    payeNom: string;
+    /**
+     * Le pays de residence du payé
+     */
+    payePays: string;
+    /**
+     * Identifiant unique de bout en bout de la transaction
+     */
+    end2endId: string;
+    /**
+     * Date de création du paiement: date et heure à laquelle le paiement a été initié par le client business.
+     *
+     */
+    dateDemande: string;
+    /**
+     * Les frais appliqués par le participant (Optionnel - dépend du modèle de facturation utilisé par le participant)
+     */
+    montantFrais?: number;
+}) | (PaiementRequest & {
+    statut: PaiementImmediatReponse.statut;
+    confirmation: boolean;
+    /**
+     * Le nom du bénéficiaire
+     */
+    payeNom: string;
+    /**
+     * Le pays de résidence du bénéficiaire
+     */
+    payePays: string;
+    /**
+     * Identifiant unique de bout en bout de la transaction
+     */
+    end2endId: string;
+    /**
+     * Date de création du paiement: date et heure à laquelle le paiement a été initié par le client business.
+     *
+     */
+    dateDemande: string;
+    /**
+     * Date d'acceptation de la demande:  date et heure à laquelle l'ordre de transfert du client business est reçu par le participant.
+     *
+     * Dans le cas d'un paiement sans confirmation, elle correspond également à `dateDemande`.
+     *
+     */
+    dateConfirmation: string;
+    /**
+     * Date d'envoi du paiement
+     */
+    dateEnvoi?: string;
+    /**
+     * Les frais appliqués par le participant (Optionnel - dépend du modèle de facturation utilisé par le participant)
+     */
+    montantFrais?: number;
+}) | (PaiementRequest & {
+    statut: PaiementImmediatReponse.statut;
+    statutRaison: PaiementStatutRaison;
+    /**
+     * Le nom du bénéficiaire (présent seulement si la recherche d'alias a réussi).
+     *
+     * Absent si statutRaison = BE23 (alias invalide).
+     * Présent si statutRaison = DU03 (txId dupliqué) ou autres codes.
+     *
+     */
+    payeNom?: string;
+    /**
+     * Le pays de résidence du bénéficiaire (présent seulement si la recherche d'alias a réussi).
+     *
+     * Absent si statutRaison = BE23 (alias invalide).
+     * Présent si statutRaison = DU03 (txId dupliqué) ou autres codes.
+     *
+     */
+    payePays?: string;
+    /**
+     * Identifiant unique de bout en bout de la transaction
+     */
+    end2endId: string;
+    /**
+     * Date de création du paiement
+     */
+    dateDemande: string;
+    /**
+     * Date à laquelle le paiement a été rejeté
+     */
+    dateReponse?: string;
+}));
+declare namespace PaiementImmediatReponse {
+    enum statut {
+        INITIE = "INITIE"
+    }
+}
+
+type PaiementListe = {
+    data?: Array<Paiement>;
+    meta?: ListeMeta;
+};
+
+type Problem7807 = {
+    /**
+     * Référence URI qui identifie le type de problème
+     */
+    type?: string;
+    /**
+     * Un bref résumé du problème
+     */
+    title?: string;
+    /**
+     * Le code d'état HTTP pour cette occurrence du problème
+     */
+    status?: number;
+    /**
+     * Explication spécifique à cette occurrence du problème
+     */
+    detail?: string;
+    /**
+     * Liste des paramètres invalides
+     */
+    'invalid-params'?: Array<{
+        /**
+         * Nom du paramètre invalide
+         */
+        name?: string;
+        /**
+         * Raison de l'invalidité du paramètre
+         */
+        reason?: string;
+    }>;
+};
+
+declare enum WebhooksEvents {
+    PAIEMENT_RECU = "PAIEMENT_RECU",
+    PAIEMENT_ENVOYE = "PAIEMENT_ENVOYE",
+    PAIEMENT_REJETE = "PAIEMENT_REJETE",
+    RTP_RECU = "RTP_RECU",
+    RTP_REJETE = "RTP_REJETE",
+    ANNULATION_DEMANDE = "ANNULATION_DEMANDE",
+    ANNULATION_REJETE = "ANNULATION_REJETE",
+    RETOUR_ENVOYE = "RETOUR_ENVOYE",
+    RETOUR_REJETE = "RETOUR_REJETE",
+    RETOUR_RECU = "RETOUR_RECU"
+}
+
+type WebhookCreationRequest = {
+    callbackUrl: string;
+    /**
+     * l'alias auquel est rattaché le point de rappel pour recevoir des notifications liées à un alias de compte
+     *
+     */
+    alias?: string;
+    /**
+     * les évènements dont les notifications seront envoyés sur le point de terminaison
+     *
+     */
+    events?: Array<WebhooksEvents>;
+};
+
+type WebhookCreationResponse = (WebhookCreationRequest & {
+    id?: string;
+    /**
+     * Date et heure d'enregistrement du webhook. Conforme à la RFC ISO 8601
+     */
+    dateCreation?: string;
+    /**
+     * Le secret doit être enregistré de façon sécurisée . Il n'est envoyé qu'à la création du webhook.
+     */
+    secret?: string;
+});
+
+type WebhookData = ({
+    id?: string;
+    /**
+     * Date et heure d'enregistrement du webhook. Conforme à la RFC ISO 8601
+     */
+    dateCreation?: string;
+} & WebhookCreationRequest);
+
+type WebhookEvent = {
+    evCode: WebhooksEvents;
+    /**
+     * Date et heure de l'événement.
+     * POur un transfert irrévocable par exemple c'est la date d'irrévocabilité
+     *
+     */
+    evDate: string;
+    /**
+     * Identifiant de la transaction dans le SI du client
+     */
+    txId: string;
+    /**
+     * Identifiant de l'ordre de transfert ou de la demande de paiement
+     */
+    end2endId: string;
+    /**
+     * Identifiant de l'instruction de paiement (Pour les paiements en masse)
+     */
+    instructionId?: string;
+    /**
+     * Le montant du paiement ou demande de paiement ou demande retour
+     */
+    montant: number;
+    /**
+     * Le nom du client payeur ou payé en fonction du type d'événement
+     */
+    client?: string;
+    /**
+     * Alias de compte du client business sur lequel porte l'événement
+     */
+    alias?: string;
+    /**
+     * Le motif d'un paiement reçu ou envoyé est un texte libre renseigné par le client payeur.
+     *
+     * Le motif d'une demande de paiement reçue est un texte libre renseigné par le client payé.
+     *
+     * En dehors de ces cas, le motif est l'un des codes suivants en fonction du type d'événement :
+     *
+     * **Motifs de rejet des demandes de paiement :**
+     *
+     * - **AC04** (Closed Account Number) : Le compte du client payeur est clôturé.
+     * - **AC06** (Blocked Account) : Le compte du client payeur est bloqué.
+     * - **AEXR** (Already Expired RTP) : La demande de paiement a déjà expiré.
+     * - **AG03** (Transaction Not Supported) : Le client n'est pas autorisé à payer en mode débit différé.
+     * - **AG10** (Agent Suspended) : Le participant payeur est suspendu.
+     * - **AG11** (Creditor Agent Suspended) : Le participant payé est désactivé.
+     * - **ALAC** (Already Accepted RTP) : La demande de paiement a déjà été acceptée.
+     * - **AM02** (Not Allowed Amount) : Le montant spécifique de la transaction dépasse le montant maximum autorisé.
+     * - **AM09** (Wrong Amount) : Le montant reçu ne correspond pas au montant convenu ou attendu.
+     * - **AM14** (Amount Exceeds Agreed Limit) : Le montant de la transaction fait dépasser le plafond de débit différé du client.
+     * - **APAR** (Already Paid RTP) : Le paiement demandé a déjà été effectué par le payeur.
+     * - **ARFR** (Already Refused RTP) : La demande de paiement a déjà été refusée.
+     * - **ARJR** (Already Rejected RTP) : La demande de paiement a déjà été rejetée.
+     * - **BE01** (Inconsistent With End Customer) : L'identification du client final n'est pas liée au numéro de compte associé.
+     * - **BE05** (Unrecognised Initiating Party) : La partie qui a initié le message n'est pas reconnue par le client final.
+     * - **FR01** (Fraud) : Rejeté pour suspicion de fraude.
+     * - **RR07** (Remittance Information Invalid) : Le justificatif de la demande de paiement est invalide (par exemple, le numéro de facture est invalide).
+     *
+     * **Motifs de rejet des paiements :**
+     *
+     * - **AB03** (Aborted Settlement Timeout) : Message en timeout lors du règlement.
+     * - **AB04** (Aborted Settlement Fatal Error) : Transaction rejetée à cause d'une erreur fatale.
+     * - **AB08** (Offline Creditor Agent) : Le système du participant payé n'est pas accessible.
+     * - **AB09** (Error Creditor Agent) : Transaction rejetée à cause d'une erreur chez le participant payé.
+     * - **AC03** (Invalid Creditor Account Number) : Le numéro de compte du payé est invalide.
+     * - **AC06** (Blocked Account) : Le compte spécifié est bloqué.
+     * - **AC07** (Closed Creditor Account Number) : Le compte du payé est clôturé.
+     * - **AG01** (Transaction Forbidden) : Transaction interdite sur ce type de compte.
+     * - **AG10** (Agent Suspended) : Le participant payeur est désactivé.
+     * - **AG11** (Creditor Agent Suspended) : Le participant payé est désactivé.
+     * - **AEXR** (Already Expired RTP) : La demande de paiement a déjà expiré.
+     * - **ALAC** (Already Accepted RTP) : La demande de paiement a déjà été acceptée.
+     * - **AM02** (Not Allowed Amount) : Le montant de la transaction est supérieur au maximum autorisé.
+     * - **AM04** (Insufficient Funds) : Le solde de garantie du participant payeur est insuffisant.
+     * - **AM09** (Wrong Amount) : Le montant du transfert est différent du montant attendu.
+     * - **AM21** (Limit Exceeded) : Le montant de la transaction dépasse les limites convenues entre le participant et le client.
+     * - **ARFR** (Already Refused RTP) : La demande de paiement a déjà été refusée.
+     * - **ARJR** (Already Rejected RTP) : La demande de paiement a déjà été rejetée.
+     * - **BE01** (Inconsistent With End Customer) : L'identification du client final n'est pas liée au numéro de compte associé.
+     * - **FR01** (Fraud) : Rejeté pour suspicion de fraude.
+     * - **IRNR** (Initial RTP Never Received) : La demande de paiement n'a jamais été reçue.
+     * - **RR04** (Regulatory Reason) : Raison règlementaire, notamment lorsque le bénéficiaire figure dans une liste d'interdiction.
+     *
+     * **Motifs d'une demandes d'annulation :**
+     *
+     * - **DUPL** (Duplicate Payment) : Déjà payé.
+     * - **AM09** (Wrong Amount) : Erreur sur le montant.
+     * - **AC03** (Invalid Creditor Account Number) : Erreur sur le destinataire.
+     * - **SVNR** (Service Not Rendered) : Le paiement est annulé car le produit n'a pas été livré ou le service n'a pas été rendu.
+     * - **FRAD** (Fraudulent Origin) : Annulation demandée à la suite d'une transaction dont l'origine est frauduleuse.
+     *
+     * **Motifs de rejet d'une demande d'annulation :**
+     *
+     * - **ARDT** (Already Returned) : La transaction est déjà retournée.
+     * - **CUST** (Customer Decision) : Le client payé rejette la demande d'annulation.
+     * - **AC04** (Closed Account Number) : Le numéro de compte spécifié a été clôturé dans les livres du participant payé.
+     *
+     * **Motifs d'un retour de fonds reçu ou envoyé :**
+     *
+     * - **AC06** (Blocked Account) : Le compte du payé est bloqué.
+     * - **AC07** (Closed Creditor Account Number) : Le compte du payé est clôturé.
+     * - **MD06** (Refund Request By End Customer) : Retour de fonds initié par le client payé.
+     * - **CUST** (Requested By Customer) : Retour de fonds demandé suite à une demande d'annulation envoyée par le payeur.
+     * - **FR01** (Fraud) : Retourné à la suite d'une fraude.
+     * - **RR04** (Regulatory Reason) : Raison règlementaire, notamment lorsque le bénéficiaire figure dans une liste d'interdiction.
+     *
+     *
+     * **Motifs de rejet d'un retour de fonds :**
+     *
+     * - **AB03** (Aborted Settlement Timeout) : Timeout.
+     * - **AB04** (Aborted Settlement Fatal Error) : Transaction rejetée à cause d'une erreur fatale.
+     * - **AG10** (Agent Suspended) : Le participant payeur est désactivé.
+     * - **AG11** (Creditor Agent Suspended) : Le participant payé est désactivé.
+     * - **AM04** (Insufficient Funds) : Le solde de garantie du participant payé est insuffisant.
+     * - **AC04** (Closed Account Number) : Le compte du payeur est clôturé.
+     * - **AC06** (Blocked Account) : Le compte du payeur est bloqué.
+     * - **AG01** (Transaction Forbidden) : Transaction interdite sur ce type de compte.
+     * - **AM21** (Limit Exceeded) : Le montant de la transaction dépasse les limites convenues entre le participant et le client.
+     * - **RR04** (Regulatory Reason) : Raison règlementaire, notamment lorsque le bénéficiaire figure dans une liste d'interdiction.
+     * - **FR01** (Fraud) : Rejeté pour suspicion de fraude.
+     *
+     */
+    motif?: string;
+    /**
+     * Le type de document justificatif associé à la transaction. Les types de documents disponibles sont :
+     * - **QUOT** (Quotation) : Devis commercial détaillant les conditions d'offre.
+     * - **PROF** (Proforma Invoice) : Facture pro forma, engagement préliminaire du vendeur (prix/conditions), sans enregistrement comptable réel.
+     * - **CINV** (Commercial Invoice) : Facture commerciale standard pour la vente de biens ou services. Utilisée pour les paiements directs d'une facture émise par le vendeur.
+     * - **CMCN** (Commercial Contract) : Contrat commercial entre les parties, stipulant les termes et conditions de la livraison de biens ou de services.
+     * - **DISP** (Dispatch Advice) : Avis d'expédition ou bon de livraison.
+     * - **PUOR** (Purchase Order) : Bon de commande émis par l'acheteur.
+     * - **CONT** (Contract) : Document contractuel prouvant un accord entre vendeur et acheteur pour biens ou services.
+     * - **HIRI** (Hire Invoice) : Facture pour location de ressources humaines (ex : intérim) ou biens/équipements.
+     * - **INVS** (Invoice Signed) : Facture signée, validée électroniquement ou physiquement. Indique une approbation formelle avant paiement.
+     * - **MSIN** (Metered Service Invoice) : Facture pour services mesurés (ex : gaz, électricité via compteur fixe). Inclut la consommation réelle.
+     * - **SPRR** (Seller Presentment) : Document de présentation par le vendeur pour supporter l'acquisition (ex : preuve de livraison ou justificatif).
+     * - **TISH** (Time Sheet) : Feuille de temps enregistrant les heures pour services/prestations ou livraison. Pour paiements basés sur le temps (ex : consulting, freelance).
+     * - **USAR** (Usage Report) : Rapport d'utilisation indiquant le pattern de consommation (ex : SaaS, télécoms). Similaire à MSIN mais plus large (non forcément mesuré).
+     * - **BOLD** (Bill Of Lading) : Document de transport maritime ou logistique (connaissement) prouvant l'expédition des marchandises. Spécifique au transport multimodal (ex : maritime, aérien).
+     * - **SOAC** (Statement Of Account) : Relevé de compte émis par le fournisseur, listant les transactions enregistrées pour le débiteur (ex : factures, paiements, ajustements).
+     * - **VCHR** (Voucher) : Document électronique de paiement (bon ou coupon) représentant une obligation ou un droit de paiement. Souvent utilisé pour des paiements préautorisés ou des remises spécifiques.
+     *
+     */
+    refDocType?: WebhookEvent.refDocType;
+    /**
+     * Le numéro du document justificatif
+     */
+    refDocNumero?: string;
+};
+declare namespace WebhookEvent {
+    /**
+     * Le type de document justificatif associé à la transaction. Les types de documents disponibles sont :
+     * - **QUOT** (Quotation) : Devis commercial détaillant les conditions d'offre.
+     * - **PROF** (Proforma Invoice) : Facture pro forma, engagement préliminaire du vendeur (prix/conditions), sans enregistrement comptable réel.
+     * - **CINV** (Commercial Invoice) : Facture commerciale standard pour la vente de biens ou services. Utilisée pour les paiements directs d'une facture émise par le vendeur.
+     * - **CMCN** (Commercial Contract) : Contrat commercial entre les parties, stipulant les termes et conditions de la livraison de biens ou de services.
+     * - **DISP** (Dispatch Advice) : Avis d'expédition ou bon de livraison.
+     * - **PUOR** (Purchase Order) : Bon de commande émis par l'acheteur.
+     * - **CONT** (Contract) : Document contractuel prouvant un accord entre vendeur et acheteur pour biens ou services.
+     * - **HIRI** (Hire Invoice) : Facture pour location de ressources humaines (ex : intérim) ou biens/équipements.
+     * - **INVS** (Invoice Signed) : Facture signée, validée électroniquement ou physiquement. Indique une approbation formelle avant paiement.
+     * - **MSIN** (Metered Service Invoice) : Facture pour services mesurés (ex : gaz, électricité via compteur fixe). Inclut la consommation réelle.
+     * - **SPRR** (Seller Presentment) : Document de présentation par le vendeur pour supporter l'acquisition (ex : preuve de livraison ou justificatif).
+     * - **TISH** (Time Sheet) : Feuille de temps enregistrant les heures pour services/prestations ou livraison. Pour paiements basés sur le temps (ex : consulting, freelance).
+     * - **USAR** (Usage Report) : Rapport d'utilisation indiquant le pattern de consommation (ex : SaaS, télécoms). Similaire à MSIN mais plus large (non forcément mesuré).
+     * - **BOLD** (Bill Of Lading) : Document de transport maritime ou logistique (connaissement) prouvant l'expédition des marchandises. Spécifique au transport multimodal (ex : maritime, aérien).
+     * - **SOAC** (Statement Of Account) : Relevé de compte émis par le fournisseur, listant les transactions enregistrées pour le débiteur (ex : factures, paiements, ajustements).
+     * - **VCHR** (Voucher) : Document électronique de paiement (bon ou coupon) représentant une obligation ou un droit de paiement. Souvent utilisé pour des paiements préautorisés ou des remises spécifiques.
+     *
+     */
+    enum refDocType {
+        CINV = "CINV",
+        CMCN = "CMCN",
+        DISP = "DISP",
+        PUOR = "PUOR",
+        CONT = "CONT",
+        HIRI = "HIRI",
+        INVS = "INVS",
+        MSIN = "MSIN",
+        PROF = "PROF",
+        QUOT = "QUOT",
+        SPRR = "SPRR",
+        TISH = "TISH",
+        USAR = "USAR",
+        BOLD = "BOLD",
+        SOAC = "SOAC",
+        VCHR = "VCHR"
+    }
+}
+
+type WebhookEventsList = {
+    /**
+     * Liste des événements notifiés
+     */
+    data: Array<WebhookEvent>;
+    meta: {
+        /**
+         * Nombre total d'événements dans cette notification
+         */
+        total: number;
+    };
+};
+
+type WebhookList = {
+    /**
+     * Liste des webhooks configurés
+     */
+    data: Array<WebhookCreationResponse>;
+    meta: {
+        /**
+         * Nombre total de webhooks configurés
+         */
+        total: number;
+    };
+};
+
+type WebhookModificationRequest = {
+    callbackUrl?: string;
+    alias?: string;
+};
+
+declare class AliasService {
+    /**
+     * Créer un alias
+     * Le répertoire des alias de compte permet de créer les types d'alias suivants :
+     * - Une adresse de paiement, codifiée par SHID: cet alias est obtenu par génération d'une clé aléatoire unique sur 36 positions par le système.
+     * - Un identifiant de compte marchand, codifié par MCOD: ce type d'alias est prévu pour supporter les paiements par code USSD.
+     * - Un numéro de téléphone mobile, codifié par MBNO.
+     *
+     * Les types d'alias qu'on peut créer dépendent du type de client.
+     * Les clients de type P (particuliers, personnes physiques) peuvent créer des alias de types MBNO et SHID.
+     * Les clients de types C, B, et G (commerçants ou entreprises individuelles, entreprises, entités gouvernementales) peuvent créer des alias de types SHID et MCOD.
+     *
+     * Un client business peut créer plusieurs alias pour un compte donné.
+     * Une limite de 20 alias par compte est fixée par défaut. Cette limite peut être augmentée selon les besoins du client.
+     *
+     * @returns AliasCreationReponse Opération effectuée avec succès
+     * @throws ApiError
+     */
+    static aliasCreer({ numero, requestBody, }: {
+        /**
+         * Le numéro de compte sur lequel porte la demande
+         */
+        numero: string;
+        /**
+         * Données pour la création d'alias.
+         */
+        requestBody: AliasCreationRequest;
+    }): CancelablePromise<AliasCreationReponse>;
+    /**
+     * Lister les alias
+     * Ce point de terminaison permet de consulter la liste des alias d'un compte.
+     *
+     * @returns AliasReponseListe Succès de l'opération
+     * @throws ApiError
+     */
+    static aliasLister({ numero, }: {
+        /**
+         * Le numéro de compte sur lequel porte la demande
+         */
+        numero: string;
+    }): CancelablePromise<AliasReponseListe>;
+    /**
+     * Supprimer un alias
+     * Le client peut supprimer à tout moment un alias de compte.
+     *
+     * @returns void
+     * @throws ApiError
+     */
+    static aliasSupprimer({ numero, cle, }: {
+        /**
+         * Le numéro de compte
+         */
+        numero: string;
+        /**
+         * La cle de l'alias
+         */
+        cle: string;
+    }): CancelablePromise<void>;
+}
+
+declare class ComptesService {
+    /**
+     * Détails d'un compte
+     * Cet endpoint permet au client de consulter à tout moment les informations détaillées relatives à un compte spécifique.
+     *
+     * Les informations retournées incluent :
+     * - Le type de compte (compte courant, épargne, etc.)
+     * - Le numéro du compte
+     * - La date d'ouverture du compte
+     * - Le solde actuel du compte
+     * - Le statut du compte (ouvert, bloqué ou clôturé)
+     * - L'indicateur de pré-confirmation pour les opérations
+     *
+     * Cette consultation permet au client business de surveiller l'état de ses comptes en temps réel et de prendre des décisions éclairées concernant ses opérations financières.
+     *
+     * @returns CompteSolde Succès de l'opération
+     * @throws ApiError
+     */
+    static compteSoldeConsulter({ numero, }: {
+        /**
+         * Le numéro de compte sur lequel porte la demande
+         */
+        numero: string;
+    }): CancelablePromise<CompteSolde>;
+    /**
+     * Transfert intra-comptes
+     * Le transfert intra-comptes est un transfert de fonds entre deux comptes détenus par la même entité juridique et domiciliés au sein de la même institution financière. Le compte source (débiteur/payeur) et le compte destination (créditeur/bénéficiaire) appartiennent donc au même client.
+     *
+     * @returns CompteTransfertIntraReponse Transfert initié avec succès.
+     * @throws ApiError
+     */
+    static compteTransfertIntraCreer({ requestBody, }: {
+        /**
+         * Données à fournir pour effectuer un transfert intra-comptes.
+         *
+         * Le client business peut effectuer un transfert intra-comptes en utilisant les numéros de compte ou les alias de compte.
+         * La création d'alias n'étant possible que sur certains types de comptes, le participant doit supporter les deux modes de transfert.
+         *
+         */
+        requestBody: CompteTransfertIntraRequest;
+    }): CancelablePromise<CompteTransfertIntraReponse>;
+    /**
+     * Lister les transferts intra-comptes
+     * @returns CompteOperationListe Succès de l'opération
+     * @throws ApiError
+     */
+    static compteTransfertIntraLister({ statut, comptePayeur, comptePaye, dateEnvoi, dateIrrevocabilite, motif, page, size, sort, fields, }: {
+        statut?: string;
+        comptePayeur?: string;
+        comptePaye?: string;
+        dateEnvoi?: string;
+        dateIrrevocabilite?: string;
+        motif?: string;
+        page?: string;
+        size?: string;
+        sort?: string;
+        fields?: any;
+    }): CancelablePromise<CompteOperationListe>;
+}
+
+declare class DemandeAnnulationService {
+    /**
+     * Demander l'annulation d'un paiement
+     * Ce point de terminaison permet de demander l'annulation d'un paiement envoyé.
+     *
+     * À l'acceptation de la demande d'annulation, le payé effectue un retour de fonds et le business recevra une notification `RETOUR_RECU` s'il a souscrit au service de webhook.
+     *
+     * Si le payé refuse la demande d'annulation, le business recevra une notification `ANNULATION_REJETE`.
+     *
+     * **Note importante sur l'idempotence :**
+     *
+     * Cet endpoint utilise **POST (pas PUT)** car chaque appel envoie une **nouvelle demande d'annulation** au PSP bénéficiaire.
+     *
+     * **Comportement :**
+     * - Premier appel → Nouvelle demande d'annulation envoyée
+     * - Deuxième appel → **Nouvelle demande d'annulation envoyée** (pas idempotent)
+     * - Troisième appel → **Nouvelle demande d'annulation envoyée**
+     *
+     * **Cas d'usage :**
+     * - La première demande a été refusée, vous réessayez
+     * - Vous voulez relancer une demande en attente
+     * - Vous avez de nouvelles informations justifiant l'annulation
+     *
+     * @returns Paiement Demande d'annulation envoyée
+     * @throws ApiError
+     */
+    static demandeAnnulationEnvoyer({ end2EndId, requestBody, }: {
+        /**
+         * L'identifiant unique de bout en bout de la transaction
+         */
+        end2EndId: string;
+        requestBody: PaiementAnnulationRequest;
+    }): CancelablePromise<Paiement>;
+    /**
+     * Répondre à une demande d'annulation
+     * Ce point de terminaison permet au business de répondre à une demande d'annulation de paiement.
+     *
+     * Le business peut accepter ou refuser la demande d'annulation :
+     * - `decision: true` : Accepte la demande d'annulation (le business effectuera un retour de fonds)
+     * - `decision: false` : Refuse la demande d'annulation
+     *
+     * **Idempotence** : Cet endpoint est idempotent.
+     * - Premier appel avec `decision: true` → Accepte la demande, retourne `200 OK {statut: "ACCEPTEE"}`
+     * - Appels suivants avec `decision: true` → Retourne `200 OK` avec l'état actuel - idempotent
+     * - Premier appel avec `decision: false` → Refuse la demande, retourne `200 OK {statut: "REJETEE"}`
+     * - Appels suivants avec `decision: false` → Retourne `200 OK {statut: "REJETEE"}` (idempotent)
+     * - `decision: true` après `decision: false` → Retourne `403 Forbidden` (déjà refusée)
+     * - `decision: false` après `decision: true` → Retourne `403 Forbidden` (déjà acceptée)
+     *
+     * @returns Paiement Réponse à la demande d'annulation enregistrée.
+     *
+     * La réponse retourne l'objet `Paiement` complet avec les champs mis à jour selon la décision :
+     *
+     * **En cas d'acceptation (`decision: true`)** :
+     * - `annulationStatut` : Mis à jour pour indiquer l'acceptation
+     * - `annulationDateReponse` : Date et heure de la réponse à la demande d'annulation
+     * - Un retour de fonds est automatiquement initié par le participant, donc les champs suivants sont également renseignés :
+     * - `retourStatut` : Statut du retour de fonds (ex: `INITIE`, `ENVOYE`, `IRREVOCABLE`)
+     * - `retourStatutRaison` : Raison du statut du retour de fonds
+     * - `retourDateDemande` : Date de création du retour de fonds
+     * - `retourDateIrrevocabilite` : Date à laquelle le retour de fonds est irrévocable (si applicable)
+     *
+     * **En cas de rejet (`decision: false`)** :
+     * - `annulationStatut` : Mis à jour pour indiquer le rejet (ex: `REJETE`)
+     * - `annulationDateReponse` : Date et heure de la réponse à la demande d'annulation
+     * - Les champs `retour*` ne sont **pas** renseignés car aucun retour de fonds n'est effectué
+     *
+     * @throws ApiError
+     */
+    static demandeAnnulationRepondre({ end2EndId, requestBody, }: {
+        /**
+         * L'identifiant unique de bout en bout de la transaction
+         */
+        end2EndId: string;
+        /**
+         * La réponse du business à la demande d'annulation
+         */
+        requestBody: PaiementAnnulationReponseRequest;
+    }): CancelablePromise<Paiement>;
+}
+
+declare class DemandesDePaiementService {
+    /**
+     * Envoyer une demande
+     * Ce point de terminaison permet d'envoyer une demande de paiement.
+     *
+     * Le business peut définir le champ `confirmation` à `true` pour demander une validation en deux étapes : le PSP retournera d'abord le résultat de la recherche d'alias (avec le nom et le pays du payeur), puis attendra une confirmation explicite avant d'envoyer la demande de paiement au payeur via l'endpoint `PUT /demandes-paiements/{txId}/confirmations`.
+     *
+     * Si le champ `confirmation` n'est pas défini ou est à `false`, le système envoie directement la demande de paiement au payeur.
+     *
+     * **Timeout de confirmation** : Si le business demande une validation en deux étapes , il dispose de **24 heures** pour confirmer ou annuler. Passé ce délai, la demande expire automatiquement.
+     *
+     * @returns DemandePaiementReponse Demande de paiement traitée. Le champ `statut` indique le résultat :
+     * - `INITIE` : En attente de confirmation (si `confirmation: true`)
+     * - `ENVOYE` : Demande envoyée au payeur avec succès (si `confirmation: false`)
+     * - `REJETE` : Demande rejetée. Le champ `statutRaison` contient le code d'erreur :
+     * - `DU03` : txId dupliqué (déjà utilisé)
+     * - `BE23` : Alias payeur invalide
+     * - Autres codes ISO 20022
+     *
+     * @throws ApiError
+     */
+    static demandePaiementCreer({ requestBody, }: {
+        /**
+         * Données pour envoyer une demande de paiement.
+         */
+        requestBody: DemandePaiementRequest;
+    }): CancelablePromise<DemandePaiementReponse>;
+    /**
+     * Lister les demandes
+     * Ce point de terminaison permet de lister les demandes de paiements effectuées par le client.
+     * @returns DemandePaiementListe Succès de l'opération
+     * @throws ApiError
+     */
+    static demandePaiementLister({ payeAlias, payeCompte, dateEnvoi, dateLimitePaiement, statut, categorie, payeurAlias, payeurCompte, montantAchat, montantRetrait, debitDiffere, remise, motif, refDocType, instructionId, page, size, sort, fields, }: {
+        payeAlias?: string;
+        payeCompte?: string;
+        dateEnvoi?: string;
+        dateLimitePaiement?: string;
+        statut?: 'INITIE' | 'ENVOYE' | 'IRREVOCABLE' | 'REJETE';
+        categorie?: '631' | '500' | '521' | '401';
+        payeurAlias?: string;
+        payeurCompte?: string;
+        montantAchat?: number;
+        montantRetrait?: number;
+        debitDiffere?: boolean;
+        remise?: boolean;
+        motif?: string;
+        refDocType?: string;
+        instructionId?: string;
+        page?: string;
+        size?: number;
+        sort?: string;
+        fields?: any;
+    }): CancelablePromise<DemandePaiementListe>;
+    /**
+     * Consulter une demande
+     * Cet point de terminaison permet de consulter les details d'une demande de paiement.
+     *
+     * @returns DemandePaiementConsultationReponse Opération effectuée avec succès
+     * @throws ApiError
+     */
+    static demandePaiementRecuperer({ txId, }: {
+        /**
+         * L'identifiant de la transaction dans le SI du client business
+         */
+        txId: string;
+    }): CancelablePromise<DemandePaiementConsultationReponse>;
+    /**
+     * Confirmer la demande
+     * Ce point de terminaison permet d'envoyer la confirmation de l'envoi d'une demande de paiement.
+     *
+     * Le client business confirme oui ou non si le PSP peut envoyer la demande au payeur après vérification des informations d'identification (nom et pays du payeur).
+     *
+     * **Idempotence** : Cet endpoint est idempotent.
+     * - Premier appel avec `decision: true` → Envoie la demande, retourne `200 OK {statut: "ENVOYE"}`
+     * - Appels suivants avec `decision: true` → Retourne `200 OK` avec l'état actuel (ENVOYE, IRREVOCABLE, ou REJETE) - idempotent
+     * - Premier appel avec `decision: false` → Annule, retourne `200 OK {statut: "ANNULE"}`
+     * - Appels suivants avec `decision: false` → Retourne `200 OK {statut: "ANNULE"}` (idempotent)
+     * - `decision: true` après `decision: false` → Retourne `403 Forbidden` (déjà annulé)
+     * - `decision: false` après `decision: true` → Retourne `403 Forbidden` (déjà confirmé)
+     *
+     * **Timeout** : La confirmation doit être envoyée dans les **24 heures** suivant la création de la demande. Passé ce délai, la demande expire automatiquement et ne peut plus être confirmée.
+     *
+     * **Changement de décision** : Une fois une décision prise, elle est définitive. Impossible de confirmer après avoir annulé, et vice-versa.
+     *
+     * @returns DemandePaiementConfirmationReponse Opération effectuée avec succès
+     * @throws ApiError
+     */
+    static demandePaiementConfirmer({ txId, requestBody, }: {
+        /**
+         * L'identifiant de la transaction dans le SI du payé
+         */
+        txId: string;
+        /**
+         * Le client envoie oui ou non s'il confirme l'envoi de la demande
+         */
+        requestBody: DemandePaiementConfirmationRequest;
+    }): CancelablePromise<DemandePaiementConfirmationReponse>;
+    /**
+     * Accepter ou rejeter la demande
+     * Ce point de terminaison permet au client d'accepter ou de rejeter une demande de paiement reçue.
+     * @returns any Opération effectuée avec succès
+     * @throws ApiError
+     */
+    static demandePaiementRepondre({ txId, requestBody, }: {
+        /**
+         * L'identifiant de la transaction dans le SI du client
+         */
+        txId: string;
+        /**
+         * Réponse à la demande de paiement.
+         */
+        requestBody: DemandePaiementReponseRequest;
+    }): CancelablePromise<any>;
+}
+
+declare class DemandesDePaiementEnMasseService {
+    /**
+     * Envoyer une demande de paiement en masse
+     * Ce point de terminaison permet au client business d'envoyer plusieurs demandes de paiement à la fois.
+     *
+     * La catégorie des demandes de paiement en masse est toujours `401` (Autres demandes de paiement de facture).
+     *
+     * **Traitement asynchrone :** La création retourne immédiatement `202 Accepted`. Le traitement des transactions se fait de manière asynchrone.
+     *
+     * **Sans confirmation (`confirmation: false` ou non spécifié) :**
+     * - Les transactions sont créées et validées (unicité des txId)
+     * - Les demandes de paiement sont envoyées directement aux payeurs
+     * - Les transactions avec txId dupliqué sont automatiquement rejetées avec le code `DU03`
+     * - Les transactions avec alias de payeur invalide sont automatiquement rejetées avec le code `BE23`
+     *
+     * **Avec confirmation (`confirmation: true`) :**
+     * - Les transactions sont créées et validées (unicité des txId + recherche d'alias des payeurs)
+     * - Les transactions avec alias de payeur invalide sont rejetées avec le code `BE23`
+     * - Les transactions avec txId dupliqué sont rejetées avec le code `DU03`
+     * - Les transactions valides passent à l'état `INITIE` avec les noms et pays des payeurs
+     * - Le business dispose d'un **délai adaptatif** pour confirmer ou annuler via `PUT /demandes-paiements-groupes/{instructionId}/confirmations` :
+     * - **1 à 500 transactions** : 24 heures
+     * - **501 à 1000 transactions** : 48 heures
+     * - **Plus de 1000 transactions** : 72 heures
+     * - Lors de la confirmation, seules les transactions `INITIE` sont envoyées (les transactions `REJETE` sont automatiquement exclues)
+     * - Passé le délai, la demande expire automatiquement
+     *
+     * **Consultation des détails :**
+     * - Statut global du bulk : `GET /demandes-paiements-groupes/{instructionId}`
+     * - Liste de toutes les transactions : `GET /demandes-paiements?instructionId={instructionId}`
+     * - Seulement les rejetées (validation) : `GET /demandes-paiements?instructionId={instructionId}&statut=REJETE`
+     * - Seulement les valides (avec noms/pays des payeurs) : `GET /demandes-paiements?instructionId={instructionId}&statut=INITIE`
+     *
+     * **Convention de nommage des instructionId (important) :**
+     *
+     * L'`instructionId` doit être **unique** pour chaque création de bulk. Pour faciliter le suivi métier, nous recommandons la convention suivante :
+     *
+     * ```
+     * <IDENTIFIANT_METIER>-<NUMERO_TENTATIVE>
+     * ```
+     *
+     * **Exemples :**
+     * - Première tentative : `FACTURES-2025-01-1` (factures de janvier 2025, tentative 1)
+     * - Deuxième tentative : `FACTURES-2025-01-2` (corrections après échecs)
+     * - Troisième tentative : `FACTURES-2025-01-3` (nouvelles corrections)
+     *
+     * **Avantages :**
+     * - ✅ Chaque bulk a un statut indépendant (INITIE, CONFIRME, ANNULE)
+     * - ✅ Traçabilité claire des tentatives successives
+     * - ✅ Possibilité de filtrer par identifiant métier : `GET /demandes-paiements?instructionId[beginsWith]=FACTURES-2025-01`
+     * - ✅ Respect de l'unicité de l'instructionId
+     *
+     * @returns string La demande a été acceptée et est en cours de traitement.
+     *
+     * Consultez le statut via `GET /demandes-paiements-groupes/{instructionId}`.
+     *
+     * @throws ApiError
+     */
+    static demandePaiementGroupeCreer({ requestBody, }: {
+        requestBody: DemandePaiementEnMasseRequest;
+    }): CancelablePromise<string>;
+    /**
+     * Détails d'une demande de paiement en masse
+     * Ce point de terminaison permet de consulter les détails d'une demande de paiement en masse.
+     *
+     * **Statut du bulk :**
+     * - `INITIE` : Créée avec confirmation demandée, en attente de confirmation
+     * - `CONFIRME` : Confirmée par le business (si confirmation demandée) ou en cours de traitement (si sans confirmation)
+     * - `ANNULE` : Annulée par le business avant confirmation (seulement si confirmation demandée)
+     *
+     * **Note :**
+     * - Si créée **avec confirmation** (`confirmation: true`) : Le statut évolue de `INITIE` → `CONFIRME` ou `ANNULE`
+     * - Si créée **sans confirmation** (`confirmation: false`) : Le statut est directement `CONFIRME` (aucune action requise du business)
+     *
+     * **Vérification de fin de validation (important pour confirmation) :**
+     *
+     * Lorsque `confirmation: true`, la validation des transactions se fait de manière asynchrone.
+     * Pour savoir si la validation est terminée et que vous pouvez confirmer, vérifiez que :
+     *
+     * ```
+     * transactionsInitiees + transactionsRejetees = transactionsTotal
+     * ```
+     *
+     * - Si égalité → Validation terminée, vous pouvez confirmer ✅
+     * - Si inégalité → Validation en cours, attendez encore (consultez à nouveau plus tard) ⏳
+     *
+     * Le détail de chaque transaction se consulte via `GET /demandes-paiements?txId={txId}`.
+     *
+     * **Consultation des transactions individuelles :**
+     * Pour obtenir la liste détaillée des transactions (avec noms des payeurs, codes d'erreur, etc.), utilisez :
+     * - Toutes les transactions : `GET /demandes-paiements?instructionId={instructionId}`
+     * - Seulement les rejetées : `GET /demandes-paiements?instructionId={instructionId}&statut=REJETE`
+     * - Seulement les réussies : `GET /demandes-paiements?instructionId={instructionId}&statut=IRREVOCABLE`
+     *
+     * @returns DemandePaiementEnMasseStatutReponse Opération effectuée avec succès
+     * @throws ApiError
+     */
+    static demandePaiementGroupeConsulter({ instructionId, }: {
+        /**
+         * L'identifiant de la demande de paiement en masse dans le SI du client
+         */
+        instructionId: string;
+    }): CancelablePromise<DemandePaiementEnMasseStatutReponse>;
+    /**
+     * Confirmer la demande de paiement en masse
+     * Ce point de terminaison permet de confirmer ou d'annuler une demande de paiement en masse créée avec `confirmation: true`.
+     *
+     * **Processus de vérification :**
+     * 1. Après la création (`POST /demandes-paiements-groupes`), le participant valide toutes les transactions (unicité des txId + recherche d'alias des payeurs)
+     * 2. Les transactions invalides sont automatiquement rejetées (`statut: REJETE`) avec codes `BE23` (alias invalide) ou `DU03` (txId dupliqué)
+     * 3. Les transactions valides passent à l'état `INITIE` avec les noms et pays des payeurs
+     * 4. Le business consulte via `GET /demandes-paiements-groupes/{instructionId}` pour vérifier la progression de la validation
+     * 5. **La validation (unicité des txId + recherche d'alias) est terminée quand** : `transactionsInitiees + transactionsRejetees = transactionsTotal`
+     * 6. Le business peut alors confirmer ou annuler l'envoi des demandes de paiement
+     *
+     * **Important :** La confirmation n'est possible que lorsque la validation de toutes les transactions est terminée.
+     * Si le business tente de confirmer pendant que la validation est en cours, une erreur 403 sera retournée avec la progression actuelle.
+     *
+     * **Comportement de la confirmation :**
+     * - `decision: true` → Le système envoie **automatiquement SEULEMENT** les demandes de paiement pour les transactions avec `statut: INITIE`
+     * - Les transactions `REJETE` (erreurs de validation) sont **automatiquement exclues** (pas besoin de les lister)
+     * - Le statut du bulk passe de `INITIE` à `CONFIRME`
+     *
+     * **Idempotence** : Cet endpoint est idempotent.
+     * - Premier appel avec `decision: true` → Envoie les demandes, retourne `200 OK {statut: "CONFIRME"}`
+     * - Appels suivants avec `decision: true` → Retourne `200 OK {statut: "CONFIRME"}` (idempotent, ne relance pas)
+     * - Premier appel avec `decision: false` → Annule, retourne `200 OK {statut: "ANNULE"}`
+     * - Appels suivants avec `decision: false` → Retourne `200 OK {statut: "ANNULE"}` (idempotent)
+     * - `decision: true` après `decision: false` → Retourne `403 Forbidden` (déjà annulé)
+     * - `decision: false` après `decision: true` → Retourne `403 Forbidden` (déjà confirmé)
+     *
+     * **Timeout adaptatif** : Le délai pour confirmer dépend automatiquement du nombre de transactions :
+     * - **1 à 500 transactions** : 24 heures
+     * - **501 à 1000 transactions** : 48 heures
+     * - **Plus de 1000 transactions** : 72 heures
+     *
+     * Passé ce délai, la demande expire automatiquement et ne peut plus être confirmée. Le délai exact est indiqué dans le champ `dateExpiration` retourné par `GET /demandes-paiements-groupes/{instructionId}`.
+     *
+     * **Changement de décision** : Une fois une décision prise, elle est définitive. Impossible de confirmer après avoir annulé, et vice-versa.
+     *
+     * @returns DemandePaiementEnMasseStatutReponse Confirmation enregistrée avec succès.
+     * - Si `decision: true`, le statut passe à `CONFIRME` et les demandes de paiement sont envoyées
+     * - Si `decision: false`, le statut passe à `ANNULE`
+     *
+     * @throws ApiError
+     */
+    static demandePaiementGroupeConfirmer({ instructionId, requestBody, }: {
+        /**
+         * L'identifiant de la demande de paiement en masse dans le SI du client
+         */
+        instructionId: string;
+        /**
+         * Le client envoie oui ou non s'il confirme l'envoi de la demande de paiement en masse.
+         */
+        requestBody: DemandePaiementEnMasseConfirmationRequest;
+    }): CancelablePromise<DemandePaiementEnMasseStatutReponse>;
+}
+
+declare class NotificationService {
+    /**
+     * Créer un lien de rappel.
+     * Cet endpoint permet au client de configurer des webhooks (liens de rappel) pour recevoir des notifications en temps réel.
+     *
+     * Le client dispose d'une grande flexibilité dans la configuration de ses webhooks et peut choisir parmi plusieurs stratégies :
+     *
+     * **1. Callback URL général**
+     * - Un seul point de rappel pour toutes les notifications
+     * - Tous les événements de tous les comptes/alias sont envoyés à la même URL
+     * - Configuration simple, idéale pour centraliser toutes les notifications
+     *
+     * **2. Callback URL par alias**
+     * - Un point de rappel distinct pour chaque alias de compte
+     * - Permet de router les notifications vers des systèmes différents selon le compte concerné
+     * - Utile pour isoler les flux de notifications par compte ou par service
+     *
+     * **3. Callback URL par événement**
+     * - Un point de rappel spécifique pour chaque type d'événement (PAIEMENT_RECU, RTP_RECU, etc.)
+     * - Permet de traiter différemment chaque catégorie d'événement
+     * - Facilite la séparation des traitements métier (paiements vs demandes vs retours)
+     *
+     * **4. Callback URL par événement et alias**
+     * - Granularité maximale : un point de rappel pour chaque combinaison événement/alias
+     * - Configuration la plus fine pour des besoins très spécifiques
+     * - Permet de router précisément chaque notification vers le système approprié
+     *
+     * Cette flexibilité permet aux clients d'adapter la configuration des webhooks à leur architecture technique et à leurs besoins métier.
+     *
+     * @returns WebhookCreationResponse Webhook créé avec succès
+     * @throws ApiError
+     */
+    static webhookCreer({ requestBody, }: {
+        requestBody: WebhookCreationRequest;
+    }): CancelablePromise<WebhookCreationResponse>;
+    /**
+     * Lister les webhooks
+     * Endpoint pour lister les webhooks
+     *
+     * @returns WebhookList Liste des webhooks configurés
+     * @throws ApiError
+     */
+    static webhookLister(): CancelablePromise<WebhookList>;
+    /**
+     * Modifier un Webhook
+     * Endpoint pour la modification d'un webhook.
+     *
+     * @returns any Le Webhook a été modifié avec succès
+     * @throws ApiError
+     */
+    static webhookModifier({ id, requestBody, }: {
+        id: string;
+        requestBody: WebhookModificationRequest;
+    }): CancelablePromise<any>;
+    /**
+     * Supprimer un Webhook
+     * Endpoint pour la suppression d'un webhook.
+     *
+     * @returns void
+     * @throws ApiError
+     */
+    static webhookSupprimer({ id, }: {
+        id: string;
+    }): CancelablePromise<void>;
+    /**
+     * Recuperer un webhook
+     * Endpoint pour la consultation des informations d'un Webhook
+     * @returns WebhookData Details du webhook
+     * @throws ApiError
+     */
+    static webhookConsulter({ id, }: {
+        id: string;
+    }): CancelablePromise<WebhookData>;
+}
+
+declare class PaiementEnMasseService {
+    /**
+     * Envoyer un paiement en masse
+     * Ce point de terminaison permet au client d'envoyer des paiements en masse.
+     *
+     * **Traitement asynchrone :** La création d'un paiement en masse retourne immédiatement `202 Accepted`. Le traitement des transactions se fait de manière asynchrone.
+     *
+     * **Sans confirmation (`confirmation: false` ou non spécifié) :**
+     * - Les transactions sont créées et validées (unicité des txId)
+     * - Les paiements sont exécutés directement
+     * - Les transactions invalides (txId dupliqué) sont automatiquement rejetées avec le code `DU03`
+     * - Le business peut suivre la progression via `GET /paiements-groupes/{instructionId}` et `GET /paiements?instructionId={instructionId}`
+     *
+     * **Avec confirmation (`confirmation: true`) :**
+     * - Les transactions sont créées et validées (unicité des txId + recherche d'alias)
+     * - Les transactions avec alias invalide sont automatiquement rejetées avec le code `BE23`
+     * - Les transactions avec txId dupliqué sont rejetées avec le code `DU03`
+     * - Les transactions valides passent à l'état `INITIE` et peuvent être consultées via `GET /paiements?instructionId={instructionId}&statut=INITIE`
+     * - Le business dispose d'un **délai adaptatif** pour confirmer ou annuler via `PUT /paiements-groupes/{instructionId}/confirmations` :
+     * - **1 à 500 transactions** : 24 heures
+     * - **501 à 1000 transactions** : 48 heures
+     * - **Plus de 1000 transactions** : 72 heures
+     * - Lors de la confirmation, seules les transactions `INITIE` sont envoyées (les transactions `REJETE` sont automatiquement exclues)
+     * - Passé le délai, la demande expire automatiquement
+     *
+     * **Consultation des détails :**
+     * - Statut global du bulk : `GET /paiements-groupes/{instructionId}`
+     * - Liste de toutes les transactions : `GET /paiements?instructionId={instructionId}`
+     * - Seulement les rejetées (validation) : `GET /paiements?instructionId={instructionId}&statut=REJETE`
+     * - Seulement les valides (avec noms/pays) : `GET /paiements?instructionId={instructionId}&statut=INITIE`
+     *
+     * **Convention de nommage des instructionId (important) :**
+     *
+     * L'`instructionId` doit être **unique** pour chaque création de bulk. Pour faciliter le suivi métier, nous recommandons la convention suivante :
+     *
+     * ```
+     * <IDENTIFIANT_METIER>-<NUMERO_TENTATIVE>
+     * ```
+     *
+     * **Exemples :**
+     * - Première tentative : `SALAIRES-2025-01-1` (salaires de janvier 2025, tentative 1)
+     * - Deuxième tentative : `SALAIRES-2025-01-2` (corrections après échecs)
+     * - Troisième tentative : `SALAIRES-2025-01-3` (nouvelles corrections)
+     *
+     * **Avantages :**
+     * - ✅ Chaque bulk a un statut indépendant (INITIE, CONFIRME, ANNULE)
+     * - ✅ Traçabilité claire des tentatives successives
+     * - ✅ Possibilité de filtrer par identifiant métier : `GET /paiements?instructionId[beginsWith]=SALAIRES-2025-01`
+     * - ✅ Respect de l'unicité de l'instructionId
+     *
+     * @returns string La demande a été acceptée et est en cours de traitement.
+     *
+     * Consultez le statut via `GET /paiements-groupes/{instructionId}`.
+     *
+     * @throws ApiError
+     */
+    static paiementGroupeCreer({ requestBody, }: {
+        requestBody: PaiementEnMasseRequest;
+    }): CancelablePromise<string>;
+    /**
+     * Détails d'un paiement en masse
+     * Ce point de terminaison permet de consulter les détails d'un paiement en masse.
+     *
+     * **Statut du bulk :**
+     * - `INITIE` : Créé avec confirmation demandée, en attente de confirmation
+     * - `CONFIRME` : Confirmé par le business (si confirmation demandée) ou en cours de traitement (si sans confirmation)
+     * - `ANNULE` : Annulé par le business avant confirmation (seulement si confirmation demandée)
+     *
+     * **Note :**
+     * - Si créé **avec confirmation** (`confirmation: true`) : Le statut évolue de `INITIE` → `CONFIRME` ou `ANNULE`
+     * - Si créé **sans confirmation** (`confirmation: false`) : Le statut est directement `CONFIRME` (aucune action requise du business)
+     *
+     * **Vérification de fin de validation (important pour confirmation) :**
+     *
+     * Lorsque `confirmation: true`, la validation des transactions se fait de manière asynchrone.
+     * Pour savoir si la validation est terminée et si vous pouvez confirmer, vérifiez que :
+     *
+     * ```
+     * transactionsInitiees + transactionsRejetees = transactionsTotal
+     * ```
+     *
+     * - Si égalité → Validation terminée, vous pouvez confirmer ✅
+     * - Si inégalité → Validation en cours, attendez encore (consultez à nouveau dans quelques secondes) ⏳
+     *
+     * La progression détaillée de chaque transaction se consulte via `GET /paiements?txId={txId}`.
+     *
+     * **Consultation des transactions individuelles :**
+     * Pour obtenir la liste détaillée des transactions (avec noms des bénéficiaires, codes d'erreur, etc.), utilisez :
+     * - Toutes les transactions : `GET /paiements?instructionId={instructionId}`
+     * - Seulement les rejetées : `GET /paiements?instructionId={instructionId}&statut=REJETE`
+     * - Seulement les réussies : `GET /paiements?instructionId={instructionId}&statut=IRREVOCABLE`
+     *
+     * @returns PaiementEnMasseReponseStatut Opération effectuée avec succès
+     * @throws ApiError
+     */
+    static paiementGroupeConsulter({ instructionId, }: {
+        /**
+         * L'identifiant du paiement en masse dans le SI du client
+         */
+        instructionId: string;
+    }): CancelablePromise<PaiementEnMasseReponseStatut>;
+    /**
+     * Confirmer le paiement en masse
+     * Ce point de terminaison permet de confirmer ou d'annuler un paiement en masse créé avec `confirmation: true`.
+     *
+     * **Processus de vérification :**
+     * 1. Après la création (`POST /paiements-groupes`), le participant valide asynchronement toutes les transactions (unicité des txId + recherche d'alias)
+     * 2. Les transactions invalides sont automatiquement rejetées (`statut: REJETE`) avec codes `BE23` (alias invalide) ou `DU03` (txId dupliqué)
+     * 3. Les transactions valides passent à l'état `INITIE` avec les noms et pays des bénéficiaires
+     * 4. Le business consulte via `GET /paiements-groupes/{instructionId}` pour vérifier la progression de la validation
+     * 5. **La validation est terminée quand** : `transactionsInitiees + transactionsRejetees = transactionsTotal`
+     * 6. Le business peut alors confirmer ou annuler
+     *
+     * **Important :** La confirmation n'est possible que lorsque la validation de toutes les transactions est terminée.
+     * Si le business tente de confirmer pendant que la validation est en cours, une erreur 403 sera retournée avec la progression actuelle.
+     *
+     * **Comportement de la confirmation :**
+     * - `decision: true` → Le système envoie **automatiquement SEULEMENT** les transactions avec `statut: INITIE`
+     * - Les transactions `REJETE` (erreurs de validation) sont **automatiquement exclues** (pas besoin de les lister)
+     * - Le statut du bulk passe de `INITIE` à `CONFIRME`
+     *
+     * **Idempotence** : Cet endpoint est idempotent.
+     * - Premier appel avec `decision: true` → Lance les paiements, retourne `200 OK {statut: "CONFIRME"}`
+     * - Appels suivants avec `decision: true` → Retourne `200 OK {statut: "CONFIRME"}` (idempotent, ne relance pas)
+     * - Premier appel avec `decision: false` → Annule, retourne `200 OK {statut: "ANNULE"}`
+     * - Appels suivants avec `decision: false` → Retourne `200 OK {statut: "ANNULE"}` (idempotent)
+     * - `decision: true` après `decision: false` → Retourne `403 Forbidden` (déjà annulé)
+     * - `decision: false` après `decision: true` → Retourne `403 Forbidden` (déjà confirmé)
+     *
+     * **Timeout adaptatif** : Le délai pour confirmer dépend automatiquement du nombre de transactions :
+     * - **1 à 500 transactions** : 24 heures
+     * - **501 à 1000 transactions** : 48 heures
+     * - **Plus de 1000 transactions** : 72 heures
+     *
+     * Passé ce délai, la demande expire automatiquement et ne peut plus être confirmée. Le délai exact est indiqué dans le champ `dateExpiration` retourné par `GET /paiements-groupes/{instructionId}`.
+     *
+     * **Changement de décision** : Une fois une décision prise, elle est définitive. Impossible de confirmer après avoir annulé, et vice-versa.
+     *
+     * @returns PaiementEnMasseReponseStatut Confirmation enregistrée avec succès.
+     * - Si `decision: true`, le statut passe à `CONFIRME` et les paiements sont lancés
+     * - Si `decision: false`, le statut passe à `ANNULE`
+     *
+     * @throws ApiError
+     */
+    static paiementGroupeConfirmer({ instructionId, requestBody, }: {
+        /**
+         * L'identifiant du paiement en masse dans le SI du client
+         */
+        instructionId: string;
+        /**
+         * Le client envoie oui ou non s'il confirme l'envoi du paiement en masse.
+         */
+        requestBody: PaiementEnMasseConfirmationRequest;
+    }): CancelablePromise<PaiementEnMasseReponseStatut>;
+}
+
+declare class PaiementImmediatService {
+    /**
+     * Envoyer un paiement
+     * Ce point de terminaison permet au business d'effectuer des paiements.
+     *
+     * Le destinataire du paiement est identifié par son alias de compte.
+     *
+     * Le business peut définir le champ `confirmation` à `true` pour demander une validation en deux étapes : le PSP retournera d'abord le résultat de la recherche d'alias (avec le nom et le pays du bénéficiaire), puis attendra une confirmation explicite avant d'exécuter le paiement via l'endpoint `PUT /paiements/{txId}/confirmations`.
+     *
+     * **Timeout de confirmation** : Si le business demande une confirmation, il dispose de **24 heures** pour confirmer. Passé ce délai, la demande expire automatiquement.
+     *
+     * @returns PaiementImmediatReponse Paiement traité. Le champ `statut` indique le résultat :
+     * - `INITIE` : En attente de confirmation (si `confirmation: true`)
+     * - `ENVOYE` : Paiement envoyé avec succès (si `confirmation: false`)
+     * - `REJETE` : Paiement rejeté. Le champ `statutRaison` contient le code d'erreur :
+     * - `DU03` : txId dupliqué (déjà utilisé)
+     * - `BE23` : Alias bénéficiaire invalide
+     * - Autres codes ISO 20022
+     *
+     * @throws ApiError
+     */
+    static paiementCreer({ requestBody, }: {
+        /**
+         * Pour effectuer le transfert, le client doit fournir l'alias du destinataire ainsi que le montant du transfert à effectuer.
+         */
+        requestBody: PaiementImmediatRequest;
+    }): CancelablePromise<PaiementImmediatReponse>;
+    /**
+     * Lister les paiements
+     * Ce point de terminaison permet de lister les paiements effectués par le client.
+     * @returns PaiementListe Succès de l'opération
+     * @throws ApiError
+     */
+    static paiementLister({ payeAlias, payeCompte, payeurAlias, payeurCompte, dateEnvoi, dateIrrevocabilite, statut, categorie, montantAchat, montantRetrait, motif, refDocType, instructionId, txId, annulationStatut, annulationMotif, retourStatut, page, size, sort, fields, }: {
+        payeAlias?: string;
+        payeCompte?: string;
+        payeurAlias?: string;
+        payeurCompte?: string;
+        dateEnvoi?: string;
+        dateIrrevocabilite?: string;
+        statut?: 'INITIE' | 'ENVOYE' | 'IRREVOCABLE' | 'REJETE';
+        categorie?: '631' | '000' | '400' | '733' | '300' | '999' | '500' | '521' | '401';
+        montantAchat?: number;
+        montantRetrait?: number;
+        motif?: string;
+        refDocType?: string;
+        instructionId?: string;
+        txId?: string;
+        annulationStatut?: string;
+        annulationMotif?: string;
+        retourStatut?: string;
+        page?: string;
+        size?: string;
+        sort?: string;
+        fields?: any;
+    }): CancelablePromise<PaiementListe>;
+    /**
+     * Détails d'un paiement
+     * Cet point de terminaison permet de consulter les details d'un paiement.
+     *
+     * @returns Paiement Opération effectuée avec succès
+     * @throws ApiError
+     */
+    static paiementRecuperer({ txId, }: {
+        /**
+         * L'identifiant de la transaction dans le SI du client
+         */
+        txId: string;
+    }): CancelablePromise<Paiement>;
+    /**
+     * Confirmer le paiement
+     * Ce point de terminaison permet d'envoyer la confirmation de l'envoi d'un paiement immédiat
+     * après vérification du nom et du pays du bénéficiaire.
+     *
+     * **Idempotence** : Cet endpoint est idempotent.
+     * - Premier appel avec `decision: true` → Lance le paiement, retourne `200 OK {statut: "ENVOYE"}`
+     * - Appels suivants avec `decision: true` → Retourne `200 OK` avec l'état actuel (ENVOYE, IRREVOCABLE, ou REJETE) - idempotent
+     * - Premier appel avec `decision: false` → Annule, retourne `200 OK {statut: "ANNULE"}`
+     * - Appels suivants avec `decision: false` → Retourne `200 OK {statut: "ANNULE"}` (idempotent)
+     * - `decision: true` après `decision: false` → Retourne `403 Forbidden` (déjà annulé)
+     * - `decision: false` après `decision: true` → Retourne `403 Forbidden` (déjà confirmé)
+     *
+     * **Timeout** : La confirmation doit être envoyée dans les **24 heures** suivant la création de la demande. Passé ce délai, la demande expire automatiquement et ne peut plus être confirmée.
+     *
+     * **Changement de décision** : Une fois une décision prise, elle est définitive. Impossible de confirmer après avoir annulé, et vice-versa.
+     *
+     * @returns PaiementImmediatConfirmationReponse Paiement en cours d'envoi
+     * @throws ApiError
+     */
+    static paiementConfirmer({ txId, requestBody, }: {
+        /**
+         * L'identifiant de la transaction dans le SI du payé
+         */
+        txId: string;
+        /**
+         * Le client envoie oui ou non s'il confirme l'envoi du paiement.
+         */
+        requestBody: PaiementImmediatConfirmationRequest;
+    }): CancelablePromise<PaiementImmediatConfirmationReponse>;
+    /**
+     * Vérifier un paiement
+     * Ce point de terminaison permet de vérifier la réception d’un paiement à partir de l’`end2endId`.
+     *
+     * Dans certains cas, le **client business** peut ne pas avoir reçu la notification de paiement.
+     * Le **client payeur** peut alors lui communiquer l’`end2endId` afin qu’il puisse vérifier manuellement le statut du paiement.
+     *
+     * Le **participant** doit, dans ce cas, vérifier dans sa base de données et s'il ne trouve pas le paiement, il doit interroger l’endpoint de PI-SPI permettant de **récupérer le statut d’un paiement**,  puis **retourner ce statut** dans sa réponse.
+     *
+     * Le statut retourné doit être soit :
+     * - `IRREVOCABLE` (paiement irrévocable), ou
+     * - `REJETE` (paiement rejeté).
+     *
+     * Un transfert **ne peut pas** être signalé comme « en cours de traitement » dans ce contexte.
+     *
+     * ⚠️ **Remarques :**
+     * - La vérification ne doit concerner que les paiements réalisés depuis **moins de 3 mois (90 jours)** afin de garantir la disponibilité de la réponse.
+     * - La garantie de réponse n’est assurée qu’à partir de **20 secondes après l’envoi du transfert**.
+     *
+     * @returns Paiement Opération effectuée avec succès
+     * @throws ApiError
+     */
+    static paiementVerifier({ end2EndId, }: {
+        /**
+         * L'identifiant de bout en bout de la transaction
+         */
+        end2EndId: string;
+    }): CancelablePromise<Paiement>;
+}
+
+declare class RetoursdeFondsService {
+    /**
+     * Retourner les fonds
+     * Ce point de terminaison permet au business de retourner les fonds d'un paiement reçu.
+     *
+     * **Idempotence** : Cet endpoint est idempotent. Plusieurs appels avec le même `end2endId` produiront le même résultat.
+     * Si le retour de fonds a déjà été envoyé et irrévocable, le champ `retourStatut` de la réponse sera `IRREVOCABLE`.
+     * Si le retour de fonds a été envoyé et rejeté, le retour de fonds sera envoyé à nouveau.
+     * Si le retour de fonds est en cours d'envoi, le champ `retourStatut` de la réponse sera `INITIE`.
+     *
+     * **Notifications webhook** : Après envoi du retour de fonds, si le business a souscrit au service de webhook, il recevra :
+     * - Une notification `RETOUR_ENVOYE` en cas de succès du retour de fonds
+     * - Une notification `RETOUR_REJETE` en cas de rejet de la demande
+     *
+     * **Vérification du statut** : Pour obtenir le statut d'un retour de fonds envoyé, vous pouvez invoquer l'endpoint `GET /paiements/{end2endId}` et le champ `retourStatut` de la réponse indiquera l'état du retour de fonds.
+     *
+     * @returns Paiement Retour de fonds enregistré avec succès
+     * @throws ApiError
+     */
+    static retourFondsEnvoyer({ end2EndId, }: {
+        /**
+         * L'identifiant unique de bout en bout de la transaction
+         */
+        end2EndId: string;
+    }): CancelablePromise<Paiement>;
+}
+
+export { ACCOUNT_STATUS, ACCOUNT_TYPE, ALIAS_TYPES, type AdditionalDataOverrides, type AliasCreationReponse, type AliasCreationRequest, type AliasReponseListe, AliasService, AliasType, AliasType as AliasTypeType, AnnulationStatut, ApiError, CLIENT_TYPE, CURRENCY, CancelError, CancelablePromise, type Champs, CompteOperation, type CompteOperationListe, CompteSolde, CompteTransfertIntraReponse, type CompteTransfertIntraRequest, ComptesService, DEFAULT_LIMITS, DEFAULT_PISPI_LOGO_DATA_URL, DemandeAnnulationService, DemandePaiementConfirmationAnnulationRaison, DemandePaiementConfirmationReponse, type DemandePaiementConfirmationRequest, type DemandePaiementConfirmationRequestAccepter, type DemandePaiementConfirmationRequestRejeter, DemandePaiementConsultationReponse, type DemandePaiementEnMasseConfirmationRequest, type DemandePaiementEnMasseConfirmationRequestAccepter, type DemandePaiementEnMasseConfirmationRequestRejeter, type DemandePaiementEnMasseRequest, DemandePaiementEnMasseStatutReponse, type DemandePaiementListe, DemandePaiementListeItem, type DemandePaiementReponse, DemandePaiementReponseRequest, DemandePaiementRequest, type DemandePaiementRequestBase, DemandePaiementRequestCategorie, DemandePaiementStatut, DemandePaiementStatutRaison, DemandesDePaiementEnMasseService, DemandesDePaiementService, type FilterOperator, type ListeMeta, type LomiCustomerAliasType, type LomiCustomerQr, NotificationService, OpenAPI, type OpenAPIConfig, PAYMENT_STATUS, PISPI_AMBER_LOGO_DATA_URL, PISPI_QRCODE_LOGO_DATA_URL, PI_SPI_ENDPOINTS, Paiement, PaiementAnnulationMotif, type PaiementAnnulationReponseRequest, type PaiementAnnulationReponseRequestAccepter, type PaiementAnnulationReponseRequestRejeter, type PaiementAnnulationRequest, PaiementAnnulationStatutRaison, type PaiementEnMasseConfirmationRequest, type PaiementEnMasseConfirmationRequestAccepter, type PaiementEnMasseConfirmationRequestRejeter, PaiementEnMasseReponseStatut, type PaiementEnMasseRequest, PaiementEnMasseService, PaiementImmediatConfirmationReponse, type PaiementImmediatConfirmationRequest, type PaiementImmediatConfirmationRequestAccepter, type PaiementImmediatConfirmationRequestRejeter, PaiementImmediatReponse, type PaiementImmediatRequest, PaiementImmediatService, type PaiementListe, type PaiementRequest, PaiementStatut, PaiementStatutRaison, PiSpiAuthError, type PiSpiConfig, PiSpiError, PiSpiNotFoundError, PiSpiRateLimitError, PiSpiSDK, PiSpiValidationError, type Problem7807, QRCode, type QrCodeSvgOptions, type QrPayloadInput, type QrPayloadOptions, type QrPayloadResult, type QrType, type QrValidationResult, QueryBuilder, type QueryParams, RefDocType, RetourStatut, RetourStatutRaison, RetoursdeFondsService, UEMOA_COUNTRIES, WEBHOOK_EVENTS, type WebhookCreationRequest, type WebhookCreationResponse, type WebhookData, WebhookEvent, type WebhookEventsList, type WebhookList, type WebhookModificationRequest, WebhooksEvents, buildLomiCustomerQr, buildPayloadString, centimesToXof, computeCrc16, createQrPayload, formatAmount, generateQrCodeSvg, getAvailableAliasTypes, getCountryFromAccount, handleApiError, isValidAccountNumber, isValidAliasType, isValidPhoneNumber, isValidPispiQrPayload, isValidShidAlias, parseLomiCustomerQr, retryWithBackoff, serializeLomiCustomerQr, sleep, xofToCentimes };