@movalib/movalib-commons 1.68.32 → 1.68.33

package/.claude/feature-forfaits-creation.md

@@ -0,0 +1,263 @@
+# Feature — Création / Modification de forfaits (Catalogue)
+
+## Périmètre de ce ticket
+
+**Dans le scope**
+- Nouveau point d'entrée "AJOUTER" sur la page catalogue (Produit / Service / **Forfait**)
+- Écran de création **et** d'édition d'un forfait (CRUD complet sur l'entité Package)
+- Validation de cohérence TTC + répartition de l'écart (prorata / manuelle)
+- Affectation du compte comptable de regroupement pièces
+
+**Hors scope (ticket suivant, ne rien implémenter ici)**
+- Ajout d'un forfait sur un devis / facture (`packageIds` en query param sur `updateInvoice`/`updateQuote`)
+- `packageComponentId` sur les lignes COMMENT du document
+- Sortie de stock à la finalisation
+- Table analytique `document_packages`
+
+---
+
+## Contexte métier
+
+Aujourd'hui 100% du CA est catégorisé soit en Prestation de service, soit en Vente de marchandise → comptablement faux, risque en cas de contrôle fiscal. Le forfait permet de vendre un montant TTC global avec une composition cohérente, **sans afficher le détail quantités/prix** au client (légal tant qu'une description des produits est présente sur le document), tout en **ventilant pièces / MO sur deux comptes comptables distincts** (contrainte Sinao : une ligne = un seul compte comptable).
+
+---
+
+## Stack (rappel — réutiliser l'existant, pas de réinvention)
+- React + TS, Vite, MUI v6, TanStack Query v5, Formik
+- Composants partagés : `@movalib/movalib-commons`
+- **Liste forfaits** : même mécanique que la page Catalogue (liste paginée + recherche).
+- **Tableau composants** : **AG Grid** (déjà en place dans la solution). S'inspirer fortement de `panelOrder` / `contentTable` pour la structure du grid (colonnes, cell renderers/editors, gestion des lignes).
+- **Recherche/chargement produit** : utiliser `<CatalogSearchBase ... />` (comme à la création de document), pas de nouveau composant de recherche.
+- Montants : **tout en centimes** côté API. Convertir à l'affichage uniquement (helpers existants type `truncTo4` / format euro).
+
+---
+
+## API backend disponible
+
+Préfixe : `/api/billing/{garageId}/packages`
+
+| Méthode | URL | Description |
+|---------|-----|-------------|
+| GET | `/{garageId}/packages?search=&page=0&limit=20` | Liste paginée |
+| GET | `/{garageId}/packages/{packageId}` | Détail + composants (renvoie `components[].id` = UUID) |
+| POST | `/{garageId}/packages` | Création |
+| PATCH | `/{garageId}/packages/{packageId}` | Modification |
+| DELETE | `/{garageId}/packages/{packageId}` | Suppression |
+
+### Body POST / PATCH
+
+```json
+{
+  "reference": "FORFAIT-VIDANGE-01",
+  "label": "Forfait vidange complète",
+  "amountCents": 8000,
+  "amountInclVatCents": 9600,
+  "vatRate": 20.00,
+  "accountId": 42,
+  "components": [
+    {
+      "catalogId": 101,
+      "reference": "HUI-MOT-5W30",
+      "label": "Huile moteur 5W30 - 5L",
+      "quantity": 1,
+      "amountCents": 3500,
+      "amountInclVatCents": 4200,
+      "vatRate": 20.00,
+      "index": 0
+    }
+  ],
+  "labor": {
+    "serviceId": 55,
+    "reference": "MO-VIDANGE",
+    "label": "Main d'œuvre vidange",
+    "quantity": 1,
+    "amountCents": 3500,
+    "amountInclVatCents": 4200,
+    "vatRate": 20.00
+  }
+}
+```
+
+**Contrainte back (à valider aussi côté front avant submit) :**
+`Σ(components.amountInclVatCents) + labor.amountInclVatCents === amountInclVatCents`
+
+---
+
+## Modèle de données front
+
+Même pattern que les autres entités : classes `class-transformer` avec `@Expose`, instanciation via `plainToInstance` exposée en statique `JsonToObject` / `JsonToObjects`.
+
+> Le payload du endpoint `packages` est déjà en **camelCase** (cf. body API), donc pas de remapping `@Expose({ name: "..." })` à priori — `@Expose()` simple suffit. Si le back renvoie finalement du snake_case, ajouter les `name` comme sur `Account`.
+> **Important** : les sous-objets (`components[]`, `labor`) ont besoin de `@Type(() => …)` pour être hydratés en instances (sinon ils restent en plain objects).
+
+```ts
+import { Expose, Type, plainToInstance } from "class-transformer";
+
+export type PackageComponentKind = "PRODUCT" | "COMMENT";
+
+export class PackageComponent {
+  @Expose() id?: string;                     // UUID, présent en GET (édition), absent en création
+  @Expose() kind!: PackageComponentKind;     // discriminant front (cf. question ouverte)
+  @Expose() catalogId?: number;              // PRODUCT uniquement
+  @Expose() reference?: string;
+  @Expose() label!: string;                  // surchargeable ; seul champ requis pour COMMENT
+  @Expose() quantity?: number;               // PRODUCT
+  @Expose() amountCents?: number;            // PRODUCT, surchargeable (HT)
+  @Expose() amountInclVatCents?: number;     // PRODUCT, surchargeable (TTC)
+  @Expose() vatRate?: number;                // non éditable (hérité du produit)
+  @Expose() index!: number;
+
+  static JsonToObject(json: any): PackageComponent {
+    return plainToInstance(PackageComponent, json);
+  }
+
+  static JsonToObjects(json: any[]): PackageComponent[] {
+    return plainToInstance(PackageComponent, json);
+  }
+}
+
+export class PackageLabor {
+  @Expose() serviceId!: number;
+  @Expose() reference!: string;
+  @Expose() label!: string;                  // surchargeable
+  @Expose() quantity!: number;
+  @Expose() amountCents!: number;            // surchargeable (HT)
+  @Expose() amountInclVatCents!: number;     // surchargeable (TTC)
+  @Expose() vatRate!: number;                // non éditable (hérité du service)
+
+  static JsonToObject(json: any): PackageLabor {
+    return plainToInstance(PackageLabor, json);
+  }
+}
+
+export class Package {
+  @Expose() id?: string;
+  @Expose() reference!: string;
+  @Expose() label!: string;
+  @Expose() amountCents!: number;            // HT forfait (saisi)
+  @Expose() amountInclVatCents!: number;     // TTC forfait (auto = HT * 1.20)
+  @Expose() vatRate!: number;                // 20 par défaut
+  @Expose() accountId!: number;              // compte comptable regroupement pièces
+
+  @Expose()
+  @Type(() => PackageComponent)
+  components!: PackageComponent[];
+
+  @Expose()
+  @Type(() => PackageLabor)
+  labor?: PackageLabor | null;
+
+  static JsonToObject(json: any): Package {
+    return plainToInstance(Package, json);
+  }
+
+  static JsonToObjects(json: any[]): Package[] {
+    return plainToInstance(Package, json);
+  }
+}
+```
+
+> **Pour le POST/PATCH** : le camelCase étant identique côté front et API, on envoie l'objet directement (retirer les champs purement front si le back ne les attend pas).
+
+### Représentation d'une ligne COMMENT (décision actée)
+- **Discriminant front** : `kind: "PRODUCT" | "COMMENT"`.
+- Une ligne **COMMENT** ne porte que `label` + `index`. Pas de `catalogId`, pas de `quantity`, pas de montants, pas de `vatRate`.
+- **Payload** : envoyer `kind` dans l'objet composant. Côté back, une ligne COMMENT reste identifiable de façon redondante par `catalogId` absent/null + montants nuls — donc même si le back ignore `kind`, la distinction est sûre.
+- À l'hydratation (GET), si `kind` n'est pas renvoyé par le back, le déduire : `catalogId == null → COMMENT`, sinon `PRODUCT`.
+- Une ligne COMMENT compte pour **0** dans la cohérence TTC et dans le calcul de prorata (poids nul).
+
+> Reste à aligner avec le back que `kind` est bien accepté/ignoré sans erreur — sinon basculer sur le mapping `catalogId: null` seul (la logique front ne change pas).
+
+---
+
+## Spécification UI
+
+### 1. Point d'entrée — page dédiée "Forfaits" + dialog create/edit
+Créer une **page à part entière "Forfaits"**, calquée sur la page **Catalogue** (même layout, liste paginée + recherche, branchée sur `GET /{garageId}/packages`).
+- Bouton **"Créer forfait"** → ouvre la **dialog** de création (en-tête + grid composants + MO).
+- **Clic sur une ligne forfait** → ouvre la **même dialog** en **mode édition** (`GET /{garageId}/packages/{packageId}` pour hydrater).
+- Une seule dialog pour création et édition (le mode dépend de la présence d'un `id`).
+
+### 2. En-tête du forfait
+- **Référence** (texte, requis)
+- **Nom** (texte, requis)
+- **Montant HT** (saisi)
+- **Montant TTC** (calculé auto = HT × 1,20, lecture seule, TVA 20%)
+
+### 3. Tableau des composants — **AG Grid** (pièces OU commentaires)
+- Grid **AG Grid**, structure calquée sur `panelOrder` / `contentTable` (colonnes, cell renderers/editors, ajout/suppression de lignes, gestion d'index).
+- Recherche/ajout produit via **`<CatalogSearchBase ... />`** (même usage qu'à la création de document) → au choix d'un produit, ajout d'une ligne dans le grid.
+- Colonnes : désignation, quantité, PU HT, PU TTC, TVA (lecture seule).
+- **Surcharge** possible : désignation, montant HT et/ou TTC. La TVA reste non éditable.
+- Bouton **"Ajouter une ligne (produit)"** (via `CatalogSearchBase`).
+- Bouton **"Ajouter un commentaire"** → ligne de type COMMENT (désignation seule, pas de montant).
+- Suppression de ligne ; maintenir `index` cohérent après ajout/suppression/réordonnancement.
+
+### 4. Encart Main d'œuvre (MO)
+- Sélecteur de service **filtré sur le type MO**
+- **Une seule MO autorisée** (pas de tableau, un encart unique ; remplacement si on en re-sélectionne une)
+- Surcharge possible : désignation, montant HT et/ou TTC. TVA non éditable.
+
+### 5. Pré-comptabilité
+- **Compte comptable de regroupement** (pièces) attaché à la référence du forfait → `accountId`. Sélecteur de compte.
+- La MO n'a pas de sélecteur ici : elle se ventile sur le compte déjà défini au catalogue pour ce service.
+- **Picto info-bulle** : « Les pièces vendues sous un forfait doivent être catégorisées au sein d'un même compte comptable. »
+
+---
+
+## Règles métier
+
+### Cohérence TTC (blocage)
+Le total TTC saisi (Σ composants TTC + MO TTC) doit être **strictement égal** au TTC du forfait.
+- Si écart ≠ 0 → afficher l'écart à répartir + picto warning, **bloquer la sauvegarde**.
+- Picto warning, tooltip exact :
+  > « Le total TTC doit correspondre au prix de vente TTC de votre forfait. La répartition automatique de l'écart se fait au prorata du poids de chaque ligne. »
+
+### Répartition de l'écart
+- **Manuelle** : l'utilisateur ajuste les montants ligne à ligne jusqu'à écart = 0.
+- **Automatique** : prorata du poids TTC de chaque ligne (composants + MO).
+
+```
+poids_ligne = ligne.amountInclVatCents / Σ(toutes lignes TTC)
+ajustement_ligne = round(ecart * poids_ligne)
+```
+
+> ⚠️ **Arrondi centimes** : la somme des `round()` peut différer de l'écart d'1 centime (reste). Appliquer la méthode du plus grand reste (largest remainder) ou affecter le centime résiduel à la ligne au plus gros poids, pour garantir `Σ après répartition === amountInclVatCents` exactement. Recalculer le HT de chaque ligne à partir du TTC ajusté et de sa TVA pour rester cohérent.
+
+### Conversions
+- Saisie en euros à l'écran, stockage/envoi en centimes. Aucun float en transit.
+- TTC forfait = HT × (1 + vatRate/100), vatRate = 20 par défaut.
+
+---
+
+## Points d'attention
+- **Édition** : au GET, les `components[].id` (UUID) reviennent — les conserver dans le state et les renvoyer en PATCH (ne pas les regénérer).
+- Mutations via TanStack Query (`useMutation`) + invalidation de la liste catalogue/forfaits au succès.
+- Réutiliser les helpers de format/troncature existants plutôt que d'en réécrire.
+- Valider la cohérence TTC côté front **avant** l'appel pour éviter le 4xx back (mais ne pas se reposer dessus : gérer aussi l'erreur back).
+
+---
+
+## Plan d'implémentation (ordre conseillé)
+
+Avancer incrémentalement, chaque étape testable avant la suivante.
+
+1. **Service / entités** — Classes `class-transformer` (`Package`, `PackageComponent`, `PackageLabor`) + service API (`getPackages`, `getPackage`, `createPackage`, `updatePackage`, `deletePackage`) calqué sur les services existants. Hooks TanStack Query (`useQuery` liste/détail, `useMutation` create/update/delete).
+
+2. **Page liste "Forfaits"** — Nouvelle route + entrée de nav, layout calqué sur Catalogue. Liste paginée + recherche (`GET .../packages`), colonnes : référence, nom, montant HT, montant TTC. Pagination/recherche branchées.
+
+3. **Bouton "Créer forfait" + ouverture dialog** — Bouton sur la page liste → ouvre la dialog vide (mode création). Clic sur une ligne → ouvre la dialog hydratée via `getPackage` (mode édition, déduit de la présence d'`id`).
+
+4. **Dialog create/edit — squelette** — Structure de la dialog avec Formik : en-tête (référence, nom, montant HT, montant TTC auto = HT × 1,20 lecture seule). Boutons Annuler / Enregistrer (save encore désactivé). Pas encore de grid ni MO.
+
+5. **Grid composants (AG Grid)** — Intégrer le grid calqué sur `panelOrder` / `contentTable`. Colonnes désignation / qté / PU HT / PU TTC / TVA (lecture seule). Ajout via `<CatalogSearchBase />`, bouton "Ajouter un commentaire" (ligne COMMENT), suppression de ligne, gestion de l'`index`. Surcharge désignation / HT / TTC (TVA verrouillée).
+
+6. **Encart Main d'œuvre** — Sélecteur service filtré type MO, une seule MO (remplacement si re-sélection), surcharge désignation / HT / TTC (TVA verrouillée).
+
+7. **Pré-comptabilité** — Sélecteur de compte comptable de regroupement pièces (`accountId`) + picto info-bulle. (Rappel : la MO se ventile sur son compte catalogue, pas de sélecteur ici.)
+
+8. **Cohérence TTC + répartition écart** — Calcul du total TTC (composants + MO, COMMENT = 0), affichage de l'écart + picto warning, blocage de la sauvegarde si écart ≠ 0. Répartition manuelle, puis répartition automatique au prorata (avec gestion du reste d'arrondi en centimes).
+
+9. **Mapping payload + branchement mutations** — Mapper le state front → body POST/PATCH (centimes, `kind`/COMMENT, retrait des champs front non attendus), brancher save sur create/update, invalider la liste au succès, gérer les erreurs back. Conserver les UUID `components[].id` en édition.
+
+10. **Suppression** — Action de suppression depuis la liste (ou la dialog) via `deletePackage` + invalidation.

package/.claude/recaptcha-enterprise-setup.md

@@ -0,0 +1,159 @@
+# reCAPTCHA Enterprise — intégration React + TypeScript (Vite)
+
+## Prérequis
+
+- Projet React + TypeScript avec Vite
+- Une clé de site reCAPTCHA Enterprise (Google Cloud Console → reCAPTCHA Enterprise)
+
+---
+
+## 1. Variable d'environnement
+
+Dans `.env` (et `.env.production`, `.env.demo` selon vos modes) :
+
+```env
+VITE_RECAPTCHA_SITE_KEY=votre_clé_de_site_ici
+```
+
+---
+
+## 2. Helper `src/helpers/recaptcha.ts`
+
+Créez ce fichier tel quel :
+
+```typescript
+declare global {
+  interface Window {
+    grecaptcha?: {
+      enterprise: {
+        ready: (cb: () => void) => void;
+        execute: (siteKey: string, opts: { action: string }) => Promise<string>;
+      };
+    };
+  }
+}
+
+const SITE_KEY = import.meta.env.VITE_RECAPTCHA_SITE_KEY as string;
+
+let resolveReady!: () => void;
+const scriptReady = new Promise<void>(resolve => { resolveReady = resolve; });
+
+/** À appeler une seule fois au démarrage de l'app. */
+export function loadRecaptcha(): void {
+  if (!SITE_KEY) {
+    console.warn("VITE_RECAPTCHA_SITE_KEY manquante");
+    resolveReady();
+    return;
+  }
+  const existing = document.getElementById("recaptcha-enterprise");
+  if (existing) {
+    if (window.grecaptcha?.enterprise) resolveReady();
+    else existing.addEventListener('load', resolveReady, { once: true });
+    return;
+  }
+  const s = document.createElement("script");
+  s.id = "recaptcha-enterprise";
+  s.src = `https://www.google.com/recaptcha/enterprise.js?render=${SITE_KEY}`;
+  s.async = true;
+  s.onload = resolveReady;
+  document.head.appendChild(s);
+}
+
+/**
+ * Génère un token reCAPTCHA pour l'action donnée.
+ * Attend automatiquement que le script soit chargé avant d'exécuter.
+ * Token à usage unique, validité ~2 minutes.
+ */
+export function executeRecaptcha(action: string): Promise<string> {
+  return scriptReady.then(() => new Promise((resolve, reject) => {
+    const grecaptcha = window.grecaptcha?.enterprise;
+    if (!grecaptcha) {
+      reject(new Error("reCAPTCHA non chargé"));
+      return;
+    }
+    grecaptcha.ready(() => {
+      grecaptcha.execute(SITE_KEY, { action }).then(resolve).catch(reject);
+    });
+  }));
+}
+
+export {};
+```
+
+### Pourquoi `scriptReady` ?
+
+Le script est injecté avec `async`, donc il se charge en arrière-plan. Sans cette `Promise`, un composant monté directement depuis un lien externe (ex. lien email d'activation de compte) peut appeler `executeRecaptcha` avant que `window.grecaptcha` soit disponible — résultat : erreur silencieuse et action bloquée. `scriptReady` sert de verrou : `executeRecaptcha` attend que `loadRecaptcha` ait confirmé le chargement avant de s'exécuter.
+
+---
+
+## 3. Appel au démarrage dans `App.tsx`
+
+Appelez `loadRecaptcha()` **en dehors** du composant React, au niveau module, pour garantir l'injection du script dès le chargement du bundle :
+
+```typescript
+import { loadRecaptcha } from './helpers/recaptcha';
+
+loadRecaptcha(); // ← avant la définition du composant App
+
+const App = () => {
+  return (
+    // ...
+  );
+};
+```
+
+---
+
+## 4. Utilisation dans un composant
+
+```typescript
+import { executeRecaptcha } from '../helpers/recaptcha';
+
+const handleSubmit = async () => {
+  let recaptchaToken = "";
+  try {
+    recaptchaToken = await executeRecaptcha('nom_action'); // ex: 'login', 'signup', 'validateAccount'
+  } catch (e) {
+    console.error(e);
+    // Informer l'utilisateur que la vérification de sécurité est indisponible
+    return;
+  }
+
+  // Passer recaptchaToken à votre API
+  await monService.maRequete(payload, recaptchaToken);
+};
+```
+
+Les noms d'actions sont libres mais doivent être déclarés dans Google Cloud Console pour apparaître dans les rapports reCAPTCHA.
+
+---
+
+## 5. Côté API (rappel)
+
+Le backend doit valider le token auprès de l'endpoint Google :
+
+```
+POST https://recaptchaenterprise.googleapis.com/v1/projects/{PROJECT_ID}/assessments?key={API_KEY}
+```
+
+Avec le body :
+```json
+{
+  "event": {
+    "token": "<token reçu>",
+    "siteKey": "<votre clé de site>",
+    "expectedAction": "nom_action"
+  }
+}
+```
+
+---
+
+## Checklist rapide
+
+- [ ] Clé de site ajoutée dans `.env`
+- [ ] `src/helpers/recaptcha.ts` créé
+- [ ] `loadRecaptcha()` appelé au niveau module dans `App.tsx`
+- [ ] Chaque action sensible appelle `executeRecaptcha('action')` avec try/catch
+- [ ] Le token est transmis à l'API backend
+- [ ] Le backend valide le token côté serveur

package/.claude/settings.json

@@ -0,0 +1,8 @@
+{
+  "env": {
+    "CLAUDE_CODE_USE_BEDROCK": "1",
+    "AWS_PROFILE": "default",
+    "AWS_REGION": "eu-west-3",
+    "ANTHROPIC_MODEL": "eu.anthropic.claude-sonnet-4-6"
+  }
+}

package/.claude/settings.local.json

@@ -0,0 +1,12 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git ls-tree *)",
+      "Bash(npx tsc *)",
+      "Bash(grep -v \"^--$\")",
+      "Bash(git checkout *)",
+      "Bash(rm -rf /Users/juliendezerable/Documents/GitHub/movalib-pro/src/components/catalog)",
+      "Bash(git *)"
+    ]
+  }
+}

package/dist/index.d.ts

@@ -33,6 +33,7 @@ export { default as Absence } from "./src/models/Absence";
 export { default as Address } from "./src/models/Address";
 export { default as CategoryPrestation } from "./src/models/CategoryPrestation";
 export { default as Customer } from "./src/models/Customer";
+export type { EmailVerification } from "./src/models/EmailVerification";
 export { default as Document } from "./src/models/Document";
 export { default as Employee } from "./src/models/Employee";
 export { default as Event, } from "./src/models/Event";

package/dist/src/models/Customer.d.ts

@@ -1,5 +1,6 @@
 import { CustomerType } from "../helpers/Enums";
 import Address from "./Address";
+import { EmailVerification } from "./EmailVerification";
 import Role from "./Role";
 import User from "./User";
 import Vehicle from "./Vehicle";
@@ -36,6 +37,7 @@ export default class Customer extends User {
     paymentPeriod?: number;
     billingEmail?: string;
     additionalEmails?: string;
+    emailVerification?: EmailVerification;
     constructor(id: string, roles: Role[] | undefined, firstname: string | undefined, lastname: string | undefined, avatar: string | undefined, addresses: Address[] | undefined, vehicles: Vehicle[], email: string | undefined, turnover: {
         key: string;
         value: number;

package/dist/src/models/EmailVerification.d.ts

@@ -0,0 +1,13 @@
+export interface EmailVerification {
+    email: string;
+    reason: string | null;
+    verificationResult: string;
+    sendex: number;
+    role: boolean;
+    disposable: boolean;
+    acceptAll: boolean;
+    verifiedAt: string | null;
+    bounceEventType: string | null;
+    bounceReason: string | null;
+    bouncedAt: string | null;
+}

package/dist/src/models/EmailVerification.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/index.ts

@@ -47,6 +47,7 @@ export { default as Absence } from "./src/models/Absence";
 export { default as Address } from "./src/models/Address";
 export { default as CategoryPrestation } from "./src/models/CategoryPrestation";
 export { default as Customer } from "./src/models/Customer";
+export type { EmailVerification } from "./src/models/EmailVerification";
 export { default as Document } from "./src/models/Document";
 export { default as Employee } from "./src/models/Employee";
 export { default as Event,  } from "./src/models/Event";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@movalib/movalib-commons",
-	"version": "1.68.32",
+	"version": "1.68.33",
 	"description": "Bibliothèque d'objets communs à l'ensemble des projets React de Movalib",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/src/models/Customer.ts

@@ -1,5 +1,6 @@
 import { CustomerType } from "../helpers/Enums";
 import Address from "./Address";
+import { EmailVerification } from "./EmailVerification";
 import Role from "./Role";
 import User from "./User";
 import Vehicle from "./Vehicle";
@@ -37,7 +38,8 @@ export default class Customer extends User {
   discountRate?:number;
   paymentPeriod?:number;
   billingEmail?:string;
-  additionalEmails?:string
+  additionalEmails?:string;
+  emailVerification?: EmailVerification;
   constructor(
     id: string,
     roles: Role[] = [],

package/src/models/EmailVerification.ts

@@ -0,0 +1,13 @@
+export interface EmailVerification {
+  email: string;
+  reason: string | null;
+  verificationResult: string;
+  sendex: number;
+  role: boolean;
+  disposable: boolean;
+  acceptAll: boolean;
+  verifiedAt: string | null;
+  bounceEventType: string | null;
+  bounceReason: string | null;
+  bouncedAt: string | null;
+}