import type { PaymentChannel, PaymentMethodType, PaymentStatus } from '../types/index.js';
/**
 * ENCAISSER — une seule question, quel que soit le canal.
 *
 * ── POURQUOI ICI, ET PAS DANS UN MODULE À PART ──────────────────────────────
 * `createPaymentCheckout` et `settlePaymentFromWebhook` **sont déjà** un point d'entrée, et neuf
 * consommateurs les appellent. Créer un module au-dessus reviendrait à renommer ce qui existe —
 * pour le prix de dix-sept livrables.
 *
 * ── LE TERMINAL EST UN PAIR OPTIONNEL, CHARGÉ PARESSEUSEMENT ────────────────
 * `@mostajs/paiement-tpe` n'est importé **que** si le canal `en-presence` est demandé. Un
 * consommateur qui ne fait que du paiement en ligne ne le charge jamais — et n'a pas à l'installer.
 *
 * C'est le même procédé que pour Stripe, déjà en place ici.
 */
/** L'unité d'un montant. ⚠️ Lire l'avertissement de `enUnitesDeBase`. */
export interface Monnaie {
    devise: string;
    /** Nombre de décimales. **Seul `2` est accepté** — voir ci-dessous. */
    uniteMineure: number;
}
/**
 * Convertit un entier de la plus petite unité vers l'unité de base.
 *
 * ⚠️ **LE PIÈGE LE PLUS COÛTEUX DE CE MODULE.** `CheckoutParams.amount` est en **unités de base** :
 * tous les dialectes font `Math.round(amount * 100)` avant d'appeler la banque. Passer `1380`
 * (13,80 €) facturerait donc **1 380,00 €** — et **rien ne lèverait**, ni ici, ni chez le
 * fournisseur, qui n'a aucune raison de trouver 1 380 € suspect.
 *
 * La conversion se fait donc **une seule fois**, ici, à la frontière.
 *
 * ⚠️ Le `× 100` est **codé en dur** chez chaque dialecte : pour une monnaie à trois décimales — le
 * dinar tunisien —, la conversion serait fausse d'un facteur dix. On **refuse** plutôt que de
 * facturer un dixième de ce qu'il faut : c'est le genre d'écart qu'on ne découvre qu'au relevé.
 */
export declare function enUnitesDeBase(montantMineur: number, uniteMineure: number): number;
export interface EncaisserParams {
    moyen: string;
    canal: PaymentChannel;
    /** ENTIER de la plus petite unité — 1380 = 13,80 €. */
    montant: number;
    monnaie: Monnaie;
    reference: string;
    /** EXIGÉ sur tout constat pris sur parole (espèces, terminal autonome). */
    acteur?: string | null;
    dialecte?: string;
    /** OÙ le client revient après un paiement accepté. **URL ABSOLUE** — cf. `exigerAbsolue`. */
    urlSucces?: string;
    /** OÙ il revient s'il renonce. **URL ABSOLUE**. */
    urlAnnulation?: string;
    /**
     * OÙ la banque nous notifie. **URL ABSOLUE.**
     *
     * Sans effet pour Stripe, qui lit la sienne au tableau de bord. **Requise par Chargily**, qui
     * l'attend PAR SESSION : l'omettre y prive de tout webhook, et la vente n'est alors close que si
     * le client revient — un client qui ferme son navigateur après avoir payé n'est jamais encaissé.
     */
    urlWebhook?: string;
    meta?: Record<string, unknown>;
}
export interface EncaisserResultat {
    verdict: string;
    canal: PaymentChannel;
    moyen: string;
    dialecte: string;
    reference: string;
    /** Rendue par le canal en ligne : où envoyer le client. */
    url?: string | null;
    message?: string;
}
/**
 * Encaisse — quel que soit le canal.
 *
 * `enLigne` est la fonction d'orchestration existante (`createPaymentCheckout`), injectée : ce
 * fichier ne la réimplémente pas.
 */
export declare function encaisser(p: EncaisserParams, deps?: {
    enLigne?: (i: any) => Promise<any>;
    dialecteTpe?: unknown;
}): Promise<EncaisserResultat>;
/**
 * LA PASSE DE RAPPROCHEMENT — ce qui ferme le cas résiduel.
 *
 * Un paiement en ligne a **deux chemins** pour se résoudre : le webhook (serveur à serveur) et le
 * retour du client. Une implémentation soignée les combine, idempotents — et alors `pending` est
 * juste.
 *
 * Reste le cas où **les deux échouent** : webhook perdu ET client qui ne revient pas (onglet fermé
 * après paiement). Il est rare, et aucun des deux chemins ne le résout.
 *
 * Sa parade n'est pas un verdict, c'est une **capacité** : interroger la banque par référence.
 * Cette capacité a déjà un nom dans l'écosystème — `interrogeParReference`, déclarée par les
 * dialectes de terminal. **Le côté en ligne avait besoin de ce que le côté terminal avait déjà
 * nommé.**
 *
 * @param delaiMs au-delà duquel un `pending` devient suspect. **Aucune valeur par défaut n'est
 *   imposée** : elle dépend du rythme de rapprochement bancaire de l'exploitant, ce qui est une
 *   décision comptable et non technique.
 */
export declare function rapprocherEnAttente(paiements: Array<{
    id: string;
    orderId?: string;
    status: PaymentStatus;
    createdAt?: Date | string;
    provider?: string;
}>, deps: {
    interroger?: (p: any) => Promise<PaymentStatus | null>;
    maintenant?: () => Date;
    delaiMs: number;
}): Promise<Array<{
    id: string;
    avant: PaymentStatus;
    apres: PaymentStatus;
    interroge: boolean;
}>>;
export declare const VERDICTS_ENCAISSEMENT: readonly import("@mostajs/paiement-contrat").Verdict[];
export type { PaymentChannel, PaymentMethodType, PaymentStatus };
//# sourceMappingURL=encaissement.d.ts.map