{"_id":"@ao627515/capacitor-sms-vault","name":"@ao627515/capacitor-sms-vault","dist-tags":{"latest":"1.0.0"},"versions":{"1.0.0":{"name":"@ao627515/capacitor-sms-vault","version":"1.0.0","publishConfig":{"access":"public"},"description":"Generalist Capacitor plugin for reading, intercepting and exporting SMS on AndroidInstalling dependencies.","main":"dist/plugin.cjs.js","module":"dist/esm/index.js","types":"dist/esm/index.d.ts","unpkg":"dist/plugin.js","author":{"name":"Az"},"license":"MIT","repository":{"type":"git","url":"git+https://github.com/ao627515/capacitor-sms-vault.git"},"bugs":{"url":"https://github.com/ao627515/capacitor-sms-vault/issues"},"keywords":["capacitor","plugin","native"],"scripts":{"verify":"npm run verify:ios && npm run verify:android && npm run verify:web","verify:ios":"xcodebuild -scheme CapacitorSmsVault -destination generic/platform=iOS","verify:android":"cd android && ./gradlew clean build test && cd ..","verify:web":"npm run build","lint":"npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint","fmt":"npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format","eslint":"eslint . --ext ts","prettier":"prettier \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java","swiftlint":"node-swiftlint","docgen":"docgen --api SmsVaultPlugin --output-readme README.md --output-json dist/docs.json","build":"npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs","clean":"rimraf ./dist","watch":"tsc --watch","prepublishOnly":"npm run build"},"devDependencies":{"@capacitor/android":"^8.0.0","@capacitor/core":"^8.0.0","@capacitor/docgen":"^0.3.1","@capacitor/ios":"^8.0.0","@ionic/eslint-config":"^0.4.0","@ionic/prettier-config":"^4.0.0","@ionic/swiftlint-config":"^2.0.0","eslint":"^8.57.1","prettier":"^3.6.2","prettier-plugin-java":"^2.7.7","rimraf":"^6.1.0","rollup":"^4.53.2","swiftlint":"^2.0.0","typescript":"^5.9.3"},"peerDependencies":{"@capacitor/core":"^7.0.0 || ^8.0.0"},"prettier":"@ionic/prettier-config","swiftlint":"@ionic/swiftlint-config","eslintConfig":{"extends":"@ionic/eslint-config/recommended"},"capacitor":{"ios":{"src":"ios"},"android":{"src":"android"}},"gitHead":"5495484a13f460eade69690eb46522a97a1f1297","_id":"@ao627515/capacitor-sms-vault@1.0.0","homepage":"https://github.com/ao627515/capacitor-sms-vault#readme","_nodeVersion":"24.11.1","_npmVersion":"11.6.2","dist":{"integrity":"sha512-NDLEkB+VK2deY1kMIKAXwivXB4tJRH9yCgsKisCiDZOW48ate93Pz85Qnumjm3RpM0ckagHIj+H/E4KksEh5Ew==","shasum":"567492769ff3863a45707ecccd34f42092e63ec9","tarball":"https://registry.npmjs.org/@ao627515/capacitor-sms-vault/-/capacitor-sms-vault-1.0.0.tgz","fileCount":29,"unpackedSize":221301,"signatures":[{"keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U","sig":"MEUCIEJFkFlYCqnBstktXyBIwtr8ydg5VPkE1+X365fmqjV2AiEAmj8+ON8PNVMIV2m4UTH2XQKuJ//9NtF7Sps4tFVGdIg="}]},"_npmUser":{"name":"ao627515","email":"ao627515@gmail.com"},"directories":{},"maintainers":[{"name":"ao627515","email":"ao627515@gmail.com"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages-npm-production","tmp":"tmp/capacitor-sms-vault_1.0.0_1784098423393_0.14698776704542293"},"_hasShrinkwrap":false}},"time":{"created":"2026-07-15T06:53:43.224Z","1.0.0":"2026-07-15T06:53:43.589Z","modified":"2026-07-15T06:53:43.771Z"},"maintainers":[{"name":"ao627515","email":"ao627515@gmail.com"}],"description":"Generalist Capacitor plugin for reading, intercepting and exporting SMS on AndroidInstalling dependencies.","homepage":"https://github.com/ao627515/capacitor-sms-vault#readme","keywords":["capacitor","plugin","native"],"repository":{"type":"git","url":"git+https://github.com/ao627515/capacitor-sms-vault.git"},"author":{"name":"Az"},"bugs":{"url":"https://github.com/ao627515/capacitor-sms-vault/issues"},"license":"MIT","readme":"# capacitor-sms-vault\n\nPlugin Capacitor généraliste pour Android — lecture de l'historique SMS, interception en temps réel et export JSON structuré. Conçu comme une brique bas niveau et neutre, sans logique métier embarquée.\n\n[](https://www.npmjs.com/package/capacitor-sms-vault)\n[](LICENSE)\n\n\n## Install\n\nTo use npm\n\n```bash\nnpm install capacitor-sms-vault\n````\n\nTo use yarn\n\n```bash\nyarn add capacitor-sms-vault\n```\n\nSync native files\n\n```bash\nnpx cap sync\n```\n\n## Configuration Android\n\n### 1. Permissions dans le Manifest de l'app hôte\n\nAjouter dans `android/app/src/main/AndroidManifest.xml` de **votre application** :\n\n```xml\n\n\n\n\n\n\n\n```\n\n### 2. App SMS par défaut (requis pour `READ_SMS` sur Android 10+)\n\nSur Android 10+, votre application doit être l'application SMS par défaut pour accéder à l'historique SMS. Utilisez `requestDefaultSmsApp()` pour déclencher le dialogue système.\n\n> ⚠️ **Note Google Play** : Les permissions `READ_SMS` et `RECEIVE_SMS` nécessitent une déclaration dans la Play Console (formulaire « Permissions Declaration »). Voir [§ Conformité Google Play](#conformit-google-play).\n\n### 3. Test en sideload (APK installé hors Play Store)\n\n> 🚧 **Ce n'est pas un bug du plugin.** C'est une restriction système Android intentionnelle.\n\nDepuis **Android 13**, Google restreint automatiquement les permissions sensibles (`READ_SMS`, `RECEIVE_SMS`) pour toute application installée en sideload (APK direct, hors Play Store). Vous verrez ce message :\n\n> *\"L'accès au statut Application de SMS par défaut a été refusé. Cette appli a demandé l'accès à des autorisations sensibles…\"*\n\nRéférence officielle Google : https://support.google.com/android/answer/12623953\n\n#### Débloquer manuellement (développeurs)\n\nIl n'existe **aucun code, aucun flag Manifest** qui contourne cette restriction — elle est appliquée au niveau de l'installeur Android, pas de l'application.\n\nProcédure manuelle à effectuer **après chaque réinstallation** de l'APK :\n\n1. **Appui long** sur l'icône de l'application\n2. **App info** (ou Infos sur l'appli)\n3. Menu **⋮** (trois points) en haut à droite\n4. **Allow restricted settings** (Autoriser les paramètres restreints)\n5. Revenir dans **Permissions → SMS → Autoriser**\n\n> ⚠️ Ce flag se remet à zéro à chaque réinstallation ou mise à jour de l'APK.\n\n#### Solutions selon votre contexte\n\n| Contexte | Solution |\n|---|---|\n| **Dev / test personnel** | Procédure manuelle \"Allow restricted settings\" ci-dessus |\n| **Distribution interne / entreprise** | MDM (Mobile Device Management) — peut pré-autoriser les permissions |\n| **Distribution publique** | Publier sur le Play Store avec le formulaire SMS Permissions Declaration |\n| **Store alternatif** | Utiliser un store qui déploie via l'API session-based installer (ex. F-Droid) |\n\n## Exemples d'utilisation\n\n### Vérifier et demander les permissions\n\n```typescript\nimport { SmsVault } from 'capacitor-sms-vault';\n\nconst status = await SmsVault.checkPermissions();\n\nif (status.readSms !== 'granted' || status.receiveSms !== 'granted') {\n const result = await SmsVault.requestPermissions();\n console.log('Permissions accordées :', result);\n}\n```\n\n### Vérifier et demander l'app SMS par défaut\n\n```typescript\nconst { isDefault } = await SmsVault.isDefaultSmsApp();\n\nif (!isDefault) {\n // Ouvre le dialogue système (Android 10+ : RoleManager, Android 6-9 : intent)\n const result = await SmsVault.requestDefaultSmsApp();\n console.log('App par défaut :', result.isDefault);\n}\n```\n\n### Lire l'historique SMS\n\n```typescript\nimport { MessageType } from 'capacitor-sms-vault';\n\n// 20 derniers SMS de la boîte de réception (INBOX par défaut)\nconst { messages } = await SmsVault.getSmsList({\n filter: { maxCount: 20 }\n});\n\n// SMS des 7 derniers jours d'un expéditeur avec projection de fil\nconst { messages: recent } = await SmsVault.getSmsList({\n filter: {\n address: '+33612345678',\n minDate: Date.now() - 7 * 24 * 60 * 60 * 1000,\n maxCount: 50,\n type: MessageType.ALL // Toutes les boîtes\n },\n projection: {\n threadId: true\n }\n});\n\nmessages.forEach(sms => {\n console.log(`[${new Date(sms.date).toISOString()}] [Thread: ${sms.threadId}] ${sms.address}: ${sms.body}`);\n});\n\n// Récupérer le nombre de messages correspondants sans les charger\nconst { count } = await SmsVault.getCount({\n filter: { address: '+33612345678' }\n});\nconsole.log(`Nombre de SMS reçus de l'expéditeur: ${count}`);\n\n// Obtenir toutes les colonnes brutes pour le débogage\nconst { messages: rawMessages } = await SmsVault.getRawSmsList({\n filter: { maxCount: 5 }\n});\nconsole.log('SMS brut pour débogage :', rawMessages);\n```\n\n#### Règles de Filtrage et Priorités\n\nLes filtres de `SmsFilter` sont classés en trois groupes :\n1. **Groupe A — Filtres cumulatifs (AND)** : `minDate`, `maxDate`, `bodyRegex`, `orderBy`, `read`, `maxCount`, `indexFrom`. Ils s'appliquent tous simultanément.\n2. **Groupe B — Filtres exclusifs (Priorité OR implicite)** : `id`, `threadId`, `address`, `addressRegex`, `body`. **N'en utiliser qu'un seul à la fois.** Si plusieurs sont fournis, la priorité suivante est appliquée : `id > threadId > address > addressRegex > body`. Seul le premier filtre valide trouvé selon cette priorité est appliqué (les autres sont ignorés).\n3. **Groupe C — Pagination** : `indexFrom` + `maxCount` (cumulables avec tout, appliqués en dernier).\n\n### Intercepter les SMS en temps réel\n\n```typescript\n// 1. Enregistrer le listener\nconst handle = await SmsVault.addListener('smsReceived', (sms) => {\n console.log('SMS reçu de', sms.address, ':', sms.body);\n});\n\n// 2. Démarrer l'écoute (par défaut 'broadcast')\nawait SmsVault.startListening();\n\n// OU : Stratégie hybride recommandée pour les applications critiques / Fintech (UEMOA, Tecno/Infinix)\n// active le BroadcastReceiver et le ContentObserver simultanément avec déduplication par id\nawait SmsVault.startListening({ strategy: 'both' });\n\n// 3. Plus tard, nettoyer\nawait SmsVault.stopListening();\nawait handle.remove();\n// ou : await SmsVault.removeAllListeners();\n```\n\n### Détecter les OTP (SMS Retriever API)\n\nL'API SMS Retriever de Google Play Services permet de récupérer le contenu d'un SMS de validation de manière totalement transparente, **sans requérir de permissions SMS** (`READ_SMS` / `RECEIVE_SMS`).\n\n#### Prérequis de format du SMS\n\nPour que le message soit intercepté par le système, le serveur d'envoi doit formater le message selon ces règles strictes :\n1. Le message ne doit pas dépasser **140 octets**.\n2. Commencer par le préfixe `<#>` (recommandé).\n3. Se terminer par l'**App Hash** unique de 11 caractères propre à votre signature d'application (ex: `FA+9qCX9VSu`).\n\nExemple de SMS :\n```text\n<#> Votre code de validation est : 123456\nFA+9qCX9VSu\n```\n\n#### Exemple de code\n\n```typescript\n// 1. Enregistrer le listener pour l'OTP\nconst handle = await SmsVault.addListener('otpReceived', (data) => {\n console.log('SMS OTP reçu :', data.message);\n \n // Extraire le code (ex: regex)\n const otpCode = data.message.match(/\\d{6}/)?.[0];\n console.log('Code OTP extrait :', otpCode);\n\n // Libérer le listener (l'API SMS Retriever est à usage unique)\n handle.remove();\n});\n\n// 2. Lancer l'écouteur (valide pour un seul message, max 5 minutes)\nawait SmsVault.startSmsRetriever();\n```\n\n### Détecter les cartes SIM actives\n\nRécupère les informations des cartes SIM actives et leurs numéros de téléphone si disponibles (sans garantie pour le numéro de téléphone qui dépend de l'opérateur).\n\n```typescript\n// Demander la permission phone si nécessaire\nconst status = await SmsVault.requestPermissions();\nif (status.phone === 'granted') {\n const { simCards } = await SmsVault.getSimInfo();\n \n simCards.forEach(sim => {\n console.log(`SIM ${sim.simSlotIndex}: ${sim.carrierName} (${sim.countryIso})`);\n if (sim.phoneNumber) {\n console.log(`Numéro détecté : ${sim.phoneNumber}`);\n } else {\n console.log(`Numéro non stocké sur la carte SIM`);\n }\n });\n}\n```\n\n### Détecter les codes de validation avec SMS User Consent\n\nContrairement à la SMS Retriever API, la SMS User Consent API ne requiert pas de format de message particulier ni de clé de hachage de l'application dans le SMS, mais elle demande un consentement explicite de l'utilisateur via une boîte de dialogue système lorsqu'un SMS est reçu.\n\n```typescript\n// 1. Enregistrer le listener pour le consentement\nconst handle = await SmsVault.addListener('smsUserConsentReceived', (data) => {\n console.log('Message reçu après consentement :', data.message);\n \n // Extraire le code OTP (ex: regex)\n const otpCode = data.message.match(/\\d{4,10}/)?.[0];\n console.log('OTP :', otpCode);\n \n handle.remove();\n});\n\n// 2. Démarrer l'écoute (valide max 5 minutes)\n// Spécifiez facultativement le numéro de l'expéditeur attendu pour restreindre le popup\nawait SmsVault.startSmsUserConsent({ senderAddress: '+22670000000' });\n```\n\n### Modifier ou Supprimer des SMS\n\n> ⚠️ **Important (Android 4.4+)** : La suppression de messages ou le marquage comme lu nécessite que votre application soit configurée comme l'**application SMS par défaut** sur l'appareil.\n\n```typescript\n// Marquer un SMS comme lu\nawait SmsVault.markAsRead({ id: '123' });\nconsole.log('Le message 123 a été marqué comme lu');\n\n// Supprimer un SMS\nawait SmsVault.deleteSms({ id: '123' });\nconsole.log('Le message 123 a été supprimé');\n```\n\n### Envoyer des SMS (Direct ou Indirect)\n\nVous pouvez envoyer des SMS de deux manières :\n1. **Mode direct** : Envoi immédiat en arrière-plan. Requiert la permission `sendSms` (`android.permission.SEND_SMS`).\n2. **Mode indirect** : Ouvre l'application de messagerie par défaut pré-remplie avec le numéro et le message. Aucune permission requise.\n\n```typescript\n// Mode Direct (avec permission)\nconst status = await SmsVault.requestPermissions();\nif (status.sendSms === 'granted') {\n await SmsVault.sendSms({\n phoneNumber: '+33612345678',\n message: 'Bonjour, ceci est un SMS direct.',\n mode: 'direct'\n });\n}\n\n// Mode Indirect (sans permission, ouvre l'UI système)\nawait SmsVault.sendSms({\n phoneNumber: '+33612345678',\n message: 'Bonjour, ceci est un SMS pré-rempli.',\n mode: 'indirect'\n});\n```\n\n## Conformité Google Play\n\n> ⚠️ **Important** : Les permissions `READ_SMS` et `RECEIVE_SMS` font partie des permissions sensibles soumises à une procédure de validation par Google.\n\n- La déclaration dans la **Play Console** (formulaire « Permissions Declaration ») est de la responsabilité de **l'application hôte**, pas du plugin.\n- Pour accéder à `READ_SMS`, l'application doit être déclarée **application SMS par défaut** ou justifier un usage conforme à la politique de Google.\n- Le plugin lui-même ne fait aucun appel réseau et ne stocke aucune donnée — il lit et transmet uniquement.\n- Référence : [Politique Google Play sur les permissions SMS/Call Log](https://support.google.com/googleplay/android-developer/answer/9047303)\n\n## Compatibilité\n\n| Capacitor | Android | Support |\n|---|---|---|\n| 7.x | API 23+ (Android 6.0+) | ✅ |\n| 8.x | API 23+ (Android 6.0+) | ✅ |\n| ≤ 6.x | — | ❌ Migrer vers Capacitor 7+ |\n| iOS | — | ❌ Non supporté (Apple n'autorise pas la lecture SMS) |\n\n\n\n\n\n* [`checkPermissions()`](#checkpermissions)\n* [`requestPermissions()`](#requestpermissions)\n* [`isDefaultSmsApp()`](#isdefaultsmsapp)\n* [`requestDefaultSmsApp()`](#requestdefaultsmsapp)\n* [`getSmsList(...)`](#getsmslist)\n* [`getCount(...)`](#getcount)\n* [`getRawSmsList(...)`](#getrawsmslist)\n* [`startListening(...)`](#startlistening)\n* [`stopListening()`](#stoplistening)\n* [`addListener('smsReceived', ...)`](#addlistenersmsreceived-)\n* [`startSmsRetriever()`](#startsmsretriever)\n* [`addListener('otpReceived', ...)`](#addlistenerotpreceived-)\n* [`getSimInfo()`](#getsiminfo)\n* [`getDeviceSimProfile()`](#getdevicesimprofile)\n* [`startMonitoringSimChanges()`](#startmonitoringsimchanges)\n* [`stopMonitoringSimChanges()`](#stopmonitoringsimchanges)\n* [`startSmsUserConsent(...)`](#startsmsuserconsent)\n* [`stopSmsUserConsent()`](#stopsmsuserconsent)\n* [`addListener('simsChanged', ...)`](#addlistenersimschanged-)\n* [`addListener('smsUserConsentReceived', ...)`](#addlistenersmsuserconsentreceived-)\n* [`markAsRead(...)`](#markasread)\n* [`markAsSeen(...)`](#markasseen)\n* [`deleteSms(...)`](#deletesms)\n* [`setSmsLocked(...)`](#setsmslocked)\n* [`sendSms(...)`](#sendsms)\n* [`removeAllListeners()`](#removealllisteners)\n* [Interfaces](#interfaces)\n* [Type Aliases](#type-aliases)\n* [Enums](#enums)\n\n\n\n\n\n\n### checkPermissions()\n\n```typescript\ncheckPermissions() => Promise\n```\n\nVérifie l'état actuel des permissions READ_SMS, RECEIVE_SMS et de l'état du téléphone.\nNe déclenche aucune demande.\n\n**Returns:** Promise<PermissionStatus>\n\n--------------------\n\n\n### requestPermissions()\n\n```typescript\nrequestPermissions() => Promise\n```\n\nDemande les permissions de lecture, réception de SMS et de l'état du téléphone à l'utilisateur.\nRetourne l'état des permissions après la décision de l'utilisateur.\n\n**Returns:** Promise<PermissionStatus>\n\n--------------------\n\n\n### isDefaultSmsApp()\n\n```typescript\nisDefaultSmsApp() => Promise<{ isDefault: boolean; }>\n```\n\nVérifie si l'application est l'application SMS par défaut du système.\nSur Android 10+, seule l'application par défaut peut lire l'historique SMS complet.\n\n**Returns:** Promise<{ isDefault: boolean; }>\n\n--------------------\n\n\n### requestDefaultSmsApp()\n\n```typescript\nrequestDefaultSmsApp() => Promise<{ isDefault: boolean; }>\n```\n\nOuvre la boîte de dialogue système pour demander à l'utilisateur de définir\ncette application comme application SMS par défaut.\nRetourne le statut après la décision de l'utilisateur.\n\n**Returns:** Promise<{ isDefault: boolean; }>\n\n--------------------\n\n\n### getSmsList(...)\n\n```typescript\ngetSmsList(options?: { filter?: SmsFilter | undefined; projection?: SmsProjection | undefined; } | undefined) => Promise<{ messages: SmsMessage[]; }>\n```\n\nRécupère la liste des SMS selon les filtres et la projection fournis.\nLe filtrage est appliqué côté natif pour des raisons de performance.\n\n| Param | Type |\n| ------------- | ---------------------------------------------------------------------------------------------------------------------- |\n| **`options`** | { filter?: SmsFilter; projection?: SmsProjection; } |\n\n**Returns:** Promise<{ messages: SmsMessage[]; }>\n\n--------------------\n\n\n### getCount(...)\n\n```typescript\ngetCount(options?: { filter?: SmsFilter | undefined; } | undefined) => Promise<{ count: number; }>\n```\n\nRetourne uniquement le nombre de SMS correspondant aux filtres,\nsans charger les messages — utile pour la pagination ou les badges.\n\n| Param | Type |\n| ------------- | ------------------------------------------------------------- |\n| **`options`** | { filter?: SmsFilter; } |\n\n**Returns:** Promise<{ count: number; }>\n\n--------------------\n\n\n### getRawSmsList(...)\n\n```typescript\ngetRawSmsList(options?: { filter?: SmsFilter | undefined; } | undefined) => Promise<{ messages: Record[]; }>\n```\n\nRetourne toutes les colonnes brutes de la table SMS Android,\nsans mapping — utile pour le debug ou l'accès à des colonnes\nnon exposées par l'API standard (sub_id, service_center, etc.).\n\n⚠️ Performance : à éviter sur de grands volumes de messages.\nPréférer l'utilisation de getSmsList() avec une projection pour un usage en production.\n\n| Param | Type |\n| ------------- | ------------------------------------------------------------- |\n| **`options`** | { filter?: SmsFilter; } |\n\n**Returns:** Promise<{ messages: Record<string, string>[]; }>\n\n--------------------\n\n\n### startListening(...)\n\n```typescript\nstartListening(options?: { strategy?: \"broadcast\" | \"observer\" | \"both\" | undefined; } | undefined) => Promise\n```\n\nDémarre l'écoute des SMS entrants via un BroadcastReceiver ou un ContentObserver.\nRequiert la permission RECEIVE_SMS.\nÉmet l'événement 'smsReceived' à chaque nouveau SMS reçu.\n\n| Param | Type |\n| ------------- | ---------------------------------------------------------------- |\n| **`options`** | { strategy?: 'broadcast' \\| 'observer' \\| 'both'; } |\n\n--------------------\n\n\n### stopListening()\n\n```typescript\nstopListening() => Promise\n```\n\nArrête l'écoute des SMS entrants.\nLibère le BroadcastReceiver Android enregistré par startListening().\n\n--------------------\n\n\n### addListener('smsReceived', ...)\n\n```typescript\naddListener(eventName: 'smsReceived', listener: (sms: SmsMessage) => void) => Promise\n```\n\nEnregistre un listener pour les SMS reçus en temps réel.\nAppeler startListening() pour activer la réception.\n\n| Param | Type |\n| --------------- | ------------------------------------------------------------------- |\n| **`eventName`** | 'smsReceived' |\n| **`listener`** | (sms: SmsMessage) => void |\n\n**Returns:** Promise<PluginListenerHandle>\n\n--------------------\n\n\n### startSmsRetriever()\n\n```typescript\nstartSmsRetriever() => Promise\n```\n\nDémarre la détection d'OTP via la SMS Retriever API.\nL'API attend la réception d'un unique message au format spécifique contenant la clé de hachage de l'application.\nNe requiert aucune permission SMS sensible.\n\n⚠️ L'écoute expire automatiquement après 5 minutes. Passé ce délai, relancez la méthode si nécessaire.\n\n--------------------\n\n\n### addListener('otpReceived', ...)\n\n```typescript\naddListener(eventName: 'otpReceived', listener: (data: { message: string; }) => void) => Promise\n```\n\nEnregistre un listener pour la réception de l'OTP.\n\n| Param | Type | Description |\n| --------------- | ---------------------------------------------------- | --------------------------------------------------- |\n| **`eventName`** | 'otpReceived' | - 'otpReceived' |\n| **`listener`** | (data: { message: string; }) => void | - Callback appelé lorsque l'OTP/message est détecté |\n\n**Returns:** Promise<PluginListenerHandle>\n\n--------------------\n\n\n### getSimInfo()\n\n```typescript\ngetSimInfo() => Promise<{ simCards: SimCardInfo[]; }>\n```\n\nRécupère la liste des cartes SIM actives et de leurs numéros de téléphone associés.\nRequiert la permission 'phone' (READ_PHONE_STATE et READ_PHONE_NUMBERS).\n\n**Returns:** Promise<{ simCards: SimCardInfo[]; }>\n\n--------------------\n\n\n### getDeviceSimProfile()\n\n```typescript\ngetDeviceSimProfile() => Promise\n```\n\nRécupère le profil détaillé des cartes SIM de l'appareil (état double SIM et liste des cartes actives).\nRequiert la permission 'phone'.\n\n**Returns:** Promise<SimProfile>\n\n--------------------\n\n\n### startMonitoringSimChanges()\n\n```typescript\nstartMonitoringSimChanges() => Promise\n```\n\nDémarre la surveillance des changements de cartes SIM sur l'appareil.\nÉmet l'événement 'simsChanged' à chaque changement détecté.\nRequiert la permission 'phone'.\n\n--------------------\n\n\n### stopMonitoringSimChanges()\n\n```typescript\nstopMonitoringSimChanges() => Promise\n```\n\nArrête la surveillance des changements de cartes SIM sur l'appareil.\n\n--------------------\n\n\n### startSmsUserConsent(...)\n\n```typescript\nstartSmsUserConsent(options?: { senderAddress?: string | undefined; } | undefined) => Promise\n```\n\nDémarre l'écoute d'un message de validation via l'API SMS User Consent de Google.\nAffiche une boîte de dialogue système de consentement à la réception du SMS.\n\n⚠️ L'écoute expire automatiquement après 5 minutes. Passé ce délai, relancez la méthode si nécessaire.\n\n| Param | Type |\n| ------------- | ---------------------------------------- |\n| **`options`** | { senderAddress?: string; } |\n\n--------------------\n\n\n### stopSmsUserConsent()\n\n```typescript\nstopSmsUserConsent() => Promise\n```\n\nArrête l'écoute du consentement utilisateur.\n\n--------------------\n\n\n### addListener('simsChanged', ...)\n\n```typescript\naddListener(eventName: 'simsChanged', listener: (profile: SimProfile) => void) => Promise\n```\n\nEnregistre un listener pour les changements de cartes SIM.\n\n| Param | Type |\n| --------------- | ----------------------------------------------------------------------- |\n| **`eventName`** | 'simsChanged' |\n| **`listener`** | (profile: SimProfile) => void |\n\n**Returns:** Promise<PluginListenerHandle>\n\n--------------------\n\n\n### addListener('smsUserConsentReceived', ...)\n\n```typescript\naddListener(eventName: 'smsUserConsentReceived', listener: (data: { message: string; }) => void) => Promise\n```\n\nEnregistre un listener pour la réception du message après consentement de l'utilisateur.\n\n| Param | Type |\n| --------------- | ---------------------------------------------------- |\n| **`eventName`** | 'smsUserConsentReceived' |\n| **`listener`** | (data: { message: string; }) => void |\n\n**Returns:** Promise<PluginListenerHandle>\n\n--------------------\n\n\n### markAsRead(...)\n\n```typescript\nmarkAsRead(options: { id: string; }) => Promise\n```\n\nMarque un message SMS comme lu (définit le champ 'read' à 1).\nSur Android 10+, cette opération requiert que l'application soit configurée comme l'application SMS par défaut.\nRemarque : cette opération marque également le message comme vu.\n\n| Param | Type |\n| ------------- | ---------------------------- |\n| **`options`** | { id: string; } |\n\n--------------------\n\n\n### markAsSeen(...)\n\n```typescript\nmarkAsSeen(options: { id: string; }) => Promise\n```\n\nMarque un message SMS comme vu (définit le champ 'seen' à 1).\nSur Android 10+, cette opération requiert que l'application soit configurée comme l'application SMS par défaut.\n\n| Param | Type |\n| ------------- | ---------------------------- |\n| **`options`** | { id: string; } |\n\n--------------------\n\n\n### deleteSms(...)\n\n```typescript\ndeleteSms(options: { id: string; force?: boolean; }) => Promise<{ deleted: boolean; reason?: 'locked' | 'not_found'; }>\n```\n\nSupprime un SMS par son identifiant unique.\n⚠️ Cette méthode requiert obligatoirement que l'application soit configurée comme l'application SMS par défaut.\n\n| Param | Type |\n| ------------- | --------------------------------------------- |\n| **`options`** | { id: string; force?: boolean; } |\n\n**Returns:** Promise<{ deleted: boolean; reason?: 'locked' | 'not_found'; }>\n\n--------------------\n\n\n### setSmsLocked(...)\n\n```typescript\nsetSmsLocked(options: { id: string; locked: boolean; }) => Promise\n```\n\nVerrouille ou déverrouille un SMS par son identifiant unique.\n⚠️ Cette méthode requiert obligatoirement que l'application soit configurée comme l'application SMS par défaut.\n\n| Param | Type |\n| ------------- | --------------------------------------------- |\n| **`options`** | { id: string; locked: boolean; } |\n\n--------------------\n\n\n### sendSms(...)\n\n```typescript\nsendSms(options: { phoneNumber: string; message: string; mode: 'direct' | 'indirect'; }) => Promise\n```\n\nEnvoie un SMS.\n\n| Param | Type |\n| ------------- | ------------------------------------------------------------------------------------ |\n| **`options`** | { phoneNumber: string; message: string; mode: 'direct' \\| 'indirect'; } |\n\n--------------------\n\n\n### removeAllListeners()\n\n```typescript\nremoveAllListeners() => Promise\n```\n\nSupprime tous les listeners enregistrés sur ce plugin.\n\n--------------------\n\n\n### Interfaces\n\n\n#### PermissionStatus\n\n| Prop | Type | Description |\n| ---------------- | ----------------------------------------------------------- | ---------------------------------------------------------------------------- |\n| **`readSms`** | PermissionState | État de la permission READ_SMS |\n| **`receiveSms`** | PermissionState | État de la permission RECEIVE_SMS |\n| **`phone`** | PermissionState | État de la permission de lecture de l'état du téléphone (carte SIM / numéro) |\n| **`sendSms`** | PermissionState | État de la permission d'envoi de SMS (direct) |\n\n\n#### SmsMessage\n\n| Prop | Type | Description |\n| -------------------- | --------------------------------------------------------------- | ------------------------------------------------------------------------------- |\n| **`id`** | string | Identifiant unique du SMS (depuis la base ContentProvider) |\n| **`threadId`** | string | Identifiant du fil de conversation |\n| **`address`** | string | Numéro ou nom de l'expéditeur |\n| **`body`** | string | Contenu brut du SMS |\n| **`subject`** | string | Sujet du message (MMS ou opérateurs spécifiques) |\n| **`date`** | number | Timestamp local en millisecondes (date de réception/envoi sur l'appareil) |\n| **`dateSent`** | number | Timestamp réseau en millisecondes (date d'envoi côté opérateur) |\n| **`type`** | MessageType | Type de message selon MessageType |\n| **`creator`** | string | Package de l'application ayant créé le SMS |\n| **`person`** | string | Identifiant du contact associé à l'expéditeur |\n| **`subscriptionId`** | number | Identifiant de l'abonnement SIM réceptrice (Android uniquement) |\n| **`seen`** | boolean | Indique si le message a été vu (liste ou notification) (Android uniquement) |\n| **`status`** | SmsDeliveryStatus | Statut de livraison (Android uniquement) |\n| **`errorCode`** | number | Code d'erreur associé à l'envoi/réception (Android uniquement) |\n| **`locked`** | boolean | Indique si le message est verrouillé contre la suppression (Android uniquement) |\n| **`serviceCenter`** | string | Numéro du centre de messagerie de l'opérateur (Android uniquement) |\n\n\n#### SmsFilter\n\nFiltres appliqués côté natif (Kotlin/ContentResolver)\navant le retour des données au JS — plus performant\nqu'un filtrage JS sur un inbox complet.\n\n| Prop | Type | Description |\n| ------------------ | --------------------------------------------------- | ------------------------------------------------------------------------------------- |\n| **`type`** | MessageType | Type de boîte à interroger (défaut : INBOX) |\n| **`id`** | string | Identifiant exact du SMS |\n| **`threadId`** | string | Identifiant exact du fil de conversation |\n| **`address`** | string | Filtrer par expéditeur (correspondance partielle) |\n| **`addressRegex`** | string | Filtrer par expéditeur via expression régulière |\n| **`body`** | string | Filtrer par contenu du corps (correspondance partielle) |\n| **`bodyRegex`** | string | Filtrer par contenu du corps via expression régulière |\n| **`minDate`** | number | Timestamp ms minimum — retourne les SMS après cette date |\n| **`maxDate`** | number | Timestamp ms maximum — retourne les SMS avant cette date |\n| **`indexFrom`** | number | Index de départ pour la pagination (défaut : 0) |\n| **`maxCount`** | number | Nombre maximum de résultats (défaut : 100) |\n| **`read`** | 0 \\| 1 | Filtrer par statut de lecture (0 = non lu, 1 = lu) |\n| **`seen`** | 0 \\| 1 | Filtrer par statut d'affichage notification (0 = non vu, 1 = vu) (Android uniquement) |\n| **`orderBy`** | 'date_desc' \\| 'date_asc' | Ordre de tri (date_desc ou date_asc, défaut : date_desc) |\n\n\n#### SmsProjection\n\nSélection des colonnes à retourner dans SmsMessage.\nOmettre une colonne réduit la quantité de données\ntransférées entre la couche native et la couche JavaScript.\nPar défaut, toutes les colonnes obligatoires sont retournées.\n\n| Prop | Type |\n| ------------------- | -------------------- |\n| **`threadId`** | boolean |\n| **`subject`** | boolean |\n| **`dateSent`** | boolean |\n| **`creator`** | boolean |\n| **`person`** | boolean |\n| **`seen`** | boolean |\n| **`status`** | boolean |\n| **`errorCode`** | boolean |\n| **`locked`** | boolean |\n| **`serviceCenter`** | boolean |\n\n\n#### PluginListenerHandle\n\n| Prop | Type |\n| ------------ | ----------------------------------------- |\n| **`remove`** | () => Promise<void> |\n\n\n#### SimCardInfo\n\n| Prop | Type | Description |\n| -------------------- | ------------------- | -------------------------------------------------------------------------- |\n| **`carrierName`** | string | Nom de l'opérateur (ex: Orange, SFR) |\n| **`countryIso`** | string | Code pays ISO à 2 lettres (ex: fr) |\n| **`phoneNumber`** | string | Numéro de téléphone de la ligne s'il est provisionné (peut être vide) |\n| **`simSlotIndex`** | number | Index du slot SIM physique (0, 1, etc.) |\n| **`subscriptionId`** | number | Identifiant d'abonnement interne Android |\n| **`mcc`** | string | Code pays mobile (Mobile Country Code) (ex: 208, 613) (Android uniquement) |\n| **`mnc`** | string | Code réseau mobile (Mobile Network Code) (ex: 01, 02) (Android uniquement) |\n\n\n#### SimProfile\n\n| Prop | Type | Description |\n| ------------- | -------------------------- | --------------------------------------------------------------- |\n| **`dualSim`** | boolean | Indique si le périphérique possède plusieurs cartes SIM actives |\n| **`sims`** | SimCardInfo[] | Liste des informations détaillées pour chaque carte SIM active |\n\n\n### Type Aliases\n\n\n#### PermissionState\n\n'prompt' | 'prompt-with-rationale' | 'granted' | 'denied'\n\n\n#### Record\n\nConstruct a type with a set of properties K of type T\n\n{\r [P in K]: T;\r }\n\n\n### Enums\n\n\n#### MessageType\n\n| Members | Value | Description |\n| ------------ | -------------- | ------------------------------------------ |\n| **`ALL`** | 0 | Tous les messages toutes boîtes confondues |\n| **`INBOX`** | 1 | Messages reçus |\n| **`SENT`** | 2 | Messages envoyés |\n| **`DRAFT`** | 3 | Brouillons |\n| **`OUTBOX`** | 4 | Messages en attente d'envoi |\n| **`FAILED`** | 5 | Messages dont l'envoi a échoué |\n| **`QUEUED`** | 6 | Messages en file d'attente |\n\n\n#### SmsDeliveryStatus\n\n| Members | Value | Description |\n| -------------- | --------------- | ------------------------------ |\n| **`NONE`** | -1 | Aucun accusé de réception reçu |\n| **`COMPLETE`** | 0 | SMS livré avec succès |\n| **`PENDING`** | 32 | Livraison en attente |\n| **`FAILED`** | 64 | Livraison échouée |\n\n\n","readmeFilename":"README.md","_rev":"1-92a79e8611d095a19458138643662f23"}