@microblink/blinkid-react-native 7.7.0 → 8001.0.0

package/README.md

@@ -1,39 +1,60 @@
 <p align="center" >
-  <img src="https://raw.githubusercontent.com/wiki/blinkid/blinkid-android/images/logo-microblink.png" alt="Microblink" title="Microblink">
+  <img src="https://raw.githubusercontent.com/wiki/microblink/blinkid-android/images/logo-microblink.png" alt="Microblink" title="Microblink">
 </p>
 
 # _BlinkID_ React Native plugin
 
-The BlinkID SDK is a comprehensive solution for implementing secure document scanning on the React Native cross-platform.
-It offers powerful capabilities for capturing and analyzing a wide range of identification documents. The Flutter plugin consists of BlinkID, which serves as the core module, and the BlinkIDUX package that provides a complete, ready-to-use solution with a user-friendly interface.
+The BlinkID SDK is a comprehensive solution for implementing secure document scanning in React Native cross-platform applications.
+It offers powerful capabilities for capturing and analyzing a wide range of identification documents. The React Native plugin wraps the native BlinkID SDK and BlinkID UX modules, providing a complete, ready-to-use scanning experience with a user-friendly interface.
 
-**Please note that, for maximum performance and full access to all features, it’s best to go with one of our native SDKs (for [iOS](https://github.com/BlinkID/blinkid-ios) or [Android](https://github.com/BlinkID/blinkid-android)).**
+**Please note that, for maximum performance and full access to all features, it’s best to go with one of our native SDKs (for [iOS](https://github.com/microblink/blinkid-ios) or [Android](https://github.com/microblink/blinkid-android)).**
 
 However, since the wrapper is open source, you can add the features you need on your own.
 
+> **Current version:** `@microblink/blinkid-react-native@8001.0.0` (BlinkID SDK v8001).  
+> If you are upgrading from v8000, see [What's new in v8001](#whats-new-in-v8001).  
+> If you are upgrading from v7.x, see [Migrating from v7.x](#migrating-from-v7x) (then apply the v8001 notes).
 
 # Table of contents
 - [Licensing](#licensing)
 - [Requirements](#requirements)
 - [Quickstart with the sample application](#quickstart-with-the-sample-application)
+  - [Android sample application](#android-sample-application)
+    - [On an emulator](#on-an-emulator)
+    - [On a physical device via USB](#on-a-physical-device-via-usb)
+  - [iOS sample application](#ios-sample-application)
 - [Plugin integration](#plugin-integration)
+  - [Android setup](#android-setup)
+  - [iOS setup](#ios-setup)
+  - [Permissions](#permissions)
 - [Plugin usage](#plugin-usage)
+  - [Imports and license key](#imports-and-license-key)
+  - [Configure scanning modules](#configure-scanning-modules)
+  - [Default BlinkID UX (camera scanning)](#default-blinkid-ux-camera-scanning)
+  - [BlinkID DirectAPI (static images)](#blinkid-directapi-static-images)
+  - [Document redaction](#document-redaction)
 - [Plugin specifics](#plugin-specifics)
   - [Scanning methods](#scanning-methods)
   - [SDK loading & unloading](#sdk-loading--unloading)
-  - [BlinkID Settings](#blinkid-settings)
-  - [BlinkID Results](#blinkid-results)
+  - [BlinkID settings](#blinkid-settings)
+  - [BlinkID results](#blinkid-results)
+- [What's new in v8001](#whats-new-in-v8001)
+- [What's new in v8000](#whats-new-in-v8000)
+  - [Migrating from v7.x](#migrating-from-v7x)
 - [Additional information and Support](#additional-information-and-support)
 
 ## <a name="licensing"></a> Licensing
-A valid license key is required to initialize the BlinkID plugin. A free trial license key can be requested after registering at the [Microblink Developer Hub](https://developer.microblink.com/).
+A valid license key is required to initialize the BlinkID plugin.
+
+A free trial license key can be requested after registering at the [Microblink Developer Hub](https://developer.microblink.com/).
 
 
 ## <a name="requirements"></a> Requirements
 
-- BlinkID React Native was built and tested with [React Native v0.82.1](https://github.com/facebook/react-native/releases/tag/v0.82.1)
-  - The BlinkID React Native SDK is also compatible with React Native applications running on the old architecture as it contains backward compatibility with Native Module implementation.
-- For additional help with React-Native setup, view the official documentation [here](https://reactnative.dev/docs/set-up-your-environment).
+BlinkID React Native v8001 was built and tested with [React Native v0.82.x](https://github.com/facebook/react-native/releases/tag/v0.82.1)
+- The BlinkID React Native SDK is also compatible with React Native applications running on the old architecture as it contains backward compatibility with Native Module implementation.
+
+For additional help with React-Native setup, view the official documentation [here](https://reactnative.dev/docs/set-up-your-environment).
 
 **Device requirements**
 
@@ -41,20 +62,22 @@ The BlinkID React Native plugin requires:
 - iOS version 16.0 and above
 - Android API version 24 and above
 
-- For more detailed information about the BlinkID Android and iOS requirements, view the native SDK documentation here ([Android](https://github.com/BlinkID/blinkid-android?tab=readme-ov-file#-device-requirements) & [iOS](https://github.com/BlinkID/blinkid-ios?tab=readme-ov-file#requirements)).
+For more detailed information about the BlinkID Android and iOS requirements, view the native SDK documentation here ([Android](https://github.com/microblink/blinkid-android?tab=readme-ov-file#-device-requirements) & [iOS](https://github.com/microblink/blinkid-ios?tab=readme-ov-file#requirements)).
 
 ## <a name="quickstart-with-the-sample-application"></a> Quickstart with the sample application
-The sample application demonstrates how the BlinkID plugin is implemented, used and shows how to obtain the scanned results. 
+The sample application demonstrates how the BlinkID plugin is implemented and shows how to configure scanning modules and obtain results.
 
 It contains the implementation for:
-1. The **default implementation** with the default BlinkID UX scanning experience.
-2. **Multiside DirectAPI scanning** - extracting the document information from multiple static images (from the gallery).
-3. **Singleside DirectAPI scanning** - extracting the document information from a single static images (from the gallery).
+1. **Default BlinkID UX scanning** — camera-based scanning with configurable modules.
+2. **Multiside DirectAPI scanning** — extracting document information from two static images (from the gallery).
+3. **Singleside DirectAPI scanning** — extracting document information from a single static image (from the gallery).
+
+The sample also includes a **module settings panel** where you can toggle and configure the document capture, barcode, MRZ, and VIZ modules, along with optional class filters and redaction settings.
 
-To obtain and run the sample application, follow the steps below:
-Make sure you have Node & Watchman installed before running the sample application:
+To obtain and run the sample application, follow the steps below.
+Make sure you have **Node & Watchman** installed before running the sample application:
 ```bash
-# install Watcman
+# install Watchman
 brew install watchman
 
 # install Node
@@ -64,23 +87,34 @@ brew install node
 **To install & run the sample application:**
 1. Git clone the repository:
 ```bash
-git clone https://github.com/BlinkID/blinkid-react-native.git
+git clone https://github.com/microblink/blinkid-react-native.git
+```
+2. Position to the obtained `blinkid-react-native` folder
+```bash
+cd blinkid-react-native
 ```
-2. Position to the obtained BlinkID folder and run the `initBlinkIdReactNativeSample.sh` script:
+3. Run the `initBlinkIdReactNativeSample.sh` script to create a sample app, with required configurations applied.
 ```bash
-cd blinkid-react-native && ./initBlinkIdReactNativeSample.sh
+./initBlinkIdReactNativeSample.sh
 ```
-3. After the script finishes running, position to the `BlinkIdSample` folder.
+4. After the script finishes running, position to the `BlinkIdSample` folder.
 
-**Running the sample application on Android**
+### <a name="android-sample-application"></a> Android sample application
 
-For running the sample application on Android, execute the following command:
+Running the sample application on Android
 
+#### <a name="on-an-emulator"></a> On an emulator:
+
+1. Execute the following command:
+```bash
+npx react-native start
+```
+2. In another terminal, run:
 ```bash
 npx react-native run-android
 ```
 
-**Note:** the plugin can be run directly via Android Studio as well:
+**Alternative: Run directly via Android Studio:**
 
 1. Execute the following command:
 ```bash
@@ -88,7 +122,27 @@ npx react-native start
 ```
 2. Open the `android` folder via Android Studio in the `BlinkIdSample` folder to run the Android sample application.
 
-**Running the sample application on iOS**
+#### <a name="on-a-physical-device-via-usb"></a> On a physical device via USB:
+
+1. Connect your device via USB and enable USB debugging in Developer Options.
+2. Forward the Metro bundler port:
+```bash
+adb reverse tcp:8081 tcp:8081
+```
+3. Start Metro in one terminal:
+```bash
+npx react-native start
+```
+4. In another terminal, build and run on the device:
+```bash
+npx react-native run-android
+```
+
+or open it in Android Studio and run it on the physical device from there.
+
+### <a name="ios-sample-application"></a> iOS sample application
+
+Running the sample application on iOS
 
 1. For running the sample application on iOS, execute the following command:
 ```bash
@@ -100,336 +154,622 @@ npx react-native start
 
 ## <a name="plugin-integration"></a> Plugin integration
 
-1. To add the BlinkID plugin to a React Native project, first create empty project if needed:
+1. To add the BlinkID plugin to a React Native project, first create an empty project if needed:
 ```bash
-npx @react-native-community/cli init YourAppName --package-name YourPackageName --title YourAppTitle --version "React Native version"
+npx @react-native-community/cli init YourAppName --package-name YourPackageName --title YourAppTitle --version "0.82.0"
 ```
 
-3. Install the `@microblink/blinkid-react-native` dependency:
+2. Install the `@microblink/blinkid-react-native` dependency:
 ```bash
-  npm install --save @microblink/blinkid-react-native
+npm install --save @microblink/blinkid-react-native@8001.0.0
 ```
 
-4. Android: the BlinkID library is available on Maven Central repository.
+3. Complete the platform-specific setup below.
 
-In your project root, add `mavenCentral()` repository to the repositories list, if not already present:
-```bash
-repositories {
-    // ... other repositories
-    mavenCentral()
+### <a name="android-setup"></a> Android setup
+
+Add **Maven Central** to your project repositories.
+
+In `android/settings.gradle` (or your root `build.gradle`, depending on your React Native version):
+
+```groovy
+dependencyResolutionManagement {
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+```
+
+Ensure your app uses **Kotlin v2.2.21** or newer, **minSdkVersion 24** or newer, and **compileSdkVersion 36** or newer. Use the Android Gradle Plugin and Gradle versions shipped with your React Native release (for example, React Native 0.82.x uses AGP 8.12 and Gradle 9.0).
+
+`blinkid-ux` ships its Compose-based scanning UI as a precompiled AAR, so client apps do not need to enable the Compose compiler plugin, `buildFeatures.compose`, or a Compose BOM unless they compile their own Compose code.
+
+Set the Kotlin version in your project-level `android/build.gradle`:
+
+```groovy
+buildscript {
+    ext {
+        kotlinVersion = "2.2.21"
+    }
 }
 ```
 
-5. iOS: position to the `ios` folder and run `pod install` to install the iOS dependency.
+The sample initialization script (`initBlinkIdReactNativeSample.sh`) contains the complete, tested Android configuration if you need a reference implementation.
+
+### <a name="ios-setup"></a> iOS setup
+
+1. Set the minimum iOS deployment target to **16.0** in your `ios/Podfile`:
+```ruby
+platform :ios, '16.0'
+```
+
+2. Install pods:
+```bash
+cd ios && pod install
+```
+
+The plugin ships with vendored `BlinkID.xcframework` and `BlinkIDUX.xcframework` frameworks.
+
+### <a name="permissions"></a> Permissions
+
+Add the required usage descriptions to your app:
+
+**iOS** — in `Info.plist`:
+```xml
+<key>NSCameraUsageDescription</key>
+<string>Camera access is required for document scanning</string>
+```
+
+If you use DirectAPI with images from the photo library, also add:
+```xml
+<key>NSPhotoLibraryUsageDescription</key>
+<string>Photo library access is required for document image upload</string>
+```
+
+**Android** — camera permission is typically merged from the BlinkID UX library. If needed, add to `AndroidManifest.xml`:
+```xml
+<uses-permission android:name="android.permission.CAMERA" />
+```
 
 ## <a name="plugin-usage"></a> Plugin usage
-1. After the dependency has been added to the project, first add the necessary import:
+
+**Note:** The plugin usage process can be found in the sample app `App.tsx` file [here](https://github.com/microblink/blinkid-react-native/blob/master/sample_files/App.tsx).
+
+### <a name="imports-and-license-key"></a> Imports and license key
+
+After adding the blinkid-react-native dependency, import the API and set your platform-specific license key:
+
 ```typescript
+import { Platform } from 'react-native';
 import {
   performScan,
   performDirectApiScan,
+  loadBlinkIdSdk,
+  unloadBlinkIdSdk,
+  refreshLicenseLease,
+  CountryID,
+  DocumentTypeID,
+  RegionID,
+  type BlinkIdScanningResult,
+  type BlinkIdSdkSettings,
+  type BlinkIdSessionSettings,
+  type BlinkIdScanningSettings,
+  type BlinkIdScanningUxSettings,
 } from '@microblink/blinkid-react-native';
+
+const licenseKey = Platform.select({
+  ios: 'your-ios-key',
+  android: 'your-android-key',
+})!;
+```
+
+All settings are **plain objects**. You do not need class constructors.
+
+Use `CountryID` / `RegionID` / `DocumentTypeID` for class filters and redaction document filters. Nested `Country` / `Region` / `DocumentType` types (`{ id?, rawValue }`) appear only on **scan results** (`documentClassInfo`).
+
+### <a name="configure-scanning-modules"></a> Configure scanning modules
+
+Scanning behavior is configured through `BlinkIdScanningSettings`, which contains up to four module settings. Include only the modules you want to use — omitting a module disables it.
+
+```typescript
+const scanningSettings: BlinkIdScanningSettings = {
+  // Document capture: detection, image quality, cropped images
+  documentCaptureModule: {
+    cropType: 'not-cropped', // camera UX must use not-cropped; see DirectAPI for cropped/unknown
+    inputImageSelectionStrategy: 'balanced', // camera / video only
+    documentImageReturnEnabled: true,
+    faceImageExtractionEnabled: true,
+    dotsPerInch: 250,
+    blurSensitivityLevel: 'mid',
+    imageWithBlurRejected: true,
+    glareSensitivityLevel: 'mid',
+    imageWithGlareRejected: true,
+    passportDataPageScanOnly: true,
+  },
+
+  // MRZ extraction (passports, visas, etc.)
+  mrzModule: {
+    presenceMandatory: false,
+  },
+
+  // Barcode extraction (PDF417, QR, Aztec, etc.)
+  barcodeModule: {
+    pdf417ScanningEnabled: true,
+    qrScanningEnabled: true,
+    aztecScanningEnabled: false,
+    barcodeImageReturnEnabled: false,
+  },
+
+  // VIZ extraction (visual fields on the document)
+  vizModule: {
+    signatureImageExtractionEnabled: true,
+    characterValidationEnabled: true,
+    resultAggregationEnabled: true,
+  },
+  
+  // Max character mismatches allowed per field during cross-side data matching (default: 0)
+  maxAllowedMismatchesPerField: 0,
+};
+
+const sessionSettings: BlinkIdSessionSettings = {
+  scanningMode: 'automatic', // or 'single'
+  scanningSettings,
+  // Timeouts are in milliseconds. Set to 0 to disable.
+  stepTimeoutDuration: 60000,       // default: 60 s
+  inactivityTimeoutDuration: 10000, // default: 10 s
+};
 ```
-2. Add the license key, for each platform, obtained from the [Developer Hub portal](https://developer.microblink.com/):
+
+**Module-only scanning examples:**
+
+- **Barcode only** — include `barcodeModule`, omit `mrzModule` and `vizModule`.
+- **Document capture only** (similar to BlinkID Capture) — include only `documentCaptureModule`.
+
+> **Note:** When using PDF417 and QR barcode scanning, enable both `pdf417ScanningEnabled` and `qrScanningEnabled` together. The analyzer treats them as a combined detection stage.
+
+For DirectAPI with pre-cropped document images, set `documentCaptureModule.cropType` to `"cropped"` (or `"unknown"` if cropping is uncertain). Camera scanning (`performScan`) must keep `cropType: "not-cropped"`.
+
+Module configuration helpers can be found in [ScanningModulesConfig.ts](https://github.com/microblink/blinkid-react-native/blob/master/sample_files/ScanningModulesConfig.ts).
+
+### <a name="default-blinkid-ux-camera-scanning"></a> Default BlinkID UX (camera scanning)
+
 ```typescript
-  const licenseKey = Platform.select({
-    ios: 'your-ios-key',
-    android:
-      'your-android-key',
+const sdkSettings: BlinkIdSdkSettings = {
+  licenseKey,
+  resourcesConfig: { download: true },
+  // otaResourcesConfig is optional — native defaults enable OTA update checks
+};
+
+const scanningUxSettings: BlinkIdScanningUxSettings = {
+  showHelpButton: true,
+  showOnboardingDialog: true,
+  allowHapticFeedback: true,
+  preferredCamera: 'back',
+};
+
+const classFilter = {
+  includeDocuments: [
+    { country: CountryID.Croatia, documentType: DocumentTypeID.Id },
+    { country: CountryID.USA, region: RegionID.Texas, documentType: DocumentTypeID.Dl },
+  ],
+};
+
+try {
+  const result: BlinkIdScanningResult = await performScan({
+    sdkSettings,
+    sessionSettings,
+    scanningUxSettings,
+    classFilter,
+    // redactionSettingsResolver, // optional — see Document redaction
   });
+
+  console.log(result.firstName?.value);
+  console.log(result.documentClassInfo?.country?.id);
+  console.log(result.documentClassInfo?.country?.rawValue);
+  console.log(result.firstDocumentImage); // base64, if enabled
+} catch (error) {
+  console.log(`Error during scan: ${error}`);
+}
 ```
-**Default BlinkID UX**
-1. Set all of the necessary BlinkID settings (SDK settings, session settings, and the scanning settings). If the mentioned settings are not modified, the default values will be used:
-```typescript
 
-      /**
-       * Set the BlinkID SDK settings
-       * Add the license key here from the code above
-       */
-      const sdkSettings = new BlinkIdSdkSettings(licenseKey);
-      sdkSettings.downloadResources = true;
-
-      /**
-       * Create and modify the Session Settings
-       */
-      const sessionSettings = new BlinkIdSessionSettings();
-      sessionSettings.scanningMode = ScanningMode.Automatic;
-      /**
-       * Create and modify the scanning settings
-       */
-      const scanningSettings = new BlinkIdScanningSettings();
-      scanningSettings.glareDetectionLevel = DetectionLevel.Mid;
-      scanningSettings.anonymizationMode = AnonymizationMode.FullResult;
-
-      /**
-       * Create and modify the Image settings
-       */
-      const croppedImageSettings = new CroppedImageSettings();
-      croppedImageSettings.returnDocumentImage = true;
-      croppedImageSettings.returnFaceImage = true;
-      croppedImageSettings.returnSignatureImage = true;
-      /**
-       * Place the image settings in the scanning settings
-       */
-      scanningSettings.croppedImageSettings = croppedImageSettings;
-
-      /**
-       * Place the scanning settings in the session settings
-       */
-      sessionSettings.scanningSettings = scanningSettings;
-
-      /**
-       * Modify the BlinkID UI settings for UI customization.
-       * This parameter is optional.
-       */
-      const blinkIdScanningUxSettings = new BlinkIdScanningUxSettings();
-      blinkIdScanningUxSettings.showHelpButton = true;
-      blinkIdScanningUxSettings.showOnboardingDialog = true;
-      blinkIdScanningUxSettings.allowHapticFeedback = true;
-      blinkIdScanningUxSettings.preferredCamera = PreferredCamera.Back;
-
-      /**
-       * Add the document class filter. This parameter is optional.
-       */
-      const classFilter = new ClassFilter();
-      classFilter.includeDocuments = [
-        new DocumentFilter(Country.Croatia, undefined, DocumentType.Id),
-        new DocumentFilter(Country.USA, Region.Texas, DocumentType.Dl),
-      ];
-```
-
-2. Call the `performScan` scanning method, handle the results and catch any errors:
-```typescript
-      /**
-       * Call the performScan method, where the SDK and session settings 
-       * need to be passed.
-       * 
-       * Here, you can also pass the optional BlinkIdUiSettings and ClassFilter
-       * parameters.
-       */
-      await performScan(sdkSettings, sessionSettings, blinkIdScanningUxSettings) 
-        .then((result: BlinkIdScanningResult) => {
-          // handle the results here.
-          console.log(result.firstName?.value);
-        })
-        .catch((error) => {
-          // handle any errors here.
-          console.log(`Error during scan: ${error}`);
-        });
-```
-**BlinkID DirectAPI**
-1. Set all of the necessary BlinkID settings (SDK settings, session settings, and the scanning settings). If the mentioned settings are not modified, the default values will be used:
+### <a name="blinkid-directapi-static-images"></a> BlinkID DirectAPI (static images)
+
+DirectAPI extracts data from Base64-encoded static images instead of using the camera UI.
+
+- Pass **two images** with `scanningMode: 'automatic'` (front side first, back side second).
+- Pass **one image** with `scanningMode: 'single'`.
+- Set `documentCaptureModule.cropType` to `"cropped"` when images are already cropped and perspective-corrected, or `"unknown"` when cropping is uncertain. Use `"not-cropped"` for raw photos.
+
 ```typescript
+const firstImageBase64 = 'your-base64-image';
+const secondImageBase64 = 'your-base64-image'; // optional for single-side
+
+try {
+  const result = await performDirectApiScan({
+    sdkSettings: {
+      licenseKey,
+      resourcesConfig: { download: true },
+    },
+    sessionSettings: {
+      scanningMode: 'automatic',
+      scanningSettings: {
+        documentCaptureModule: {
+          documentImageReturnEnabled: true,
+          cropType: 'not-cropped', // or 'cropped' / 'unknown' for DirectAPI
+        },
+        mrzModule: {},
+        barcodeModule: {
+          pdf417ScanningEnabled: true,
+          qrScanningEnabled: true,
+          aztecScanningEnabled: false,
+        },
+        vizModule: {},
+      },
+    },
+    firstImage: firstImageBase64,
+    secondImage: secondImageBase64,
+    // redactionSettings, // optional — see Document redaction
+  });
+
+  console.log(result.fullName?.value);
+} catch (error) {
+  console.log(`Error during scan: ${error}`);
+}
+```
+
+### <a name="document-redaction"></a> Document redaction
+
+Anonymization was renamed to **redaction** in v8000. For camera scanning, use a `RedactionSettingsResolver` to apply per-document redaction rules. For DirectAPI, pass a single `RedactionSettings` object.
 
-      /**
-       * Set the BlinkID SDK settings
-       * Add the license key here from the code above
-       */
-      const sdkSettings = new BlinkIdSdkSettings(licenseKey);
-      sdkSettings.downloadResources = true;
-
-      /**
-       * Create and modify the Session Settings
-       */
-      const sessionSettings = new BlinkIdSessionSettings();
-
-      /**
-       * Important: if two images are being passed, use the `Automatic` 
-       * scanning mode
-       * if just one image is being passed, use the `Single` scanning mode.
-      */
-      sessionSettings.scanningMode = ScanningMode.Automatic;
-
-      /**
-       * Create and modify the scanning settings
-       */
-      const scanningSettings = new BlinkIdScanningSettings();
-      scanningSettings.glareDetectionLevel = DetectionLevel.Mid;
-      /**
-       * if the input images consist solely 
-       * of the cropped document image, set the 
-       * `scanCroppedDocumentImage` to true.
-       */
-      // scanningSettings.scanCroppedDocumentImage = true;
-
-      /**
-       * Create and modify the Image settings
-       */
-      const croppedImageSettings = new CroppedImageSettings();
-      croppedImageSettings.returnDocumentImage = true;
-      croppedImageSettings.returnFaceImage = true;
-      croppedImageSettings.returnSignatureImage = true;
-      /**
-       * Place the image settings in the scanning settings
-       */
-      scanningSettings.croppedImageSettings = croppedImageSettings;
-
-      /**
-       * Place the scanning settings in the session settings
-       */
-      sessionSettings.scanningSettings = scanningSettings;
-
-      /**
-       * Add the Base64 string of the first side of the document
-       */
-      const firstImageBase64 = "your-base64-image";
-
-      /**
-       * Add the Base64 string of the second side of the document
-       * This paramater is optional if only one side 
-       * of the document is requred.
-       */
-      const secondImageBase64 = "your-base64-image";
-```
-
-2. Call the `performDirectApiScan` scanning method, handle the results and catch any errors:
 ```typescript
-      /**
-       * Call the `performDirectApiScan` method, 
-       * where the SDK and session settings need to be passed,
-       *  along with the Base64 images.
-       */
-      await performDirectApiScan(
-        sdkSettings,
-        sessionSettings,
-        firstImageBase64,
-        secondImageBase64
-      )
-        .then((result: BlinkIdScanningResult) => {
-          //handle the results here.
-          console.log(result.firstName?.value);
-        })
-        .catch((error) => {
-          // handle any errors here.
-          console.log(`Error during scan: ${error}`);
-        });
-```
-**Note:**
-- The whole integration process can be found in the sample app `App.tsx` file [here](https://github.com/BlinkID/blinkid-react-native/blob/master/sample_files/App.tsx).
-- The settings and the results that can be used with the BlinkID plugin can be found in the paragraphs below, but also in the comments of each BlinkID TS file.
+import { FieldType, CountryID, RegionID, DocumentTypeID, type RedactionSettingsResolver } from '@microblink/blinkid-react-native';
+
+const redactionSettingsResolver: RedactionSettingsResolver = {
+  documentRedactionList: [
+    {
+      mode: 'fullResult',
+      fields: [FieldType.FirstName, FieldType.LastName],
+      documentNumberRedactionSettings: {
+        prefixDigitsVisible: 0,
+        suffixDigitsVisible: 1,
+      },
+      redactMrzResult: false,
+      redactBarcodeResult: false,
+      documentFilter: {
+        country: CountryID.USA,
+        region: RegionID.California,
+        documentType: DocumentTypeID.Id,
+      },
+    },
+  ],
+};
+
+// Camera scanning — pass redactionSettingsResolver to performScan
+await performScan({ sdkSettings, sessionSettings, redactionSettingsResolver });
+
+// DirectAPI — pass redactionSettings to performDirectApiScan
+await performDirectApiScan({
+  sdkSettings,
+  sessionSettings,
+  firstImage: firstImageBase64,
+  redactionSettings: {
+    mode: 'fullResult',
+    fields: [FieldType.DocumentNumber],
+    redactMrzResult: false,
+    redactBarcodeResult: false,
+  },
+});
+```
+
+Redaction modes: `none`, `imageOnly`, `resultFieldsOnly`, `fullResult`.
 
 ## <a name="plugin-specifics"></a> Plugin specifics
-The BlinkID plugin implementation is located in the `src` folder [here](https://github.com/BlinkID/blinkid-react-native/tree/master/BlinkID/src), while platform-specific implementation is located in the `android` and `ios` folders.
+The BlinkID plugin implementation is located in the `src` folder [here](https://github.com/microblink/blinkid-react-native/tree/master/BlinkID/src), while platform-specific implementation is located in the `android` and `ios` folders.
 
 ### <a name="scanning-methods"></a> Scanning methods
-Currently, the BlinkID plugin contains the two main methods of scanning: `performScan` and `performDirectApiScan`.
+Currently, the BlinkID plugin contains two main scanning methods: `performScan` and `performDirectApiScan`.
 
 **The `performScan` method**
 
-The `performScan` method launches the BlinkID scanning process with the default UX properties.\
-It takes the following parameters: 
-1. BlinkID SDK settings
-2. BlinkID session settings
-4. The optional BlinkID UI settings for UI customization.
-3. The optional ClassFilter object for filtering documents.
-
-**BlinkID SDK Settings** - `BlinkIdSdkSettings`: the class that contains all of the available SDK settings. It contains settings for the license key, and how the models, that the SDK needs for the scanning process, should be obtained.
+Launches the BlinkID scanning process with the default UX.
 
-**BlinkID Session Settings** - `BlinkIdSessionSettings`: the class that contains various settings for the scanning session. It contains the settings for the `ScanningMode` and `BlinkIdScanningSettings`, which define various parameters that control the scanning process.
+Recommended call style — single settings object:
 
-**BlinkID UI Settings** - `BlinkIdUiSettings`: the class that allows customization of various aspects of the UI used during the scanning process.
+```typescript
+performScan({
+  sdkSettings,           // BlinkIdSdkSettings (required)
+  sessionSettings,       // BlinkIdSessionSettings (required)
+  scanningUxSettings,    // BlinkIdScanningUxSettings (optional)
+  classFilter,           // ClassFilter (optional)
+  redactionSettingsResolver, // RedactionSettingsResolver (optional)
+});
+```
 
-The optional **ClassFilter** class - `ClassFilter`: the class which controls which documents will be accepted or reject for information extraction during the scanning session.
+| Parameter | Description |
+| --- | --- |
+| `sdkSettings` | License key, `resourcesConfig`, optional `otaResourcesConfig`, proxy URL |
+| `sessionSettings` | Scanning mode, module settings, timeouts |
+| `scanningUxSettings` | Help button, onboarding dialog, haptic feedback, preferred camera |
+| `classFilter` | Include/exclude documents by country, region, and type |
+| `redactionSettingsResolver` | Per-document redaction rules applied before the result is finalized |
 
-- The implementation of the `performScan` method can be viewed here in the [index.tsx](https://github.com/BlinkID/blinkid-react-native/blob/master/BlinkID/src/index.tsx) file.
+Returns `BlinkIdScanningResult` ([implementation](https://github.com/microblink/blinkid-react-native/blob/master/BlinkID/src/index.tsx)).
 
 **The `performDirectApiScan` method**
 
-The `performDirectApiScan` method launches the BlinkID scanning process intended for information extraction from static images.\
-It takes the following parameters: 
-1. BlinkID SDK settings
-2. BlinkID session settings
-3. First image string in the Base64 format
-4. The optional second image string in the Base64 format
+Extracts document information from static Base64 images.
 
-**BlinkID SDK Settings** - `BlinkIdSdkSettings`: the class that contains all of the available SDK settings. It contains settings for the license key, and how the models, that the SDK needs for the scanning process, should be obtained.
+```typescript
+performDirectApiScan({
+  sdkSettings,        // BlinkIdSdkSettings (required)
+  sessionSettings,    // BlinkIdSessionSettings (required)
+  firstImage,         // Base64 string (required)
+  secondImage,        // Base64 string (optional)
+  redactionSettings,  // RedactionSettings (optional)
+});
+```
 
-**BlinkID Session Settings** - `BlinkIdSessionSettings`: the class that contains various settings for the scanning session. It contains the settings for the `ScanningMode` and `BlinkIdScanningSettings`, which define various parameters that control the scanning process.
+Returns `BlinkIdScanningResult` ([implementation](https://github.com/microblink/blinkid-react-native/blob/master/BlinkID/src/index.tsx)).
 
-The first image Base64 string - `String`: image that represents one side of the document. If the document contains two sides and the `ScanningMode` is set to `automatic`, this should contain the image of the front side of the document. In case the `ScanningMode` is set to `single`, it can be either the front or the back side of the document. If the document contains only one side (for example, various passports), the SDK will automatically detect it, and will not look for the other side.
+### <a name="sdk-loading--unloading"></a> SDK loading & unloading
 
-The optional second image Base64 string - `String`: needed if the information from back side of the document is required and the `ScanningMode` is set to `automatic`.
 
-- The implementation of the `performDirectApiScanning` method can be viewed here in the [index.tsx](https://github.com/BlinkID/blinkid-react-native/blob/master/BlinkID/src/index.tsx) file.
+**The `loadBlinkIdSdk` method**
 
-### <a name="sdk-loading--unloading"></a> SDK loading & unloading
-The BlinkID SDK also contains methods for loading and unloading. These methods can be called before the scanning methods (mentioned above), and are helpful to preload the neccessary resources and decrease the waiting time for the scanning session, but also to remove any resources after the scanning sessions ends.
+Creates or retrieves the BlinkID SDK instance. Handles initialization, resource downloading, and license verification. Call in advance to reduce first-scan latency.
 
-**The `loadBlinkIdSdk` method**
+```typescript
+await loadBlinkIdSdk({
+  sdkSettings: {
+    licenseKey,
+    resourcesConfig: { download: true },
+  },
+});
+```
 
-The `loadBlinkIdSdk` method creates or retrieves the instance of the BlinkID SDK It initializes and loads the BlinkID SDK if it is not already loaded.
+If you do not call `loadBlinkIdSdk`, it is invoked automatically when a scan starts.
 
-It can be called in advance to **preload** the SDK before starting a scanning session. Doing so reduces loading time for the `performScan` and `performDirectApiScan` methods, since all resources will already be available and the license verified.
+**The `unloadBlinkIdSdk` method**
 
-If the method is not called beforehand, it will still be automatically invoked on the native platform channels when a scan starts. However, the initial scan may take longer due to resource loading and license checks.
+Terminates the SDK and releases resources. Must reinitialize before the next scan.
 
-It takes the following parameter: [BlinkIdSdkSettings](#blinkid-settings), which is explained in more details below.
+```typescript
+await unloadBlinkIdSdk({ deleteCachedResources: false });
+```
 
-**The `unloadBlinkIdSdk` method**
+Set `deleteCachedResources` to `true` to also delete downloaded and cached SDK resources from the device.
 
-The `unloadBlinkIdSdk` platform method terminates the BlinkID SDK and releases all associated resources. It safely shuts down the SDK instance and frees any allocated memory.
-After calling this method, you must reinitialize the SDK (by calling `loadBlinkIdSdk` or any of the scanning methods) before using it again.
+`unloadBlinkIdSdk` is called automatically after each successful scan session.
 
-If set to `true` (`false` is default), the method performs a **complete cleanup**, including deletion of all downloaded and cached SDK resources from the device.
+**The `refreshLicenseLease` method**
 
-This method is automatically called after each successful scan session.
+Refreshes the SDK license lease. Can be called periodically to maintain an active license status; the required frequency depends on your license configuration. The SDK must already be initialized (via `loadBlinkIdSdk` or a scan) before calling this method.
+
+```typescript
+await refreshLicenseLease();
+```
 
 ### <a name="blinkid-settings"></a> BlinkID Settings
-The BlinkID SDK contains various settings, modifying different parts of scanning process:
-1. [BlinkID SDK settings](https://github.com/BlinkID/blinkid-react-native/blob/master/BlinkID/src/blinkIdSettings.ts#L14) - `BlinkIdSdkSettings` \
-These settings are used for the initialization of the BlinkID SDK.
 
-2. [BlinkID session settings](https://github.com/BlinkID/blinkid-react-native/blob/feature/blinkid-v7/BlinkID/src/blinkIdSettings.ts#L92) - `BlinkIdSessionSettings`\
-These settings represent the configuration settings for a scanning session.\
-This class holds the settings related to the resources initialization, scanning mode, and specific scanning configurations that define how the scanning session should behave.
+| Setting | Type | Description |
+| --- | --- | --- |
+| SDK settings | `BlinkIdSdkSettings` | License key, nested `resourcesConfig` / `otaResourcesConfig`, proxy URL |
+| Session settings | `BlinkIdSessionSettings` | Scanning mode, module settings, step/inactivity timeouts (ms; `0` disables) |
+| Scanning settings | `BlinkIdScanningSettings` | Module configuration (see below) |
+| UX settings | `BlinkIdScanningUxSettings` | UI customization during scanning |
+| Class filter | `ClassFilter` | Document include/exclude rules (`CountryID` / `RegionID` / `DocumentTypeID`) |
+| Redaction | `RedactionSettings` / `RedactionSettingsResolver` | Field and image redaction |
+
+**SDK resource settings** (`BlinkIdSdkSettings`)
+
+| Field | Description |
+| --- | --- |
+| `resourcesConfig` | Base ML resource download/cache (`download`, `serviceUrl`, `localFolder`, `requestTimeout` as [`RequestTimeout`](BlinkID/src/blinkIdSettings.ts), iOS `bundleIdentifier`) |
+| `otaResourcesConfig` | OTA document resources (`checkForUpdates`, `strict`, `serviceUrl`, `localFolder`, …). Optional; native defaults apply when omitted |
+
+Do not cross-wire base and OTA hosts: base defaults to `https://models.cdn.microblink.com/resources`; OTA defaults to `https://blinkid-ota.microblink.com`.
+
+**Scanning module settings**
+
+| Module | Type | Key settings |
+| --- |  | --- |
+| Document capture | `DocumentCaptureModuleSettings` | `cropType`, `inputImageSelectionStrategy`, image quality, image return, face extraction, passport data page only |
+| MRZ | `MrzModuleSettings` | `presenceMandatory` |
+| Barcode | `BarcodeModuleSettings` | PDF417, QR, Aztec, retail barcode types, barcode image return |
+| VIZ | `VizModuleSettings` | Signature extraction, character validation, result aggregation |
+
+The [blinkIdSettings.ts](https://github.com/microblink/blinkid-react-native/blob/master/BlinkID/src/blinkIdSettings.ts) and [types.ts](https://github.com/microblink/blinkid-react-native/blob/master/BlinkID/src/types.ts) files contain all available settings with inline documentation.
+
+### <a name="blinkid-results"></a> BlinkID Results
+
+The scanning result is stored in `BlinkIdScanningResult`. It contains extracted data and images from the document.
+
+Key result members:
+
+1. **Document class info** — `documentClassInfo` (`DocumentClassInfo`) with nested `country` / `region` / `documentType` as `{ id?, rawValue }`
+2. **Data match information** — `dataMatchResult` (`DataMatchResult`)
+3. **Per-side results** — `subResults` (`SingleSideScanningResult[]`) — contains VIZ, MRZ, and barcode data per side
+4. **Aggregated fields** — top-level fields such as `firstName`, `lastName`, `documentNumber`, `ethnicity`, `parentsInfo`, etc.
+5. **Images** — `firstDocumentImage`, `secondDocumentImage`, `faceImage`, `signatureImage`, `firstInputImage`, `secondInputImage`, `barcodeImage`
 
-3. [BlinkID scanning settings](https://github.com/BlinkID/blinkid-react-native/blob/master/BlinkID/src/blinkIdSettings.ts#L141) - `BlinkIdScanningSettings`\
-These settings represent the configurable settings for scanning a document.`
-This class defines various parameters and policies related to the scanning process, including image quality handling, data extraction and anonymization, along with options for frame processing and image extraction.
+Each `SingleSideScanningResult` contains:
+- `viz` — Visual Inspection Zone data (includes `ethnicity` when available)
+- `mrz` — Machine Readable Zone data
+- `barcode` — Barcode data
+- `documentImage`, `faceImage`, `signatureImage`, `inputImage`
 
-4. [BlinkID UI settings](https://github.com/BlinkID/blinkid-react-native/blob/master/BlinkID/src/blinkIdSettings.ts#L468) - `BlinkIdUiSettings`\
-Allows customization of various aspects of the UI used during the scanning process.
 
-5. [Cropped image settings](https://github.com/BlinkID/blinkid-react-native/blob/master/BlinkID/src/blinkIdSettings.ts#L468) - `CroppedImageSettings`\
-These settings represent the image cropping settings.
+Full result types: [blinkIdResult.ts](https://github.com/microblink/blinkid-react-native/blob/master/BlinkID/src/blinkIdResult.ts) and [types.ts](https://github.com/microblink/blinkid-react-native/blob/master/BlinkID/src/types.ts).
 
-**Additional notes:**
+## <a name="whats-new-in-v8001"></a> What's new in v8001
 
-- The [blinkIdSettings.ts](https://github.com/BlinkID/blinkid-react-native/blob/master/BlinkID/src/blinkIdSettings.ts) and [types.ts](https://github.com/BlinkID/blinkid-react-native/blob/master/BlinkID/src/types.ts) files contains all the settings that can be modified and explains what each setting does in more detail.
+BlinkID v8001 builds on the modular architecture from v8000 with faster document support (including OTA resources), better frame selection, DirectAPI crop handling, Aztec barcodes, and nested document class info.
 
-- The native documentation for the above mentioned settings can be found here for [Android](https://blinkid.github.io/blinkid-android/blinkid-core/com.microblink.blinkid.core/index.html) & [iOS](https://blinkid.github.io/blinkid-swift-package/documentation/blinkid/).
+Highlights for React Native:
 
-- The native Kotlin & Swift implementation of all BlinkID settings can be found here for [Android](https://github.com/BlinkID/blinkid-react-native/blob/master/BlinkID/android/src/main/java/com/blinkidreactnative/BlinkIdDeserializationUtilities.kt) & [iOS](https://github.com/BlinkID/blinkid-react-native/blob/master/BlinkID/ios/BlinkIdDeserializationUtilities.swift) in the BlinkID deserialization utilities.
+| Area | Change |
+| --- | --- |
+| **SDK settings** | Flat resource fields → nested `resourcesConfig`; new optional `otaResourcesConfig` |
+| **Document class info** | `country` / `region` / `documentType` are `{ id?, rawValue }` (filters still use flat `CountryID` / `RegionID` / `DocumentTypeID`) |
+| **Document capture** | `inputImageCropped` → `cropType`; added `inputImageSelectionStrategy` |
+| **Barcode** | `aztecScanningEnabled` |
+| **Results** | `ethnicity`; `ParentInfo.fullName`; `FieldType.Ethnicity` / `ParentFullName` |
 
-### <a name="blinkid-result"></a> BlinkID Results
+#### Migrating SDK settings from v8000
 
-The result of the scanning process is stored in the `BlinkIdScanningResult`. It contains the results of scanning a document, including the extracted data and images from the document.
+```typescript
+// v8000
+const sdkSettings = { licenseKey, downloadResources: true };
+
+// v8001
+const sdkSettings: BlinkIdSdkSettings = {
+  licenseKey,
+  resourcesConfig: { download: true },
+  otaResourcesConfig: {
+    checkForUpdates: true, // default
+    strict: false,         // default — set true to fail init on OTA download errors
+  },
+};
+```
+
+| v8000 (flat) | v8001 |
+| --- | --- |
+| `downloadResources` | `resourcesConfig.download` |
+| `resourceDownloadUrl` | `resourcesConfig.serviceUrl` |
+| `resourceLocalFolder` | `resourcesConfig.localFolder` |
+| `resourceRequestTimeout` | `resourcesConfig.requestTimeout` ([`RequestTimeout`](BlinkID/src/blinkIdSettings.ts), milliseconds) |
+| `bundleIdentifier` | `resourcesConfig.bundleIdentifier` (iOS) |
+
+Do **not** cross-wire hosts: base resources use `https://models.cdn.microblink.com/resources`; OTA uses `https://blinkid-ota.microblink.com`.
+
+#### Resource download timeouts
+
+`resourcesConfig.requestTimeout` and `otaResourcesConfig.requestTimeout` accept a [`RequestTimeout`](BlinkID/src/blinkIdSettings.ts) object (milliseconds). Omit `requestTimeout` to use native defaults (30 seconds per timeout on current BlinkID native SDKs). Omit individual fields inside `requestTimeout` to keep the native default for that timeout.
+
+```typescript
+resourcesConfig: {
+  download: true,
+  requestTimeout: {
+    connectionTimeoutMilliseconds: 30000,
+    writeTimeoutMilliseconds: 30000,
+    readTimeoutMilliseconds: 30000,
+  },
+},
+
+otaResourcesConfig: {
+  requestTimeout: {
+    connectionTimeoutMilliseconds: 30000,
+    readTimeoutMilliseconds: 60000,
+  }, // write timeout uses native default when omitted
+},
+```
+
+#### Migrating document capture settings
+
+```typescript
+// v8000
+documentCaptureModule: { inputImageCropped: true }
+
+// v8001 — DirectAPI only for cropped/unknown
+documentCaptureModule: { cropType: 'cropped' } // or 'unknown' | 'not-cropped'
+```
+
+Camera UX (`performScan`) must use `cropType: 'not-cropped'`.
+
+#### Document class info in results
+
+```typescript
+const countryId = result.documentClassInfo?.country?.id;       // CountryID when known
+const countryRaw = result.documentClassInfo?.country?.rawValue; // always set when country present
+```
+
+Full changelog (documents, bug fixes, API details): [Release notes.md](https://github.com/microblink/blinkid-react-native/blob/master/Release%20notes.md) and [platform release notes](https://docs.microblink.com/blinkid/release-notes).
+
+## <a name="whats-new-in-v8000"></a> What's new in v8000
+
+BlinkID v8000 introduces a **modular recognition architecture**. Instead of flat scanning settings and fallback recognition modes, extraction is driven by four independent modules that you enable and configure separately:
+
+| Module | Purpose |
+| --- | --- |
+| **Document capture** | Document detection, image quality checks (blur, glare, tilt, lighting), and cropped image extraction |
+| **MRZ** | Machine Readable Zone detection and parsing (passports, visas, ID cards) |
+| **Barcode** | 1D/2D barcode detection and parsing (PDF417, QR, retail codes, and more) |
+| **VIZ** | Visual Inspection Zone field extraction, character validation, and signature images |
+
+Other notable changes:
+
+- Settings are **plain TypeScript objects** (no class constructors).
+- Scanning methods accept a **single settings object** (recommended) or legacy positional arguments.
+- **Anonymization** has been renamed to **redaction** (`RedactionSettings`, `RedactionSettingsResolver`).
+- Image return and quality settings moved from `CroppedImageSettings` into `documentCaptureModule` and `vizModule`.
+- Detection levels (`DetectionLevel`) are replaced by **sensitivity levels** (`SensitivityLevel`: `off`, `low`, `mid`, `high`).
+- Scanning sessions include **step** and **inactivity timeouts** on `BlinkIdSessionSettings` (milliseconds; defaults `60000` and `10000`). Set either to `0` to disable.
+
+### <a name="migrating-from-v7x"></a> Migrating from v7.x
+
+If you are upgrading from `@microblink/blinkid-react-native@7.x` (e.g. 7.7.0), the following changes apply.
 
-Along with the information scanned from the document, the BlinkID also provides additional details that was obtained during the scanning process:
+#### Settings are plain objects
 
-1. **Recognition mode**- `RecognitionMode`\
-Scanning mode used to scan the current document.
+```typescript
+// v7
+const sdkSettings = new BlinkIdSdkSettings(licenseKey);
+sdkSettings.downloadResources = true;
+
+// v8000 (flat resource fields)
+const sdkSettings = { licenseKey, downloadResources: true };
+
+// v8001 (nested resources — preferred)
+const sdkSettings = {
+  licenseKey,
+  resourcesConfig: { download: true },
+};
+```
+
+#### Modular scanning settings
 
-2. **Document class info** - `DocumentClassInfo`\
-The document class information.
+Flat v7 settings map to module settings in v8000 (still valid in v8001; use `cropType` instead of `inputImageCropped`):
 
-3. **Data match informatoin** - `DataMatchResult`\
-Info on whether the data extracted from multiple sides matches.
+| v7                                                | v8000 / v8001                                          |
+|---------------------------------------------------|--------------------------------------------------------|
+| `blurDetectionLevel`                              | `documentCaptureModule.blurSensitivityLevel`           |
+| `glareDetectionLevel`                             | `documentCaptureModule.glareSensitivityLevel`          |
+| `tiltDetectionLevel`                              | `documentCaptureModule.tiltSensitivityLevel`           |
+| `skipImagesWithBlur`                              | `documentCaptureModule.imageWithBlurRejected`          |
+| `skipImagesWithGlare`                             | `documentCaptureModule.imageWithGlareRejected`         |
+| `croppedImageSettings.returnDocumentImage`        | `documentCaptureModule.documentImageReturnEnabled`     |
+| `croppedImageSettings.returnFaceImage`            | `documentCaptureModule.faceImageExtractionEnabled`     |
+| `croppedImageSettings.returnSignatureImage`       | `vizModule.signatureImageExtractionEnabled`            |
+| `croppedImageSettings.dotsPerInch`                | `documentCaptureModule.dotsPerInch`                    |
+| `scanCroppedDocumentImage`                        | `documentCaptureModule.cropType` (`"cropped"` / `"not-cropped"` / `"unknown"`) |
+| `enableCharacterValidation`                       | `vizModule.characterValidationEnabled`                 |
+| `scanPassportDataPageOnly`                        | `documentCaptureModule.passportDataPageScanOnly`       |
+| `anonymizationMode`                               | Use `RedactionSettings` / `RedactionSettingsResolver`  |
+| `recognitionModeFilter` / `enableBarcodeScanOnly` | Enable/disable modules explicitly                      |
 
-4. **Singleside scanning result** - `SingleSideScanningResult`\
-Represents the result of scanning a single side of the document.\
-Contains the data extracted from the Visual Inspection Zone, Machine Readable Zone, barcode, the input image, and the cropped document, face, and signature images.
+Removed types: `CroppedImageSettings`, `AnonymizationMode`, `DetectionLevel`, `RecognitionMode`.
 
-5. **Detailed cropped image result** - `DetailedCroppedImageResult`\
-Represents the result of the image crop transformation with additional details.
+#### Method call style
+
+```typescript
+// v7 — positional arguments
+await performScan(sdkSettings, sessionSettings, uxSettings, classFilter);
 
-**Additional notes:**
+// v8000 / v8001 — recommended object style
+await performScan({ sdkSettings, sessionSettings, scanningUxSettings: uxSettings, classFilter });
+```
+
+```typescript
+// unload API
+await unloadBlinkIdSdk({ deleteCachedResources: false });
+```
 
-- The [blinkIdResult.ts](https://github.com/BlinkID/blinkid-react-native/blob/master/BlinkID/src/blinkIdResult.ts) and [types.ts](https://github.com/BlinkID/blinkid-react-native/blob/master/BlinkID/src/types.ts) files contain all the results after the scanning process finishes.
+BlinkID Android SDK requires Kotlin v2.2.21+. See [Android setup](#android-setup) for more details.
 
-- The native documentation for the above mentioned results can be found here for [Android](https://blinkid.github.io/blinkid-android/blinkid-core/com.microblink.blinkid.core.result/index.html) & [iOS](https://blinkid.github.io/blinkid-swift-package/documentation/blinkid/blinkidscanningresult).
+After migrating from v7 to the modular API, also apply [What's new in v8001](#whats-new-in-v8001) (nested `resourcesConfig` / OTA, `cropType`, nested class info).
 
-- The native Kotlin & Swift implementation of all BlinkID settings can be found here for [Android](https://github.com/BlinkID/blinkid-react-native/blob/master/BlinkID/android/src/main/java/com/blinkidreactnative/BlinkIdSerializationUtilities.kt) & [iOS](https://github.com/BlinkID/blinkid-react-native/blob/master/BlinkID/ios/BlinkIdSerializationUtilities.swift) in the BlinkID deserialization utilities.
+For the complete native migration guide from v7, see [Migrate to v8000](https://docs.microblink.com/blinkid/migration-v8000).
 
 ## <a name="additional-information-and-support"></a> Additional information and Support
-For any additional questions and information, feel free to contact us [here](https://help.microblink.com), or directly to the Support team via mail support@microblink.com.
+For any additional questions and information, feel free to contact us [here](https://help.microblink.com), or directly to the Support team at support@microblink.com.