@capgo/capacitor-native-biometric 7.5.4 → 8.0.1

package/CapgoCapacitorNativeBiometric.podspec

@@ -8,6 +8,6 @@
     s.author = 'Martin Donadieu'
     s.source = { :git => 'https://github.com/Cap-go/capacitor-native-biometric', :tag => s.version.to_s }
     s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
-    s.ios.deployment_target = '14.0'
+    s.ios.deployment_target = '15.0'
     s.dependency 'Capacitor'
   end

package/Package.swift

@@ -3,14 +3,14 @@ import PackageDescription
 
 let package = Package(
     name: "CapgoCapacitorNativeBiometric",
-    platforms: [.iOS(.v14)],
+    platforms: [.iOS(.v15)],
     products: [
         .library(
             name: "CapgoCapacitorNativeBiometric",
             targets: ["NativeBiometricPlugin"])
     ],
     dependencies: [
-        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "7.0.0")
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0")
     ],
     targets: [
         .target(

package/README.md

@@ -18,6 +18,7 @@ A **free**, **comprehensive** biometric authentication plugin with secure creden
 - **Flexible fallback** - Optional passcode fallback when biometrics unavailable
 - **Customizable UI** - Full control over prompts, titles, descriptions, button text
 - **Detailed error codes** - Unified error handling across iOS and Android
+- **Resume listener** - Detect biometry availability changes when app returns from background
 - **Modern package management** - Supports both Swift Package Manager (SPM) and CocoaPods (SPM-ready for Capacitor 8)
 
 Perfect for banking apps, password managers, authentication flows, and any app requiring secure user verification.
@@ -40,8 +41,16 @@ async performBiometricVerification(){
 
   if(!result.isAvailable) return;
 
+  // Check the biometry type for display purposes
+  // IMPORTANT: Always use isAvailable for logic decisions, not biometryType
   const isFaceID = result.biometryType == BiometryType.FACE_ID;
 
+  // Check if device has PIN/pattern/password set
+  console.log('Device is secure:', result.deviceIsSecure);
+
+  // Check if strong biometry (Face ID, Touch ID, fingerprint) is available
+  console.log('Strong biometry available:', result.strongBiometryIsAvailable);
+
   const verified = await NativeBiometric.verifyIdentity({
     reason: "For easy log in",
     title: "Log in",
@@ -69,6 +78,15 @@ NativeBiometric.setCredentials({
 NativeBiometric.deleteCredentials({
   server: "www.example.com",
 }).then();
+
+// Listen for biometry availability changes when app resumes from background
+const handle = await NativeBiometric.addListener('biometryChange', (result) => {
+  console.log('Biometry availability changed:', result.isAvailable);
+  console.log('Biometry type:', result.biometryType);
+});
+
+// To remove the listener when no longer needed:
+// await handle.remove();
 ```
 
 ### Biometric Auth Errors
@@ -94,6 +112,7 @@ This is a plugin specific list of error codes that can be thrown on verifyIdenti
 <docgen-index>
 
 * [`isAvailable(...)`](#isavailable)
+* [`addListener('biometryChange', ...)`](#addlistenerbiometrychange-)
 * [`verifyIdentity(...)`](#verifyidentity)
 * [`getCredentials(...)`](#getcredentials)
 * [`setCredentials(...)`](#setcredentials)
@@ -101,6 +120,7 @@ This is a plugin specific list of error codes that can be thrown on verifyIdenti
 * [`isCredentialsSaved(...)`](#iscredentialssaved)
 * [`getPluginVersion()`](#getpluginversion)
 * [Interfaces](#interfaces)
+* [Type Aliases](#type-aliases)
 * [Enums](#enums)
 
 </docgen-index>
@@ -127,6 +147,28 @@ Checks if biometric authentication hardware is available.
 --------------------
 
 
+### addListener('biometryChange', ...)
+
+```typescript
+addListener(eventName: 'biometryChange', listener: BiometryChangeListener) => Promise<PluginListenerHandle>
+```
+
+Adds a listener that is called when the app resumes from background.
+This is useful to detect if biometry availability has changed while
+the app was in the background (e.g., user enrolled/unenrolled biometrics).
+
+| Param           | Type                                                                      | Description                                                                                  |
+| --------------- | ------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| **`eventName`** | <code>'biometryChange'</code>                                             | - Must be 'biometryChange'                                                                   |
+| **`listener`**  | <code><a href="#biometrychangelistener">BiometryChangeListener</a></code> | - Callback function that receives the updated <a href="#availableresult">AvailableResult</a> |
+
+**Returns:** <code>Promise&lt;<a href="#pluginlistenerhandle">PluginListenerHandle</a>&gt;</code>
+
+**Since:** 7.6.0
+
+--------------------
+
+
 ### verifyIdentity(...)
 
 ```typescript
@@ -238,11 +280,14 @@ Get the native Capacitor plugin version.
 
 Result from isAvailable() method indicating biometric authentication availability.
 
-| Prop                         | Type                                                                      | Description                                                                                                                                                                 |
-| ---------------------------- | ------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **`isAvailable`**            | <code>boolean</code>                                                      | Whether authentication is available (biometric or fallback if useFallback is true)                                                                                          |
-| **`authenticationStrength`** | <code><a href="#authenticationstrength">AuthenticationStrength</a></code> | The strength of available authentication method (STRONG, WEAK, or NONE)                                                                                                     |
-| **`errorCode`**              | <code><a href="#biometricautherror">BiometricAuthError</a></code>         | Error code from <a href="#biometricautherror">BiometricAuthError</a> enum. Only present when isAvailable is false. Indicates why biometric authentication is not available. |
+| Prop                            | Type                                                                      | Description                                                                                                                                                                                                 |
+| ------------------------------- | ------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **`isAvailable`**               | <code>boolean</code>                                                      | Whether authentication is available (biometric or fallback if useFallback is true)                                                                                                                          |
+| **`authenticationStrength`**    | <code><a href="#authenticationstrength">AuthenticationStrength</a></code> | The strength of available authentication method (STRONG, WEAK, or NONE)                                                                                                                                     |
+| **`biometryType`**              | <code><a href="#biometrytype">BiometryType</a></code>                     | The primary biometry type available on the device. On Android devices with multiple biometry types, this returns MULTIPLE. Use this for display purposes only - always use isAvailable for logic decisions. |
+| **`deviceIsSecure`**            | <code>boolean</code>                                                      | Whether the device has a secure lock screen (PIN, pattern, or password). This is independent of biometric enrollment.                                                                                       |
+| **`strongBiometryIsAvailable`** | <code>boolean</code>                                                      | Whether strong biometry (Face ID, Touch ID, or fingerprint on devices that consider it strong) is specifically available, separate from weak biometry or device credentials.                                |
+| **`errorCode`**                 | <code><a href="#biometricautherror">BiometricAuthError</a></code>         | Error code from <a href="#biometricautherror">BiometricAuthError</a> enum. Only present when isAvailable is false. Indicates why biometric authentication is not available.                                 |
 
 
 #### IsAvailableOptions
@@ -252,6 +297,13 @@ Result from isAvailable() method indicating biometric authentication availabilit
 | **`useFallback`** | <code>boolean</code> | Specifies if should fallback to passcode authentication if biometric authentication is not available. |
 
 
+#### PluginListenerHandle
+
+| Prop         | Type                                      |
+| ------------ | ----------------------------------------- |
+| **`remove`** | <code>() =&gt; Promise&lt;void&gt;</code> |
+
+
 #### BiometricOptions
 
 | Prop                       | Type                        | Description                                                                                                                                                | Default        |
@@ -312,6 +364,16 @@ Result from isAvailable() method indicating biometric authentication availabilit
 | **`server`** | <code>string</code> |
 
 
+### Type Aliases
+
+
+#### BiometryChangeListener
+
+Callback type for biometry change listener
+
+<code>(result: <a href="#availableresult">AvailableResult</a>): void</code>
+
+
 ### Enums
 
 
@@ -324,6 +386,19 @@ Result from isAvailable() method indicating biometric authentication availabilit
 | **`WEAK`**   | <code>2</code> | Weak authentication: Face authentication on Android devices that consider face weak, or PIN/pattern/password if useFallback = true (PIN is always WEAK, never STRONG).                           |
 
 
+#### BiometryType
+
+| Members                   | Value          |
+| ------------------------- | -------------- |
+| **`NONE`**                | <code>0</code> |
+| **`TOUCH_ID`**            | <code>1</code> |
+| **`FACE_ID`**             | <code>2</code> |
+| **`FINGERPRINT`**         | <code>3</code> |
+| **`FACE_AUTHENTICATION`** | <code>4</code> |
+| **`IRIS_AUTHENTICATION`** | <code>5</code> |
+| **`MULTIPLE`**            | <code>6</code> |
+
+
 #### BiometricAuthError
 
 | Members                       | Value           | Description                                                                           |
@@ -342,19 +417,6 @@ Result from isAvailable() method indicating biometric authentication availabilit
 | **`USER_CANCEL`**             | <code>16</code> | User canceled the authentication Platform: Android, iOS                               |
 | **`USER_FALLBACK`**           | <code>17</code> | User chose to use fallback authentication method Platform: Android, iOS               |
 
-
-#### BiometryType
-
-| Members                   | Value          |
-| ------------------------- | -------------- |
-| **`NONE`**                | <code>0</code> |
-| **`TOUCH_ID`**            | <code>1</code> |
-| **`FACE_ID`**             | <code>2</code> |
-| **`FINGERPRINT`**         | <code>3</code> |
-| **`FACE_AUTHENTICATION`** | <code>4</code> |
-| **`IRIS_AUTHENTICATION`** | <code>5</code> |
-| **`MULTIPLE`**            | <code>6</code> |
-
 </docgen-api>
 ## Face ID (iOS)
 
@@ -375,6 +437,22 @@ To use android's BiometricPrompt api you must add the following permission to yo
 <uses-permission android:name="android.permission.USE_BIOMETRIC">
 ```
 
+### Important Note About biometryType on Android
+
+The `biometryType` field indicates what biometric hardware is present, but **hardware presence does not guarantee availability**. Some Android devices report face authentication hardware but don't make it available to apps.
+
+**Always use `isAvailable` for logic decisions**, not `biometryType`. The `biometryType` field should only be used for display purposes (e.g., showing "Use Face ID" vs "Use Fingerprint" in your UI).
+
+## Web Platform
+
+This plugin does not support web browsers. On web:
+- `isAvailable()` returns `{ isAvailable: false, ... }` (no error thrown)
+- `addListener()` returns a no-op handle
+- `verifyIdentity()` throws an error
+- Credential methods throw errors
+
+This allows you to safely check availability on web without try/catch, but authentication features are only available on iOS and Android.
+
 ## Contributors
 
 [Jonthia](https://github.com/jonthia)

package/android/build.gradle

@@ -1,8 +1,8 @@
 ext {
     junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
-    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.2.1'
-    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.6.1'
-    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.0'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.3.0'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.7.0'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.1'
 }
 
 buildscript {
@@ -11,18 +11,18 @@ buildscript {
         mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:8.7.2'
+        classpath 'com.android.tools.build:gradle:8.13.0'
     }
 }
 
 apply plugin: 'com.android.library'
 
 android {
-    namespace "ee.forgr.biometric.capacitornativebiometric"
-    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 35
+    namespace = "ee.forgr.biometric.capacitornativebiometric"
+    compileSdk = project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 36
     defaultConfig {
-        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 23
-        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 35
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 24
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 36
         versionCode 1
         versionName "1.0"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
@@ -34,7 +34,7 @@ android {
         }
     }
     lintOptions {
-        abortOnError false
+        abortOnError = false
     }
 }
 

package/android/src/main/java/ee/forgr/biometric/AuthActivity.java

@@ -23,7 +23,9 @@ public class AuthActivity extends AppCompatActivity {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_auth_acitivy);
 
-        maxAttempts = getIntent().getIntExtra("maxAttempts", 1);
+        // Get maxAttempts with validation: must be between 1 and 5, default to 1
+        int rawMaxAttempts = getIntent().getIntExtra("maxAttempts", 1);
+        maxAttempts = Math.max(1, Math.min(5, rawMaxAttempts));
 
         Executor executor;
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {

package/android/src/main/java/ee/forgr/biometric/NativeBiometric.java

@@ -51,7 +51,7 @@ import org.json.JSONException;
 @CapacitorPlugin(name = "NativeBiometric")
 public class NativeBiometric extends Plugin {
 
-    private final String pluginVersion = "7.3.2";
+    private final String pluginVersion = "7.5.4";
 
     //protected final static int AUTH_CODE = 0102;
 
@@ -77,11 +77,20 @@ public class NativeBiometric extends Plugin {
 
     private SharedPreferences encryptedSharedPreferences;
 
-    @PluginMethod
-    public void isAvailable(PluginCall call) {
-        JSObject ret = new JSObject();
+    @Override
+    protected void handleOnResume() {
+        super.handleOnResume();
+        // Notify listeners when app resumes from background
+        JSObject result = checkBiometryAvailability(false);
+        notifyListeners("biometryChange", result);
+    }
 
-        boolean useFallback = Boolean.TRUE.equals(call.getBoolean("useFallback", false));
+    /**
+     * Check biometry availability and return result as JSObject.
+     * This is a helper method used by both isAvailable() and handleOnResume().
+     */
+    private JSObject checkBiometryAvailability(boolean useFallback) {
+        JSObject ret = new JSObject();
 
         BiometricManager biometricManager = BiometricManager.from(getContext());
 
@@ -96,23 +105,30 @@ public class NativeBiometric extends Plugin {
         boolean hasWeakBiometric = (weakResult == BiometricManager.BIOMETRIC_SUCCESS);
 
         // Check if device has credentials (PIN/pattern/password)
-        boolean fallbackAvailable = useFallback && this.deviceHasCredentials();
+        boolean deviceIsSecure = this.deviceHasCredentials();
+        boolean fallbackAvailable = useFallback && deviceIsSecure;
+
+        // Determine biometry type
+        int biometryType = detectBiometryType(biometricManager);
+        ret.put("biometryType", biometryType);
+
+        // Device is secure if it has PIN/pattern/password
+        ret.put("deviceIsSecure", deviceIsSecure);
+
+        // Strong biometry is available only if strong biometric check passes
+        ret.put("strongBiometryIsAvailable", hasStrongBiometric);
 
         // Determine authentication strength
         int authenticationStrength = AUTH_STRENGTH_NONE;
         boolean isAvailable = false;
 
         if (hasStrongBiometric) {
-            // Strong biometric available (fingerprints on devices that consider them strong)
             authenticationStrength = AUTH_STRENGTH_STRONG;
             isAvailable = true;
         } else if (hasWeakBiometric) {
-            // Only weak biometric available (face on devices that consider it weak)
             authenticationStrength = AUTH_STRENGTH_WEAK;
             isAvailable = true;
         } else if (fallbackAvailable) {
-            // No biometrics but fallback (PIN/pattern/password) is available
-            // PIN/pattern/password is ALWAYS considered WEAK, never STRONG
             authenticationStrength = AUTH_STRENGTH_WEAK;
             isAvailable = true;
         }
@@ -120,29 +136,58 @@ public class NativeBiometric extends Plugin {
         // Handle error codes when authentication is not available
         if (!isAvailable) {
             int biometricManagerErrorCode;
-
-            // Prefer the error from strong biometric check if it failed
             if (strongResult != BiometricManager.BIOMETRIC_SUCCESS) {
                 biometricManagerErrorCode = strongResult;
             } else if (weakResult != BiometricManager.BIOMETRIC_SUCCESS) {
-                // Otherwise use error from weak biometric check if it failed
                 biometricManagerErrorCode = weakResult;
             } else {
-                // No biometrics available at all
-                // BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE indicates that biometric hardware is unavailable
-                // or cannot be accessed. This constant value may vary across Android versions, so we explicitly
-                // use the constant rather than assuming its numeric value.
                 biometricManagerErrorCode = BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE;
             }
-
-            // Convert BiometricManager error codes to plugin error codes
             int pluginErrorCode = convertBiometricManagerErrorToPluginError(biometricManagerErrorCode);
             ret.put("errorCode", pluginErrorCode);
         }
 
         ret.put("isAvailable", isAvailable);
         ret.put("authenticationStrength", authenticationStrength);
-        call.resolve(ret);
+        return ret;
+    }
+
+    @PluginMethod
+    public void isAvailable(PluginCall call) {
+        boolean useFallback = Boolean.TRUE.equals(call.getBoolean("useFallback", false));
+        JSObject result = checkBiometryAvailability(useFallback);
+        call.resolve(result);
+    }
+
+    /**
+     * Detect the primary biometry type available on the device.
+     * Note: Android doesn't provide a direct API to query specific biometry types,
+     * so we check for hardware features. This is informational only - always use
+     * isAvailable for logic decisions as hardware presence doesn't guarantee availability.
+     */
+    private int detectBiometryType(BiometricManager biometricManager) {
+        PackageManager pm = getContext().getPackageManager();
+
+        boolean hasFingerprint = pm.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT);
+        boolean hasFace = pm.hasSystemFeature(PackageManager.FEATURE_FACE);
+        boolean hasIris = pm.hasSystemFeature(PackageManager.FEATURE_IRIS);
+
+        int typeCount = 0;
+        if (hasFingerprint) typeCount++;
+        if (hasFace) typeCount++;
+        if (hasIris) typeCount++;
+
+        if (typeCount > 1) {
+            return MULTIPLE; // Multiple biometry types available
+        } else if (hasFingerprint) {
+            return FINGERPRINT;
+        } else if (hasFace) {
+            return FACE_AUTHENTICATION;
+        } else if (hasIris) {
+            return IRIS_AUTHENTICATION;
+        }
+
+        return NONE;
     }
 
     @PluginMethod
@@ -292,8 +337,10 @@ public class NativeBiometric extends Plugin {
         String KEY_ALIAS = call.getString("server", null);
 
         if (KEY_ALIAS != null) {
-            SharedPreferences sharedPreferences = getContext()
-                .getSharedPreferences(NATIVE_BIOMETRIC_SHARED_PREFERENCES, Context.MODE_PRIVATE);
+            SharedPreferences sharedPreferences = getContext().getSharedPreferences(
+                NATIVE_BIOMETRIC_SHARED_PREFERENCES,
+                Context.MODE_PRIVATE
+            );
             String username = sharedPreferences.getString(KEY_ALIAS + "-username", null);
             String password = sharedPreferences.getString(KEY_ALIAS + "-password", null);
 

package/dist/docs.json

@@ -40,6 +40,51 @@
         ],
         "slug": "isavailable"
       },
+      {
+        "name": "addListener",
+        "signature": "(eventName: 'biometryChange', listener: BiometryChangeListener) => Promise<PluginListenerHandle>",
+        "parameters": [
+          {
+            "name": "eventName",
+            "docs": "- Must be 'biometryChange'",
+            "type": "'biometryChange'"
+          },
+          {
+            "name": "listener",
+            "docs": "- Callback function that receives the updated AvailableResult",
+            "type": "BiometryChangeListener"
+          }
+        ],
+        "returns": "Promise<PluginListenerHandle>",
+        "tags": [
+          {
+            "name": "param",
+            "text": "eventName - Must be 'biometryChange'"
+          },
+          {
+            "name": "param",
+            "text": "listener - Callback function that receives the updated AvailableResult"
+          },
+          {
+            "name": "returns",
+            "text": "Handle to remove the listener"
+          },
+          {
+            "name": "since",
+            "text": "7.6.0"
+          },
+          {
+            "name": "example",
+            "text": "```typescript\nconst handle = await NativeBiometric.addListener('biometryChange', (result) => {\n  console.log('Biometry availability changed:', result.isAvailable);\n});\n\n// To remove the listener:\nawait handle.remove();\n```"
+          }
+        ],
+        "docs": "Adds a listener that is called when the app resumes from background.\nThis is useful to detect if biometry availability has changed while\nthe app was in the background (e.g., user enrolled/unenrolled biometrics).",
+        "complexTypes": [
+          "PluginListenerHandle",
+          "BiometryChangeListener"
+        ],
+        "slug": "addlistenerbiometrychange-"
+      },
       {
         "name": "verifyIdentity",
         "signature": "(options?: BiometricOptions | undefined) => Promise<void>",
@@ -258,6 +303,29 @@
           ],
           "type": "AuthenticationStrength"
         },
+        {
+          "name": "biometryType",
+          "tags": [],
+          "docs": "The primary biometry type available on the device.\nOn Android devices with multiple biometry types, this returns MULTIPLE.\nUse this for display purposes only - always use isAvailable for logic decisions.",
+          "complexTypes": [
+            "BiometryType"
+          ],
+          "type": "BiometryType"
+        },
+        {
+          "name": "deviceIsSecure",
+          "tags": [],
+          "docs": "Whether the device has a secure lock screen (PIN, pattern, or password).\nThis is independent of biometric enrollment.",
+          "complexTypes": [],
+          "type": "boolean"
+        },
+        {
+          "name": "strongBiometryIsAvailable",
+          "tags": [],
+          "docs": "Whether strong biometry (Face ID, Touch ID, or fingerprint on devices that consider it strong)\nis specifically available, separate from weak biometry or device credentials.",
+          "complexTypes": [],
+          "type": "boolean"
+        },
         {
           "name": "errorCode",
           "tags": [
@@ -290,6 +358,22 @@
         }
       ]
     },
+    {
+      "name": "PluginListenerHandle",
+      "slug": "pluginlistenerhandle",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "remove",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "() => Promise<void>"
+        }
+      ]
+    },
     {
       "name": "BiometricOptions",
       "slug": "biometricoptions",
@@ -517,6 +601,54 @@
         }
       ]
     },
+    {
+      "name": "BiometryType",
+      "slug": "biometrytype",
+      "members": [
+        {
+          "name": "NONE",
+          "value": "0",
+          "tags": [],
+          "docs": ""
+        },
+        {
+          "name": "TOUCH_ID",
+          "value": "1",
+          "tags": [],
+          "docs": ""
+        },
+        {
+          "name": "FACE_ID",
+          "value": "2",
+          "tags": [],
+          "docs": ""
+        },
+        {
+          "name": "FINGERPRINT",
+          "value": "3",
+          "tags": [],
+          "docs": ""
+        },
+        {
+          "name": "FACE_AUTHENTICATION",
+          "value": "4",
+          "tags": [],
+          "docs": ""
+        },
+        {
+          "name": "IRIS_AUTHENTICATION",
+          "value": "5",
+          "tags": [],
+          "docs": ""
+        },
+        {
+          "name": "MULTIPLE",
+          "value": "6",
+          "tags": [],
+          "docs": ""
+        }
+      ]
+    },
     {
       "name": "BiometricAuthError",
       "slug": "biometricautherror",
@@ -600,56 +732,22 @@
           "docs": "User chose to use fallback authentication method\nPlatform: Android, iOS"
         }
       ]
-    },
+    }
+  ],
+  "typeAliases": [
     {
-      "name": "BiometryType",
-      "slug": "biometrytype",
-      "members": [
-        {
-          "name": "NONE",
-          "value": "0",
-          "tags": [],
-          "docs": ""
-        },
-        {
-          "name": "TOUCH_ID",
-          "value": "1",
-          "tags": [],
-          "docs": ""
-        },
+      "name": "BiometryChangeListener",
+      "slug": "biometrychangelistener",
+      "docs": "Callback type for biometry change listener",
+      "types": [
         {
-          "name": "FACE_ID",
-          "value": "2",
-          "tags": [],
-          "docs": ""
-        },
-        {
-          "name": "FINGERPRINT",
-          "value": "3",
-          "tags": [],
-          "docs": ""
-        },
-        {
-          "name": "FACE_AUTHENTICATION",
-          "value": "4",
-          "tags": [],
-          "docs": ""
-        },
-        {
-          "name": "IRIS_AUTHENTICATION",
-          "value": "5",
-          "tags": [],
-          "docs": ""
-        },
-        {
-          "name": "MULTIPLE",
-          "value": "6",
-          "tags": [],
-          "docs": ""
+          "text": "(result: AvailableResult): void",
+          "complexTypes": [
+            "AvailableResult"
+          ]
         }
       ]
     }
   ],
-  "typeAliases": [],
   "pluginConfigs": []
 }