SYSCOHADA-BANKS v2.1

Base de données complète des banques, systèmes de règlement, devises et Incoterms de la zone OHADA (UEMOA + CEMAC)

Nouveautés v2.1.0

Extension majeure : Commerce international complet pour la zone OHADA !

Nouvelles fonctionnalités

• Gestion des devises : 25 devises avec taux de change et conversions
• Incoterms 2020 : 11 règles avec recommandations OHADA
• Commerce international : Ports, corridors et recommandations Europe/Amérique/Asie
• 23 ports internationaux avec temps de transit vers l'Afrique
• 10 corridors commerciaux vers la zone OHADA
• 11 accords commerciaux (AGOA, APE, GSP, etc.)

Table des matières

• Installation
• Utilisation rapide
• API des banques
• API des systèmes de règlement
• API des devises et taux de change
• API des Incoterms
• API du commerce international
• Types TypeScript
• License

Installation

npm install syscohada-banks

Utilisation rapide

Banques et institutions

import {
  getInstitutionsByCountry,
  searchInstitutionsByName,
  getInstitutionBySwiftCode
} from 'syscohada-banks';

// Banques du Sénégal
const senegalBanks = getInstitutionsByCountry('SN');

// Rechercher par nom
const ecobanks = searchInstitutionsByName('Ecobank');

// Rechercher par code SWIFT
const bank = getInstitutionBySwiftCode('ECOCSNDAXXX');

Devises et conversions

import {
  convertCurrency,
  getExchangeRate,
  formatCurrency,
  getCurrencyByCountry
} from 'syscohada-banks';

// Convertir 1 000 000 XOF en EUR
const conversion = convertCurrency(1000000, 'XOF', 'EUR');
console.log(conversion.toAmount); // 1524.49 EUR

// Taux de change
const rate = getExchangeRate('USD', 'XOF');
console.log(rate.rate); // ~615

// Formater un montant
const formatted = formatCurrency(1500000, 'XOF');
console.log(formatted); // "1 500 000 FCFA"

// Devise d'un pays OHADA
const currency = getCurrencyByCountry('SN'); // XOF

Incoterms 2020

import {
  getAllIncoterms,
  getIncotermByCode,
  getRecommendedIncoterm,
  compareIncoterms
} from 'syscohada-banks';

// Tous les Incoterms
const incoterms = getAllIncoterms(); // 11 Incoterms

// Détails d'un Incoterm
const cif = getIncotermByCode('CIF');
console.log(cif.nameFr); // "Coût, assurance et fret"

// Recommandation pour un importateur OHADA
const recommended = getRecommendedIncoterm({
  isExporter: false,
  transportMode: 'SEA',
  wantsInsurance: true,
  isOHADA: true
});
console.log(recommended.code); // CIF

// Comparer FOB vs CIF
const comparison = compareIncoterms('FOB', 'CIF');

Commerce international

import {
  getEuropeanPorts,
  getTradeCorridorById,
  getRegionalIncotermRecommendation,
  getInternationalIncotermRecommendation
} from 'syscohada-banks';

// Ports européens
const euPorts = getEuropeanPorts();
console.log(euPorts[0].transitTimeToWestAfrica); // 12 jours

// Corridor Chine-UEMOA
const corridor = getTradeCorridorById('CHINA-UEMOA');
console.log(corridor.averageCostPerTEU); // 2800 USD

// Recommandations pour import depuis la Chine
const recom = getInternationalIncotermRecommendation({
  partnerRegion: 'ASIA_PACIFIC',
  partnerSubRegion: 'CHINA',
  isExporter: false,
  transportMode: 'SEA',
  wantsInsurance: true
});
console.log(recom.recommended); // ['FOB', 'CFR', 'CIF']
console.log(recom.risks); // Risques spécifiques Chine

API des banques

Fonctions principales

| Fonction | Description | |----------|-------------| | getAllInstitutions() | Toutes les institutions (123+) | | getInstitutionsByCountry(country) | Par pays (SN, CI, CM, etc.) | | getInstitutionsByZone(zone) | Par zone (UEMOA, CEMAC) | | getInstitutionsByGroup(group) | Par groupe (ECOBANK, BOA, UBA...) | | searchInstitutionsByName(term) | Recherche textuelle | | getInstitutionBySwiftCode(code) | Par code SWIFT | | validateSwiftCode(code) | Valider format SWIFT | | getStatsByCountry() | Statistiques par pays | | getStatsByGroup() | Statistiques par groupe |

API des systèmes de règlement

Systèmes de paiement

| Fonction | Description | |----------|-------------| | getAllPaymentSystems() | Tous les systèmes | | getPaymentSystemsByType(type) | RTGS, NETTING, INSTANT, etc. | | getPaymentSystemsByCountry(country) | Par pays | | getRTGSSystems() | STAR-UEMOA, SYGMA, SAGETIL | | getInstantPaymentSystems() | PI-SPI, GIMACPAY | | calculateEstimatedFees(systemId, amount) | Calcul des frais | | getRecommendedPaymentSystems(amount, country, urgency) | Recommandations |

Mobile Money

| Fonction | Description | |----------|-------------| | getAllMobileMoneyProviders() | Tous les opérateurs | | getMobileMoneyProvidersByCountry(country) | Par pays | | getUSSDCode(operator, country) | Code USSD (ex: *144#) | | getInteroperableMobileMoneyProviders(operator) | Interopérabilité |

Corridors transfrontaliers

| Fonction | Description | |----------|-------------| | getAllPaymentCorridors() | Tous les corridors | | getPaymentCorridor(from, to) | Entre deux pays | | getActivePaymentCorridors() | Corridors actifs |

API des devises et taux de change

25 devises supportées

Régionales : XOF (UEMOA), XAF (CEMAC) Internationales : EUR, USD, GBP, CHF, CNY, JPY, CAD, AED, SAR Africaines : NGN, GHS, ZAR, EGP, KES, MAD, TND, DZD, GNF, MRU, GMD, SLL, LRD, CVE

Fonctions de conversion

// Conversion complète avec frais
const result = convertCurrency(1000000, 'XOF', 'EUR', {
  includeFees: true,
  transactionType: 'TRANSFER'
});
// { fromAmount: 1000000, toAmount: 1524.49, rate: 0.001524, feeAmount: 6500, netAmount: 1514.09 }

// Conversion rapide
const amount = quickConvert(1000000, 'XOF', 'EUR'); // 1524.49

// Conversions directes
const xofAmount = convertToXOF(100, 'EUR'); // 65595.7
const eurAmount = convertFromXOF(1000000, 'EUR'); // 1524.49

Taux de change

| Fonction | Description | |----------|-------------| | getAllExchangeRates() | Tous les taux (~30 paires) | | getExchangeRate(from, to) | Taux direct | | getExchangeRateWithFallback(from, to) | Avec calcul indirect via pivot | | getFixedExchangeRates() | Taux fixes (CFA/EUR = 655.957) | | getExchangeRateHistory(from, to) | Historique 12 mois | | isFixedRate(from, to) | Vérifier si taux fixe |

Frais et formatage

| Fonction | Description | |----------|-------------| | calculateExchangeFee(amount, from, to, type) | Calcul des frais | | formatCurrency(amount, code) | Formatage avec symbole | | getCFAEuroFixedRate() | Taux fixe 655.957 |

API des Incoterms

11 Incoterms 2020

Catégorie E : EXW (Ex Works) Catégorie F : FCA, FAS, FOB Catégorie C : CFR, CIF, CPT, CIP Catégorie D : DAP, DPU, DDP

Fonctions principales

| Fonction | Description | |----------|-------------| | getAllIncoterms() | 11 Incoterms complets | | getIncotermByCode(code) | Détails d'un Incoterm | | getIncotermsByCategory(cat) | Par catégorie (E, F, C, D) | | getSeaOnlyIncoterms() | Maritimes (FAS, FOB, CFR, CIF) | | getAnyModeIncoterms() | Tout mode de transport | | getRecommendedIncotermsForOHADA() | 7 recommandés pour OHADA | | compareIncoterms(code1, code2) | Comparaison détaillée | | getRecommendedIncoterm(options) | Recommandation intelligente |

Fonctions OHADA spécifiques

| Fonction | Description | |----------|-------------| | getOHADARequiredDocuments(type) | Documents import/export | | getOHADAPorts(zone?) | Ports UEMOA/CEMAC | | getPortsByCountry(country) | Ports par pays | | calculateCustomsDuty(value, category) | Droits de douane TEC | | getIncotermsForLandlockedCountries() | Pour pays enclavés | | getIncotermResponsibilitySummary(code) | Résumé vendeur/acheteur |

Exemple de comparaison

const comparison = compareIncoterms('FOB', 'CIF');
// {
//   sellerDifferences: ['Transport principal: FOB=Non, CIF=Oui', 'Assurance: FOB=Non, CIF=Oui'],
//   riskDifference: 'Même point de transfert du risque',
//   costDifference: 'HIGHER', // CIF plus cher pour le vendeur
//   recommendation: 'Les deux Incoterms sont adaptés selon le contexte'
// }

API du commerce international

23 ports internationaux

Europe (7) : Rotterdam, Anvers, Hambourg, Le Havre, Marseille, Algésiras, Felixstowe Amérique (6) : New York, Houston, Los Angeles, Montréal, Santos, Buenos Aires Asie/Moyen-Orient (10) : Shanghai, Shenzhen, Singapour, Busan, Tokyo, Mumbai, Jebel Ali, etc.

Fonctions ports

| Fonction | Description | |----------|-------------| | getAllInternationalPorts() | 23 ports mondiaux | | getEuropeanPorts() | 7 ports européens | | getAmericanPorts() | 6 ports américains | | getAsianPorts() | 10 ports asiatiques | | getAfricaHubPorts() | 14 hubs pour l'Afrique | | getPortsByTransitTimeToWestAfrica() | Triés par temps de transit | | getInternationalPortByCode(code) | Par code (ex: NLRTM) | | searchInternationalPorts(term) | Recherche |

10 corridors commerciaux

| Corridor | Transit | Coût/TEU | Incoterms | |----------|---------|----------|-----------| | EU-UEMOA | 12 jours | $2,500 | CIF, CFR, FOB | | EU-CEMAC | 18 jours | $3,200 | CIF, CIP, CFR | | USA-UEMOA | 18 jours | $3,500 | CIF, CFR, FOB | | CHINA-UEMOA | 28 jours | $2,800 | FOB, CFR, CIF | | CHINA-CEMAC | 32 jours | $3,200 | FOB, CFR, CIF | | INDIA-UEMOA | 18 jours | $2,000 | CFR, CIF, FOB | | BRAZIL-UEMOA | 10 jours | $2,200 | CFR, CIF, FOB | | UAE-OHADA | 20 jours | $2,500 | CIF, CFR, FOB |

Fonctions corridors

| Fonction | Description | |----------|-------------| | getAllTradeCorridors() | 10 corridors | | getTradeCorridorById(id) | Par ID (ex: CHINA-UEMOA) | | getTradeCorridorsFromRegion(region) | Par région d'origine | | getTradeCorridorsByVolume() | Triés par volume | | estimateCorridorCost(id, TEUs) | Estimation coût | | getBestPortForCorridor(region, zone) | Meilleur port |

Recommandations par région

// Recommandation pour import depuis la Chine
const recom = getRegionalIncotermRecommendation('ASIA_PACIFIC', 'CHINA');

console.log(recom.importToOHADA.recommended); // ['FOB', 'CFR', 'CIF']
console.log(recom.importToOHADA.avoid);       // ['DDP', 'DAP', 'EXW']
console.log(recom.customsNotes);              // Notes douanières
console.log(recom.specificDocuments);         // Documents requis
console.log(recom.risks);                     // Risques spécifiques

Accords commerciaux

| Accord | Description | |--------|-------------| | EPA_EU_AFRICA | Partenariat Économique UE-Afrique | | AGOA | African Growth and Opportunity Act (USA) | | GSP | Système Généralisé de Préférences | | ZLECAF | Zone de Libre-Échange Continentale Africaine | | CEDEAO | Communauté Économique des États de l'Afrique de l'Ouest |

const agreements = getTradeAgreementsByRegion('EUROPE');
// ['EPA_EU_AFRICA', 'GSP', 'WTO']

const description = getTradeAgreementDescription('AGOA');
// "African Growth and Opportunity Act - Accès préférentiel au marché US"

Statistiques commerce international

const stats = getInternationalTradeStats();
// {
//   totalInternationalPorts: 23,
//   africaHubPorts: 14,
//   totalTradeVolume: 86.5, // milliards USD
//   topPartners: [
//     { region: 'ASIA_PACIFIC', volume: 45000, mainProducts: ['Électronique', 'Textiles'] },
//     { region: 'EUROPE', volume: 23000, mainProducts: ['Équipements', 'Véhicules'] }
//   ]
// }

Modèles de données

Institution (Banque)

interface Institution {
  id: string;                    // Identifiant unique
  name: string;                  // Nom complet
  shortName?: string;            // Acronyme
  country: OHADACountry;         // Code pays ISO (SN, CI, CM...)
  zone: EconomicZone;            // UEMOA | CEMAC
  type: InstitutionType;         // BANQUE | ETABLISSEMENT_FINANCIER | MICROFINANCE
  group?: BankingGroup;          // Groupe bancaire (ECOBANK, BOA...)
  isBranch?: boolean;            // Est une succursale
  swiftCode?: string;            // Code SWIFT/BIC
  website?: string;              // Site web
  city?: string;                 // Ville du siège
  foundedYear?: number;          // Année de création
}

Currency (Devise)

interface Currency {
  code: CurrencyCode;            // XOF, EUR, USD...
  name: string;                  // Nom anglais
  nameFr: string;                // Nom français
  symbol: string;                // Symbole (FCFA, €, $...)
  decimals: number;              // Décimales (0 pour XOF, 2 pour EUR)
  countries: string[];           // Pays utilisant cette devise
  type: CurrencyType;            // FIAT | REGIONAL | INTERNATIONAL
  status: CurrencyStatus;        // ACTIVE | INACTIVE | RESTRICTED
  isOHADAReference?: boolean;    // Devise OHADA (XOF, XAF)
  isConvertible: boolean;        // Convertibilité
  economicZone?: EconomicZone;   // Zone économique
}

ExchangeRate (Taux de change)

interface ExchangeRate {
  fromCurrency: CurrencyCode;    // Devise source
  toCurrency: CurrencyCode;      // Devise cible
  rate: number;                  // Taux de change
  bidRate?: number;              // Taux acheteur
  askRate?: number;              // Taux vendeur
  spread?: number;               // Écart (spread)
  source: ExchangeRateSource;    // BCEAO | BEAC | BCE | MARKET...
  isFixed: boolean;              // Taux fixe (CFA/EUR)
  lastUpdated: string;           // Date de mise à jour
  change24h?: number;            // Variation 24h (%)
  change7d?: number;             // Variation 7 jours (%)
}

CurrencyConversion (Résultat de conversion)

interface CurrencyConversion {
  fromCurrency: CurrencyCode;
  toCurrency: CurrencyCode;
  fromAmount: number;            // Montant source
  toAmount: number;              // Montant converti
  rate: number;                  // Taux appliqué
  conversionFee?: number;        // Pourcentage de frais
  feeAmount: number;             // Montant des frais
  netAmount: number;             // Montant net après frais
  conversionDate: string;        // Date de conversion
  rateSource: ExchangeRateSource;
}

Incoterm

interface Incoterm {
  code: IncotermCode;            // EXW, FOB, CIF...
  name: string;                  // Nom anglais
  nameFr: string;                // Nom français
  category: IncotermCategory;    // E, F, C, D
  version: number;               // 2020
  transportModes: TransportMode[];
  seaOnly: boolean;              // Maritime uniquement
  description: string;           // Description anglais
  descriptionFr: string;         // Description français
  riskTransferPoint: TransferPoint;
  costTransferPoint: TransferPoint;
  sellerResponsibilities: SellerResponsibilities;
  buyerResponsibilities: BuyerResponsibilities;
  requiredDocuments: string[];   // Documents requis
  recommendedForOHADA: boolean;  // Recommandé pour OHADA
  africaNotes?: string;          // Notes spécifiques Afrique
}

interface SellerResponsibilities {
  packaging: boolean;            // Emballage
  loading: boolean;              // Chargement
  exportClearance: boolean;      // Dédouanement export
  mainCarriage: boolean;         // Transport principal
  insurance: boolean;            // Assurance
  importClearance: boolean;      // Dédouanement import
  unloading: boolean;            // Déchargement
  delivery: boolean;             // Livraison
}

interface BuyerResponsibilities {
  loading: boolean;
  exportClearance: boolean;
  mainCarriage: boolean;
  insurance: boolean;
  importClearance: boolean;
  unloading: boolean;
  delivery: boolean;
  dutiesAndTaxes: boolean;       // Droits et taxes
}

InternationalPort (Port international)

interface InternationalPort {
  code: string;                  // Code port (NLRTM, CNSHA...)
  name: string;                  // Nom du port
  country: string;               // Pays
  countryCode: string;           // Code ISO pays
  region: TradeRegion;           // EUROPE, ASIA_PACIFIC...
  subRegion?: string;            // Sous-région (EU, CHINA...)
  type: 'SEA' | 'AIR' | 'RAIL' | 'MULTIMODAL';
  annualVolume?: number;         // Volume annuel (TEU)
  worldRanking?: number;         // Rang mondial
  isAfricaHub?: boolean;         // Hub pour l'Afrique
  transitTimeToWestAfrica?: number;    // Jours vers Afrique Ouest
  transitTimeToCentralAfrica?: number; // Jours vers Afrique Centrale
  mainShippingLines?: string[];  // Compagnies maritimes
  notes?: string;
}

TradeCorridor (Corridor commercial)

interface TradeCorridor {
  id: string;                    // EU-UEMOA, CHINA-UEMOA...
  name: string;                  // Nom du corridor
  fromRegion: TradeRegion;       // Région d'origine
  toRegion: TradeRegion;         // Région destination
  fromCountries: string[];       // Pays d'origine
  toCountries: string[];         // Pays destination
  mainOriginPorts: string[];     // Ports d'origine
  mainDestinationPorts: string[];// Ports destination
  mainTransportMode: TransportMode;
  recommendedIncoterms: IncotermCode[];
  averageTransitTime: number;    // Jours
  averageCostPerTEU?: number;    // Coût USD/TEU
  tradeAgreements: TradeAgreement[];
  mainProducts: string[];        // Produits principaux
  annualVolume?: number;         // Volume annuel (millions USD)
  status: 'ACTIVE' | 'RESTRICTED' | 'SUSPENDED';
  notes?: string;
}

RegionalIncotermRecommendation

interface RegionalIncotermRecommendation {
  region: TradeRegion;
  subRegion?: string;
  exportFromOHADA: {
    recommended: IncotermCode[];
    avoid: IncotermCode[];
    notes: string;
  };
  importToOHADA: {
    recommended: IncotermCode[];
    avoid: IncotermCode[];
    notes: string;
  };
  customsNotes: string;          // Notes douanières
  specificDocuments: string[];   // Documents requis
  averageClearanceTime: number;  // Jours dédouanement
  risks: string[];               // Risques à considérer
}

PaymentSystem (Système de paiement)

interface PaymentSystem {
  id: string;
  name: string;
  shortName?: string;
  type: PaymentSystemType;       // RTGS | NETTING | INSTANT | MOBILE_MONEY...
  category: PaymentCategory;     // RETAIL | CORPORATE | INTERBANK
  zone: EconomicZone | 'OHADA' | 'INTERNATIONAL';
  countries: OHADACountry[];
  status: PaymentSystemStatus;   // ACTIVE | PILOT | PLANNED
  operator?: string;             // Opérateur
  regulator?: string;            // Régulateur
  minAmount?: number;            // Montant minimum
  maxAmount?: number;            // Montant maximum
  baseFee?: string;              // Frais de base
  processingTime?: number;       // Temps traitement (minutes)
  operatingHours?: string;       // Heures d'opération
  supportedInstruments?: PaymentInstrument[];
  features?: string[];
  website?: string;
}

MobileMoneyProvider

interface MobileMoneyProvider {
  id: string;
  name: string;
  operator: MobileMoneyOperator; // ORANGE_MONEY | MTN_MOBILE_MONEY...
  zone: EconomicZone | 'OHADA';
  countries: OHADACountry[];
  status: PaymentSystemStatus;
  subscribers?: number;          // Nombre d'abonnés
  ussdCodes?: Record<OHADACountry, string>; // Codes USSD par pays
  transactionLimits?: {
    daily?: number;
    monthly?: number;
    perTransaction?: number;
  };
  interoperableWith?: MobileMoneyOperator[];
  features?: string[];
}

Types TypeScript

// Pays
type OHADACountry = 'BJ' | 'BF' | 'CI' | 'GW' | 'ML' | 'NE' | 'SN' | 'TG' | 'CM' | 'CF' | 'CG' | 'GA' | 'GQ' | 'TD';
type UEMOACountry = 'BJ' | 'BF' | 'CI' | 'GW' | 'ML' | 'NE' | 'SN' | 'TG';
type CEMACCountry = 'CM' | 'CF' | 'CG' | 'GA' | 'GQ' | 'TD';
type EconomicZone = 'UEMOA' | 'CEMAC';

// Institutions
type InstitutionType = 'BANQUE' | 'ETABLISSEMENT_FINANCIER' | 'MICROFINANCE';
type BankingGroup = 'ECOBANK' | 'BOA' | 'UBA' | 'BGFI' | 'SOCIETE_GENERALE' | 'BANQUE_ATLANTIQUE' | 'CORIS' | 'NSIA' | 'ORABANK' | 'BSIC' | ...;

// Devises
type CurrencyCode = 'XOF' | 'XAF' | 'EUR' | 'USD' | 'GBP' | 'CHF' | 'CNY' | 'JPY' | 'NGN' | 'GHS' | 'ZAR' | 'MAD' | ...;
type CurrencyType = 'FIAT' | 'REGIONAL' | 'INTERNATIONAL';
type CurrencyStatus = 'ACTIVE' | 'INACTIVE' | 'RESTRICTED';
type ExchangeRateSource = 'BCEAO' | 'BEAC' | 'BCE' | 'FED' | 'MARKET' | 'OFFICIAL' | 'PARALLEL';

// Incoterms
type IncotermCode = 'EXW' | 'FCA' | 'FAS' | 'FOB' | 'CFR' | 'CIF' | 'CPT' | 'CIP' | 'DAP' | 'DPU' | 'DDP';
type IncotermCategory = 'E' | 'F' | 'C' | 'D';
type TransportMode = 'ANY' | 'SEA' | 'AIR' | 'ROAD' | 'RAIL' | 'MULTIMODAL';
type TransferPoint = 'SELLER_PREMISES' | 'CARRIER_FIRST' | 'PORT_OF_SHIPMENT' | 'PORT_OF_DESTINATION' | 'PLACE_OF_DESTINATION' | 'BUYER_PREMISES';

// Commerce international
type TradeRegion = 'EUROPE' | 'NORTH_AMERICA' | 'SOUTH_AMERICA' | 'ASIA_PACIFIC' | 'MIDDLE_EAST' | 'AFRICA' | 'OCEANIA';
type TradeAgreement = 'WTO' | 'EPA_EU_AFRICA' | 'AGOA' | 'GSP' | 'ZLECAF' | 'CEDEAO' | 'CEMAC_EU' | 'RCEP' | 'CPTPP' | 'USMCA';

// Paiements
type PaymentSystemType = 'RTGS' | 'NETTING' | 'INSTANT' | 'MOBILE_MONEY' | 'CROSS_BORDER' | 'E_MONEY' | 'BULK_PAYMENT';
type PaymentCategory = 'RETAIL' | 'CORPORATE' | 'INTERBANK';
type PaymentSystemStatus = 'ACTIVE' | 'PILOT' | 'PLANNED' | 'SUSPENDED';
type MobileMoneyOperator = 'ORANGE_MONEY' | 'MTN_MOBILE_MONEY' | 'MOOV_MONEY' | 'WAVE' | 'ECOBANK_XPRESS' | 'FREE_MONEY';

Intégration Frameworks

Angular

Installation

npm install syscohada-banks

Service Angular

// services/syscohada.service.ts
import { Injectable } from '@angular/core';
import {
  Institution,
  Currency,
  Incoterm,
  InternationalPort,
  TradeCorridor,
  OHADACountry,
  CurrencyCode,
  TradeRegion,
  getAllInstitutions,
  getInstitutionsByCountry,
  searchInstitutionsByName,
  getAllCurrencies,
  convertCurrency,
  formatCurrency,
  getExchangeRate,
  getAllIncoterms,
  getIncotermByCode,
  getRecommendedIncoterm,
  compareIncoterms,
  getAllInternationalPorts,
  getEuropeanPorts,
  getTradeCorridorById,
  getRegionalIncotermRecommendation,
  getInternationalTradeStats
} from 'syscohada-banks';

@Injectable({
  providedIn: 'root'
})
export class SyscohadaService {

  // ============ INSTITUTIONS ============

  getAllBanks(): Institution[] {
    return getAllInstitutions();
  }

  getBanksByCountry(country: OHADACountry): Institution[] {
    return getInstitutionsByCountry(country);
  }

  searchBanks(term: string): Institution[] {
    return searchInstitutionsByName(term);
  }

  // ============ DEVISES ============

  getAllCurrencies(): Currency[] {
    return getAllCurrencies();
  }

  convert(amount: number, from: CurrencyCode, to: CurrencyCode) {
    return convertCurrency(amount, from, to);
  }

  format(amount: number, currency: CurrencyCode): string {
    return formatCurrency(amount, currency);
  }

  getRate(from: CurrencyCode, to: CurrencyCode) {
    return getExchangeRate(from, to);
  }

  // ============ INCOTERMS ============

  getAllIncoterms(): Incoterm[] {
    return getAllIncoterms();
  }

  getIncoterm(code: string) {
    return getIncotermByCode(code as any);
  }

  getRecommendedIncoterm(options: {
    isExporter: boolean;
    transportMode: 'SEA' | 'AIR' | 'ROAD';
    wantsInsurance: boolean;
    isOHADA: boolean;
  }) {
    return getRecommendedIncoterm({
      ...options,
      transportMode: options.transportMode as any,
      handlesImportClearance: false
    });
  }

  compareIncoterms(code1: string, code2: string) {
    return compareIncoterms(code1 as any, code2 as any);
  }

  // ============ COMMERCE INTERNATIONAL ============

  getAllPorts(): InternationalPort[] {
    return getAllInternationalPorts();
  }

  getEuropeanPorts(): InternationalPort[] {
    return getEuropeanPorts();
  }

  getCorridor(id: string): TradeCorridor | undefined {
    return getTradeCorridorById(id);
  }

  getRegionalRecommendation(region: TradeRegion, subRegion?: string) {
    return getRegionalIncotermRecommendation(region, subRegion);
  }

  getTradeStats() {
    return getInternationalTradeStats();
  }
}

Composant de sélection de banque

// components/bank-selector/bank-selector.component.ts
import { Component, OnInit, Output, EventEmitter } from '@angular/core';
import { FormControl } from '@angular/forms';
import { Observable } from 'rxjs';
import { map, startWith } from 'rxjs/operators';
import { SyscohadaService } from '../../services/syscohada.service';
import { Institution, OHADACountry } from 'syscohada-banks';

@Component({
  selector: 'app-bank-selector',
  template: `
    <div class="bank-selector">
      <mat-form-field>
        <mat-label>Pays</mat-label>
        <mat-select [formControl]="countryControl" (selectionChange)="onCountryChange()">
          <mat-option *ngFor="let country of countries" [value]="country.code">
            {{ country.name }}
          </mat-option>
        </mat-select>
      </mat-form-field>

      <mat-form-field>
        <mat-label>Banque</mat-label>
        <input matInput [formControl]="bankControl" [matAutocomplete]="auto">
        <mat-autocomplete #auto="matAutocomplete" (optionSelected)="onBankSelected($event)">
          <mat-option *ngFor="let bank of filteredBanks$ | async" [value]="bank">
            {{ bank.name }}
            <small *ngIf="bank.swiftCode"> - {{ bank.swiftCode }}</small>
          </mat-option>
        </mat-autocomplete>
      </mat-form-field>
    </div>
  `
})
export class BankSelectorComponent implements OnInit {
  @Output() bankSelected = new EventEmitter<Institution>();

  countryControl = new FormControl('SN');
  bankControl = new FormControl('');

  countries = [
    { code: 'SN', name: 'Sénégal' },
    { code: 'CI', name: 'Côte d\'Ivoire' },
    { code: 'CM', name: 'Cameroun' },
    { code: 'ML', name: 'Mali' },
    { code: 'BF', name: 'Burkina Faso' },
    // ... autres pays
  ];

  banks: Institution[] = [];
  filteredBanks$!: Observable<Institution[]>;

  constructor(private syscohada: SyscohadaService) {}

  ngOnInit() {
    this.loadBanks();
    this.setupFilter();
  }

  loadBanks() {
    const country = this.countryControl.value as OHADACountry;
    this.banks = this.syscohada.getBanksByCountry(country);
  }

  setupFilter() {
    this.filteredBanks$ = this.bankControl.valueChanges.pipe(
      startWith(''),
      map(value => this.filterBanks(value || ''))
    );
  }

  filterBanks(value: string): Institution[] {
    const filterValue = value.toLowerCase();
    return this.banks.filter(bank =>
      bank.name.toLowerCase().includes(filterValue) ||
      bank.swiftCode?.toLowerCase().includes(filterValue)
    );
  }

  onCountryChange() {
    this.loadBanks();
    this.bankControl.setValue('');
  }

  onBankSelected(event: any) {
    this.bankSelected.emit(event.option.value);
  }
}

Composant de conversion de devises

// components/currency-converter/currency-converter.component.ts
import { Component } from '@angular/core';
import { SyscohadaService } from '../../services/syscohada.service';
import { Currency, CurrencyCode } from 'syscohada-banks';

@Component({
  selector: 'app-currency-converter',
  template: `
    <div class="converter">
      <mat-form-field>
        <mat-label>Montant</mat-label>
        <input matInput type="number" [(ngModel)]="amount" (ngModelChange)="convert()">
      </mat-form-field>

      <mat-form-field>
        <mat-label>De</mat-label>
        <mat-select [(ngModel)]="fromCurrency" (selectionChange)="convert()">
          <mat-option *ngFor="let c of currencies" [value]="c.code">
            {{ c.code }} - {{ c.nameFr }}
          </mat-option>
        </mat-select>
      </mat-form-field>

      <button mat-icon-button (click)="swap()">
        <mat-icon>swap_horiz</mat-icon>
      </button>

      <mat-form-field>
        <mat-label>Vers</mat-label>
        <mat-select [(ngModel)]="toCurrency" (selectionChange)="convert()">
          <mat-option *ngFor="let c of currencies" [value]="c.code">
            {{ c.code }} - {{ c.nameFr }}
          </mat-option>
        </mat-select>
      </mat-form-field>

      <div class="result" *ngIf="result">
        <h3>{{ result.formattedAmount }}</h3>
        <p>Taux: 1 {{ fromCurrency }} = {{ result.rate | number:'1.4-4' }} {{ toCurrency }}</p>
        <p *ngIf="result.feeAmount">Frais: {{ result.feeAmount | number }} {{ fromCurrency }}</p>
      </div>
    </div>
  `
})
export class CurrencyConverterComponent {
  currencies: Currency[] = [];
  amount = 1000000;
  fromCurrency: CurrencyCode = 'XOF';
  toCurrency: CurrencyCode = 'EUR';
  result: any = null;

  constructor(private syscohada: SyscohadaService) {
    this.currencies = this.syscohada.getAllCurrencies();
    this.convert();
  }

  convert() {
    const conversion = this.syscohada.convert(this.amount, this.fromCurrency, this.toCurrency);
    if (conversion) {
      this.result = {
        ...conversion,
        formattedAmount: this.syscohada.format(conversion.toAmount, this.toCurrency)
      };
    }
  }

  swap() {
    [this.fromCurrency, this.toCurrency] = [this.toCurrency, this.fromCurrency];
    this.convert();
  }
}

React

Installation

npm install syscohada-banks

Hook personnalisé

// hooks/useSyscohada.ts
import { useState, useMemo, useCallback } from 'react';
import {
  Institution,
  Currency,
  Incoterm,
  InternationalPort,
  OHADACountry,
  CurrencyCode,
  TradeRegion,
  getAllInstitutions,
  getInstitutionsByCountry,
  searchInstitutionsByName,
  getAllCurrencies,
  convertCurrency,
  formatCurrency,
  getExchangeRate,
  getAllIncoterms,
  getIncotermByCode,
  getRecommendedIncoterm,
  compareIncoterms,
  getAllInternationalPorts,
  getTradeCorridorById,
  getRegionalIncotermRecommendation,
  getInternationalTradeStats,
  IncotermCode
} from 'syscohada-banks';

// Hook pour les banques
export function useBanks(country?: OHADACountry) {
  const banks = useMemo(() => {
    return country ? getInstitutionsByCountry(country) : getAllInstitutions();
  }, [country]);

  const searchBanks = useCallback((term: string) => {
    return searchInstitutionsByName(term);
  }, []);

  return { banks, searchBanks };
}

// Hook pour les devises
export function useCurrency() {
  const currencies = useMemo(() => getAllCurrencies(), []);

  const convert = useCallback((
    amount: number,
    from: CurrencyCode,
    to: CurrencyCode
  ) => {
    return convertCurrency(amount, from, to);
  }, []);

  const format = useCallback((amount: number, code: CurrencyCode) => {
    return formatCurrency(amount, code);
  }, []);

  const getRate = useCallback((from: CurrencyCode, to: CurrencyCode) => {
    return getExchangeRate(from, to);
  }, []);

  return { currencies, convert, format, getRate };
}

// Hook pour les Incoterms
export function useIncoterms() {
  const incoterms = useMemo(() => getAllIncoterms(), []);

  const getIncoterm = useCallback((code: IncotermCode) => {
    return getIncotermByCode(code);
  }, []);

  const recommend = useCallback((options: {
    isExporter: boolean;
    transportMode: 'SEA' | 'AIR' | 'ROAD';
    wantsInsurance: boolean;
    isOHADA: boolean;
  }) => {
    return getRecommendedIncoterm({
      ...options,
      transportMode: options.transportMode as any,
      handlesImportClearance: false
    });
  }, []);

  const compare = useCallback((code1: IncotermCode, code2: IncotermCode) => {
    return compareIncoterms(code1, code2);
  }, []);

  return { incoterms, getIncoterm, recommend, compare };
}

// Hook pour le commerce international
export function useInternationalTrade() {
  const ports = useMemo(() => getAllInternationalPorts(), []);
  const stats = useMemo(() => getInternationalTradeStats(), []);

  const getCorridor = useCallback((id: string) => {
    return getTradeCorridorById(id);
  }, []);

  const getRecommendation = useCallback((region: TradeRegion, subRegion?: string) => {
    return getRegionalIncotermRecommendation(region, subRegion);
  }, []);

  return { ports, stats, getCorridor, getRecommendation };
}

Composant de sélection de banque

// components/BankSelector.tsx
import React, { useState, useMemo } from 'react';
import { useBanks } from '../hooks/useSyscohada';
import { Institution, OHADACountry } from 'syscohada-banks';

interface BankSelectorProps {
  onSelect: (bank: Institution) => void;
}

const countries = [
  { code: 'SN' as OHADACountry, name: 'Sénégal' },
  { code: 'CI' as OHADACountry, name: 'Côte d\'Ivoire' },
  { code: 'CM' as OHADACountry, name: 'Cameroun' },
  { code: 'ML' as OHADACountry, name: 'Mali' },
  { code: 'BF' as OHADACountry, name: 'Burkina Faso' },
];

export const BankSelector: React.FC<BankSelectorProps> = ({ onSelect }) => {
  const [country, setCountry] = useState<OHADACountry>('SN');
  const [search, setSearch] = useState('');
  const { banks, searchBanks } = useBanks(country);

  const filteredBanks = useMemo(() => {
    if (!search) return banks;
    return banks.filter(b =>
      b.name.toLowerCase().includes(search.toLowerCase()) ||
      b.swiftCode?.toLowerCase().includes(search.toLowerCase())
    );
  }, [banks, search]);

  return (
    <div className="bank-selector">
      <select
        value={country}
        onChange={(e) => setCountry(e.target.value as OHADACountry)}
      >
        {countries.map(c => (
          <option key={c.code} value={c.code}>{c.name}</option>
        ))}
      </select>

      <input
        type="text"
        placeholder="Rechercher une banque..."
        value={search}
        onChange={(e) => setSearch(e.target.value)}
      />

      <ul className="bank-list">
        {filteredBanks.map(bank => (
          <li key={bank.id} onClick={() => onSelect(bank)}>
            <strong>{bank.name}</strong>
            {bank.swiftCode && <span className="swift">{bank.swiftCode}</span>}
            {bank.group && <span className="group">{bank.group}</span>}
          </li>
        ))}
      </ul>
    </div>
  );
};

Composant de conversion de devises

// components/CurrencyConverter.tsx
import React, { useState, useEffect } from 'react';
import { useCurrency } from '../hooks/useSyscohada';
import { CurrencyCode } from 'syscohada-banks';

export const CurrencyConverter: React.FC = () => {
  const { currencies, convert, format } = useCurrency();
  const [amount, setAmount] = useState(1000000);
  const [from, setFrom] = useState<CurrencyCode>('XOF');
  const [to, setTo] = useState<CurrencyCode>('EUR');
  const [result, setResult] = useState<any>(null);

  useEffect(() => {
    const conversion = convert(amount, from, to);
    if (conversion) {
      setResult({
        ...conversion,
        formatted: format(conversion.toAmount, to)
      });
    }
  }, [amount, from, to, convert, format]);

  const swap = () => {
    setFrom(to);
    setTo(from);
  };

  return (
    <div className="currency-converter">
      <div className="input-group">
        <input
          type="number"
          value={amount}
          onChange={(e) => setAmount(Number(e.target.value))}
        />
        <select value={from} onChange={(e) => setFrom(e.target.value as CurrencyCode)}>
          {currencies.map(c => (
            <option key={c.code} value={c.code}>{c.code} - {c.nameFr}</option>
          ))}
        </select>
      </div>

      <button onClick={swap} className="swap-btn">⇄</button>

      <div className="input-group">
        <select value={to} onChange={(e) => setTo(e.target.value as CurrencyCode)}>
          {currencies.map(c => (
            <option key={c.code} value={c.code}>{c.code} - {c.nameFr}</option>
          ))}
        </select>
      </div>

      {result && (
        <div className="result">
          <h3>{result.formatted}</h3>
          <p>Taux: 1 {from} = {result.rate.toFixed(4)} {to}</p>
        </div>
      )}
    </div>
  );
};

Composant Incoterm Advisor

// components/IncotermAdvisor.tsx
import React, { useState } from 'react';
import { useIncoterms, useInternationalTrade } from '../hooks/useSyscohada';
import { TradeRegion } from 'syscohada-banks';

export const IncotermAdvisor: React.FC = () => {
  const { recommend } = useIncoterms();
  const { getRecommendation } = useInternationalTrade();

  const [isExporter, setIsExporter] = useState(false);
  const [region, setRegion] = useState<TradeRegion>('EUROPE');
  const [transportMode, setTransportMode] = useState<'SEA' | 'AIR' | 'ROAD'>('SEA');
  const [wantsInsurance, setWantsInsurance] = useState(true);

  const recommended = recommend({
    isExporter,
    transportMode,
    wantsInsurance,
    isOHADA: true
  });

  const regionalRecom = getRecommendation(region);

  return (
    <div className="incoterm-advisor">
      <h2>Conseiller Incoterms</h2>

      <div className="options">
        <label>
          <input
            type="checkbox"
            checked={isExporter}
            onChange={(e) => setIsExporter(e.target.checked)}
          />
          Je suis exportateur (depuis OHADA)
        </label>

        <select value={region} onChange={(e) => setRegion(e.target.value as TradeRegion)}>
          <option value="EUROPE">Europe</option>
          <option value="ASIA_PACIFIC">Asie</option>
          <option value="NORTH_AMERICA">Amérique du Nord</option>
          <option value="SOUTH_AMERICA">Amérique du Sud</option>
          <option value="MIDDLE_EAST">Moyen-Orient</option>
        </select>

        <select value={transportMode} onChange={(e) => setTransportMode(e.target.value as any)}>
          <option value="SEA">Maritime</option>
          <option value="AIR">Aérien</option>
          <option value="ROAD">Routier</option>
        </select>

        <label>
          <input
            type="checkbox"
            checked={wantsInsurance}
            onChange={(e) => setWantsInsurance(e.target.checked)}
          />
          Assurance souhaitée
        </label>
      </div>

      {recommended && (
        <div className="recommendation">
          <h3>Incoterm recommandé: {recommended.code}</h3>
          <p>{recommended.nameFr}</p>
          <p>{recommended.descriptionFr}</p>
        </div>
      )}

      {regionalRecom && (
        <div className="regional-advice">
          <h3>Conseils pour {region}</h3>
          <div>
            <h4>Recommandés:</h4>
            <ul>
              {(isExporter ? regionalRecom.exportFromOHADA : regionalRecom.importToOHADA)
                .recommended.map(code => <li key={code}>{code}</li>)}
            </ul>
          </div>
          <div>
            <h4>Risques:</h4>
            <ul>
              {regionalRecom.risks.map((risk, i) => <li key={i}>{risk}</li>)}
            </ul>
          </div>
        </div>
      )}
    </div>
  );
};

Vue.js 3

Installation

npm install syscohada-banks

Composables

// composables/useSyscohada.ts
import { ref, computed, Ref } from 'vue';
import {
  Institution,
  Currency,
  Incoterm,
  OHADACountry,
  CurrencyCode,
  TradeRegion,
  IncotermCode,
  getAllInstitutions,
  getInstitutionsByCountry,
  searchInstitutionsByName,
  getAllCurrencies,
  convertCurrency,
  formatCurrency,
  getExchangeRate,
  getAllIncoterms,
  getIncotermByCode,
  getRecommendedIncoterm,
  compareIncoterms,
  getAllInternationalPorts,
  getTradeCorridorById,
  getRegionalIncotermRecommendation,
  getInternationalTradeStats
} from 'syscohada-banks';

// Composable pour les banques
export function useBanks(country?: Ref<OHADACountry | undefined>) {
  const banks = computed(() => {
    return country?.value
      ? getInstitutionsByCountry(country.value)
      : getAllInstitutions();
  });

  const searchBanks = (term: string) => searchInstitutionsByName(term);

  return { banks, searchBanks };
}

// Composable pour les devises
export function useCurrency() {
  const currencies = computed(() => getAllCurrencies());

  const convert = (amount: number, from: CurrencyCode, to: CurrencyCode) => {
    return convertCurrency(amount, from, to);
  };

  const format = (amount: number, code: CurrencyCode) => {
    return formatCurrency(amount, code);
  };

  const getRate = (from: CurrencyCode, to: CurrencyCode) => {
    return getExchangeRate(from, to);
  };

  return { currencies, convert, format, getRate };
}

// Composable pour les Incoterms
export function useIncoterms() {
  const incoterms = computed(() => getAllIncoterms());

  const getIncoterm = (code: IncotermCode) => getIncotermByCode(code);

  const recommend = (options: {
    isExporter: boolean;
    transportMode: 'SEA' | 'AIR' | 'ROAD';
    wantsInsurance: boolean;
    isOHADA: boolean;
  }) => {
    return getRecommendedIncoterm({
      ...options,
      transportMode: options.transportMode as any,
      handlesImportClearance: false
    });
  };

  const compare = (code1: IncotermCode, code2: IncotermCode) => {
    return compareIncoterms(code1, code2);
  };

  return { incoterms, getIncoterm, recommend, compare };
}

// Composable pour le commerce international
export function useInternationalTrade() {
  const ports = computed(() => getAllInternationalPorts());
  const stats = computed(() => getInternationalTradeStats());

  const getCorridor = (id: string) => getTradeCorridorById(id);

  const getRecommendation = (region: TradeRegion, subRegion?: string) => {
    return getRegionalIncotermRecommendation(region, subRegion);
  };

  return { ports, stats, getCorridor, getRecommendation };
}

Composant de sélection de banque

<!-- components/BankSelector.vue -->
<template>
  <div class="bank-selector">
    <select v-model="selectedCountry">
      <option v-for="c in countries" :key="c.code" :value="c.code">
        {{ c.name }}
      </option>
    </select>

    <input
      v-model="searchTerm"
      type="text"
      placeholder="Rechercher une banque..."
    />

    <ul class="bank-list">
      <li
        v-for="bank in filteredBanks"
        :key="bank.id"
        @click="selectBank(bank)"
      >
        <strong>{{ bank.name }}</strong>
        <span v-if="bank.swiftCode" class="swift">{{ bank.swiftCode }}</span>
        <span v-if="bank.group" class="group">{{ bank.group }}</span>
      </li>
    </ul>
  </div>
</template>

<script setup lang="ts">
import { ref, computed, toRef } from 'vue';
import { useBanks } from '../composables/useSyscohada';
import type { Institution, OHADACountry } from 'syscohada-banks';

const emit = defineEmits<{
  (e: 'select', bank: Institution): void;
}>();

const countries = [
  { code: 'SN' as OHADACountry, name: 'Sénégal' },
  { code: 'CI' as OHADACountry, name: 'Côte d\'Ivoire' },
  { code: 'CM' as OHADACountry, name: 'Cameroun' },
  { code: 'ML' as OHADACountry, name: 'Mali' },
  { code: 'BF' as OHADACountry, name: 'Burkina Faso' },
];

const selectedCountry = ref<OHADACountry>('SN');
const searchTerm = ref('');

const { banks } = useBanks(toRef(() => selectedCountry.value));

const filteredBanks = computed(() => {
  if (!searchTerm.value) return banks.value;
  const term = searchTerm.value.toLowerCase();
  return banks.value.filter(b =>
    b.name.toLowerCase().includes(term) ||
    b.swiftCode?.toLowerCase().includes(term)
  );
});

const selectBank = (bank: Institution) => {
  emit('select', bank);
};
</script>

Composant de conversion de devises

<!-- components/CurrencyConverter.vue -->
<template>
  <div class="currency-converter">
    <div class="input-group">
      <input v-model.number="amount" type="number" />
      <select v-model="fromCurrency">
        <option v-for="c in currencies" :key="c.code" :value="c.code">
          {{ c.code }} - {{ c.nameFr }}
        </option>
      </select>
    </div>

    <button @click="swap" class="swap-btn">⇄</button>

    <div class="input-group">
      <select v-model="toCurrency">
        <option v-for="c in currencies" :key="c.code" :value="c.code">
          {{ c.code }} - {{ c.nameFr }}
        </option>
      </select>
    </div>

    <div v-if="result" class="result">
      <h3>{{ formattedResult }}</h3>
      <p>Taux: 1 {{ fromCurrency }} = {{ result.rate.toFixed(4) }} {{ toCurrency }}</p>
    </div>
  </div>
</template>

<script setup lang="ts">
import { ref, computed, watch } from 'vue';
import { useCurrency } from '../composables/useSyscohada';
import type { CurrencyCode } from 'syscohada-banks';

const { currencies, convert, format } = useCurrency();

const amount = ref(1000000);
const fromCurrency = ref<CurrencyCode>('XOF');
const toCurrency = ref<CurrencyCode>('EUR');
const result = ref<any>(null);

const formattedResult = computed(() => {
  if (!result.value) return '';
  return format(result.value.toAmount, toCurrency.value);
});

const updateResult = () => {
  result.value = convert(amount.value, fromCurrency.value, toCurrency.value);
};

const swap = () => {
  const temp = fromCurrency.value;
  fromCurrency.value = toCurrency.value;
  toCurrency.value = temp;
};

watch([amount, fromCurrency, toCurrency], updateResult, { immediate: true });
</script>

Composant Incoterm Advisor

<!-- components/IncotermAdvisor.vue -->
<template>
  <div class="incoterm-advisor">
    <h2>Conseiller Incoterms</h2>

    <div class="options">
      <label>
        <input type="checkbox" v-model="isExporter" />
        Je suis exportateur (depuis OHADA)
      </label>

      <select v-model="region">
        <option value="EUROPE">Europe</option>
        <option value="ASIA_PACIFIC">Asie</option>
        <option value="NORTH_AMERICA">Amérique du Nord</option>
        <option value="SOUTH_AMERICA">Amérique du Sud</option>
        <option value="MIDDLE_EAST">Moyen-Orient</option>
      </select>

      <select v-model="transportMode">
        <option value="SEA">Maritime</option>
        <option value="AIR">Aérien</option>
        <option value="ROAD">Routier</option>
      </select>

      <label>
        <input type="checkbox" v-model="wantsInsurance" />
        Assurance souhaitée
      </label>
    </div>

    <div v-if="recommended" class="recommendation">
      <h3>Incoterm recommandé: {{ recommended.code }}</h3>
      <p>{{ recommended.nameFr }}</p>
      <p>{{ recommended.descriptionFr }}</p>
    </div>

    <div v-if="regionalRecom" class="regional-advice">
      <h3>Conseils pour {{ region }}</h3>

      <div>
        <h4>Recommandés:</h4>
        <ul>
          <li v-for="code in currentRecommendations.recommended" :key="code">
            {{ code }}
          </li>
        </ul>
      </div>

      <div>
        <h4>À éviter:</h4>
        <ul>
          <li v-for="code in currentRecommendations.avoid" :key="code">
            {{ code }}
          </li>
        </ul>
      </div>

      <div>
        <h4>Risques:</h4>
        <ul>
          <li v-for="(risk, i) in regionalRecom.risks" :key="i">
            {{ risk }}
          </li>
        </ul>
      </div>

      <div>
        <h4>Documents requis:</h4>
        <ul>
          <li v-for="(doc, i) in regionalRecom.specificDocuments" :key="i">
            {{ doc }}
          </li>
        </ul>
      </div>
    </div>
  </div>
</template>

<script setup lang="ts">
import { ref, computed } from 'vue';
import { useIncoterms, useInternationalTrade } from '../composables/useSyscohada';
import type { TradeRegion } from 'syscohada-banks';

const { recommend } = useIncoterms();
const { getRecommendation } = useInternationalTrade();

const isExporter = ref(false);
const region = ref<TradeRegion>('EUROPE');
const transportMode = ref<'SEA' | 'AIR' | 'ROAD'>('SEA');
const wantsInsurance = ref(true);

const recommended = computed(() => {
  return recommend({
    isExporter: isExporter.value,
    transportMode: transportMode.value,
    wantsInsurance: wantsInsurance.value,
    isOHADA: true
  });
});

const regionalRecom = computed(() => {
  return getRecommendation(region.value);
});

const currentRecommendations = computed(() => {
  if (!regionalRecom.value) return { recommended: [], avoid: [] };
  return isExporter.value
    ? regionalRecom.value.exportFromOHADA
    : regionalRecom.value.importToOHADA;
});
</script>

Plugin Vue.js (optionnel)

// plugins/syscohada.ts
import { App } from 'vue';
import * as syscohada from 'syscohada-banks';

export default {
  install(app: App) {
    app.config.globalProperties.$syscohada = syscohada;
    app.provide('syscohada', syscohada);
  }
};

// main.ts
import { createApp } from 'vue';
import App from './App.vue';
import syscohadaPlugin from './plugins/syscohada';

createApp(App)
  .use(syscohadaPlugin)
  .mount('#app');

Données incluses

Institutions bancaires

• 123+ banques et établissements financiers
• 94 codes SWIFT/BIC (76.4% de couverture)
• 15+ groupes bancaires majeurs
• 14 pays OHADA (UEMOA + CEMAC)

Systèmes de règlement

• RTGS : STAR-UEMOA, SYGMA, SAGETIL
• Compensation : SICA-UEMOA, SYSTAC
• Instantané : PI-SPI UEMOA, GIMACPAY
• Mobile money : Orange Money, MTN, Wave, Moov
• Transfrontalier : PAPSS, Western Union

Devises et taux

• 25 devises supportées
• 30+ paires de taux de change
• Taux fixes CFA/EUR = 655.957
• Historique 12 mois

Incoterms et commerce

• 11 Incoterms 2020 complets
• 23 ports internationaux
• 10 corridors commerciaux
• 11 accords commerciaux

Sources des données

• BCEAO (Banque Centrale des États de l'Afrique de l'Ouest)
• BEAC (Banque des États de l'Afrique Centrale)
• CCI (Chambre de Commerce Internationale) pour Incoterms
• OMC (Organisation Mondiale du Commerce)
• SWIFT pour les codes BIC
• GSMA pour Mobile Money

License

MIT © Hypnoz Team

Dernière mise à jour: Décembre 2025 - v2.1.0