freeRASP React Native

https://github.com/talsec/free-rasp-reactnative
Admin
freeRASP React Native is a mobile in-app protection and security monitoring plugin that provides...
Tokens:33,222
Snippets:279
Trust Score:9.1
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install iOS Pods

Source: https://github.com/talsec/free-rasp-reactnative/wiki/Home

Navigate to the `ios` directory in your React Native project and run `pod install` to set up the necessary dependencies for iOS.

```bash
pod install
```

--------------------------------

### Imperative threat listener initialization

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/listeners.md

Example of manual listener setup and teardown for non-hook environments. Repeated calls to setThreatListeners replace existing subscriptions due to module-level singletons.

```ts
import { setThreatListeners, removeThreatListener } from 'freerasp-react-native';

await setThreatListeners({
  debug: () => console.warn('Debugger detected'),
  malware: (apps) => console.warn(`Malware: ${apps.length}`),
});

// ... later, when tearing down:
await removeThreatListener();
```

--------------------------------

### Basic start and screen capture control

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-methods.md

Demonstrates initializing the library with talsecStart, toggling screen capture blocking, and managing external IDs.

```ts
import {
  talsecStart,
  blockScreenCapture,
  isScreenCaptureBlocked,
  storeExternalId,
  removeExternalId,
} from 'freerasp-react-native';

const response = await talsecStart({
  iosConfig: { appBundleId: 'com.example.app', appTeamId: 'team_id' },
  watcherMail: 'dev@example.com',
  isProd: false,
});
// response === 'freeRASP started'

await blockScreenCapture(true);
const blocked = await isScreenCaptureBlocked(); // true

await storeExternalId('user-42');
// later:
await removeExternalId();
```

--------------------------------

### talsecStart Method

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-methods.md

Initializes the RASP security features using the provided configuration. Returns a promise that resolves to 'freeRASP started' on success.

```ts
export const talsecStart = async (options: TalsecConfig): Promise<string> => {
  return FreeraspReactNative.talsecStart(withDefaults(options));
};
```

--------------------------------

### Initialize freeRASP in Class Component Constructor

Source: https://github.com/talsec/free-rasp-reactnative/wiki/Home

Set up threat listeners and start freeRASP by calling `setThreatListeners` and `talsecStart` within the constructor of your app's entry point class component. Ensure `actions` and `config` are defined.

```typescript
constructor(props) {
  super(props);

  // Add these method calls
  setThreatListeners(actions);
  talsecStart(config);
}
```

--------------------------------

### Log TalsecInitializationError in useFreeRasp

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/errors.md

Example of how the TalsecInitializationError is caught and logged within the useFreeRasp hook.

```typescript
console.error(`${e.code}: ${e.message}`)
```

--------------------------------

### Install freeRASP React Native Plugin

Source: https://github.com/talsec/free-rasp-reactnative/wiki/Home

Use npm or yarn to add the freeRASP React Native package to your project dependencies.

```bash
npm install freerasp-react-native
```

```bash
yarn add freerasp-react-native
```

--------------------------------

### TalsecConfig object structure

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/configuration.md

The full TalsecConfig object as implemented in the example application, defining Android and iOS security configurations, watcher email, and production flags.

```ts
const config: TalsecConfig = {
  androidConfig: {
    packageName: 'com.freeraspreactnativeexample',
    certificateHashes: ['AKoRuyLMM91E7lX/Zqp3u4jMmd0A7hH/Iqozu0TMVd0='],
    suspiciousAppDetectionConfig: {
      packageNames: ['com.freeraspreactnativeexample'],
      hashes: ['FgvSehLMM91E7lX/Zqp3u4jMmd0A7hH/Iqozu0TMVd0u'],
      requestedPermissions: [
        ['android.permission.INTERNET', 'android.permission.ACCESS_COARSE_LOCATION'],
        ['android.permission.BLUETOOTH'],
        ['android.permission.BATTERY_STATS'],
      ],
      grantedPermissions: [['android.permission.ACCESS_FINE_LOCATION']],
      scanScope: {
        scopeType: 'SIDELOADED_AND_SYSTEM_EXCLUDE_OEM',
        trustedInstallSources: ['com.apkpure.aegon'],
      },
      reasonMode: 'HIGHEST_CONFIDENCE',
    },
  },
  iosConfig: {
    appBundleId: 'org.reactjs.native.example.FreeraspReactNativeExample',
    appTeamId: 'your_team_ID',
  },
  watcherMail: 'your_email_address@example.com',
  isProd: true,
  killOnBypass: true,
};
```

--------------------------------

### ScanScope Definition

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/types.md

Configures the scope of the scan and optional trusted installation sources.

```ts
export type ScanScope = {
  scopeType: ScopeType;
  trustedInstallSources?: string[];
};
```

--------------------------------

### useFreeRasp(config, actions, raspExecutionStateActions)

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/useFreeRasp.md

Initializes the RASP engine with the provided configuration and sets up event listeners for threat detection and execution state changes.

```APIDOC
## useFreeRasp(config, actions, raspExecutionStateActions)

### Description
This React hook wires user-provided threat callbacks to native event channels, starts the RASP engine with the supplied configuration, and cleans up listeners when the component unmounts.

### Parameters
- **config** (TalsecConfig) - Required - Full RASP configuration including androidConfig, iosConfig, watcherMail, isProd, and killOnBypass.
- **actions** (ThreatEventActions) - Required - Callback map fired when threats are detected (e.g., privilegedAccess, debug, simulator).
- **raspExecutionStateActions** (RaspExecutionStateEventActions) - Optional - Callback map for RASP lifecycle events, such as allChecksFinished.
```

--------------------------------

### talsecStart

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-methods.md

Initializes the freeRASP security module with the provided configuration.

```APIDOC
## talsecStart

### Description
Initializes the freeRASP security module. This function is a proxy to the native module and requires a configuration object.

### Method
Async Function

### Parameters
- **options** (TalsecConfig) - Required - RASP configuration object. If `scanScope.scopeType` or `reasonMode` are omitted, they default to 'SIDELOADED_ONLY' and 'HIGHEST_CONFIDENCE' respectively.

### Returns
- **Promise<string>** - Resolves to 'freeRASP started' on success.

### Errors
- **TalsecInitializationError** (iOS) - Rejects if required configuration fields like `iosConfig`, `appBundleId`, `appTeamId`, or `watcherMail` are missing.
```

--------------------------------

### Catching freeRASP initialization and platform errors

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/errors.md

Demonstrates using try-catch blocks to handle initialization errors from talsecStart and implementing a guard function to catch errors from platform-specific native methods.

```ts
import { talsecStart, addToWhitelist, getAppIcon, blockScreenCapture, isScreenCaptureBlocked } from 'freerasp-react-native';

try {
  const response = await talsecStart({ watcherMail: 'a@b.c', iosConfig: { appBundleId: 'com.x', appTeamId: 't' } });
  if (response !== 'freeRASP started') {
    // Native contract failure — the app has already been aborted by onInvalidCallback.
  }
} catch (error: any) {
  // iOS: { code: 'TalsecInitializationError', message: 'Could not initialize freeRASP: <domain>' }
  console.error(`Init failed ${error.code}: ${error.message}`);
}

// iOS platform guards + native widget errors:
const guarded = async (fn: () => Promise<unknown>) => {
  try {
    return await fn();
  } catch (error: any) {
    console.error(error?.code ?? error); // string rejections have no .code
    return null;
  }
};

await guarded(() => addToWhitelist('com.app'));          // Android only
await guarded(() => getAppIcon('com.app'));              // Android only
await guarded(() => blockScreenCapture(true));           // BlockScreenCaptureError
await guarded(() => isScreenCaptureBlocked());           // IsScreenCaptureBlockedError
```

--------------------------------

### Basic useFreeRasp implementation

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/useFreeRasp.md

Initializes freeRASP with a configuration object and threat event callbacks.

```tsx
import { useFreeRasp, type TalsecConfig, type ThreatEventActions } from 'freerasp-react-native';

const config: TalsecConfig = {
  androidConfig: {
    packageName: 'com.example.myapp',
    certificateHashes: ['AKoRuyLMM91E7lX/Zqp3u4jMmd0A7hH/Iqozu0TMVd0='],
  },
  iosConfig: {
    appBundleId: 'org.reactjs.native.example.MyApp',
    appTeamId: 'your_team_ID',
  },
  watcherMail: 'security-team@example.com',
  isProd: true,
  killOnBypass: true,
};

const actions: ThreatEventActions = {
  privilegedAccess: () => {
    console.warn('Privileged access / root detected');
  },
  debug: () => {
    console.warn('Debugger detected');
  },
  hooks: () => {
    console.warn('Hooking framework detected');
  },
  // ...all other optional callbacks
};

useFreeRasp(config, actions);
```

--------------------------------

### Initialize Talsec and block screen capture

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-module.md

Initializes the Talsec security module with required configuration and enables screen capture blocking.

```ts
import { NativeEventEmitter } from 'react-native';
// FreeraspReactNative is internal; application code uses the public methods instead:
import { talsecStart, blockScreenCapture } from 'freerasp-react-native';

await talsecStart({ watcherMail: 'a@b.c', iosConfig: { appBundleId: 'com.x', appTeamId: 't' } });
await blockScreenCapture(true);
```

--------------------------------

### prepareRaspExecutionStateMapping

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/channels-and-utils.md

Maps native identifiers to the RASP execution state values.

```APIDOC
## prepareRaspExecutionStateMapping

### Description
Asynchronously fetches native identifiers and assigns them to the `RaspExecutionState.AllChecksFinished.value` property.

### Return Type
`Promise<void>`
```

--------------------------------

### useFreeRasp with RASP execution-state callbacks

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/useFreeRasp.md

Demonstrates usage of the hook with additional RASP execution-state monitoring callbacks.

```tsx
useFreeRasp(
  config,
  {
    appIntegrity: () => console.warn('App integrity violation'),
    malware: (suspiciousApps) => {
      // Android only — receives parsed malware detections
      console.warn(`Malware detected: ${suspiciousApps.map((a) => a.packageInfo.packageName)}`);
    },
  },
  {
    allChecksFinished: () => {
      console.info('All RASP security checks finished');
    },
  }
);
```

--------------------------------

### Expo Config Plugin Entry Point

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/plugin.md

The entry point for the Expo config plugin, exposed via app.plugin.js at the repository root.

```js
module.exports = require('./plugin/build');
```

--------------------------------

### useFreeRasp(config, actions, raspExecutionStateActions)

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/useFreeRasp.md

Initializes the RASP security module and registers threat detection listeners. This hook handles the lifecycle of the security service, including automatic cleanup on unmount.

```APIDOC
## useFreeRasp(config, actions, raspExecutionStateActions)

### Description
Initializes the freeRASP security module and registers threat listeners. It ensures the service is started exactly once per process and manages the lifecycle of listeners via React's useEffect.

### Parameters
- **config** (TalsecConfig) - Required - Configuration object containing androidConfig, iosConfig, watcherMail, isProd, and killOnBypass settings.
- **actions** (ThreatEventActions) - Optional - Callback functions triggered when specific security threats (e.g., privilegedAccess, debug, hooks) are detected.
- **raspExecutionStateActions** (Object) - Optional - Callbacks for RASP execution states, such as allChecksFinished.

### Usage Example
```tsx
import { useFreeRasp } from 'freerasp-react-native';

useFreeRasp(config, actions, {
  allChecksFinished: () => {
    console.info('All RASP security checks finished');
  },
});
```
```

--------------------------------

### configureIosSpmProperties

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/plugin.md

Configures iOS SPM properties by managing the ios.useFrameworks setting and tracking state via freerasp bookkeeping keys.

```APIDOC
## configureIosSpmProperties

### Description
Configures iOS SPM properties. When enabling SPM, it stores the previous ios.useFrameworks value, sets it to 'dynamic', and marks the property as managed. When disabling, it restores the previous value and removes bookkeeping keys.

### Signature
`configureIosSpmProperties(properties: Record<string, string>, spmEnabled: boolean): Record<string, string>`

### Parameters
- **properties** (Record<string, string>) - The current properties map.
- **spmEnabled** (boolean) - Whether to enable or disable SPM configuration.

### Returns
- (Record<string, string>) - The updated properties map.
```

--------------------------------

### Implement Singleton behavior for talsecStart

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/useFreeRasp.md

This snippet demonstrates how the isRaspStarted flag prevents multiple initializations of the freeRASP service. It ensures talsecStart is called only once and handles potential errors or invalid responses.

```ts
if (isRaspStarted) {
  return;
}
try {
  const response = await talsecStart(config);
  if (response !== 'freeRASP started') {
    onInvalidCallback();
  }
  isRaspStarted = true;
} catch (e: any) {
  console.error(`${e.code}: ${e.message}`);
}
```

--------------------------------

### blockScreenCapture method

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-methods.md

Enables or disables screen capture protection on the protected window. Returns a promise resolving to a status string.

```ts
export const blockScreenCapture = (enable: boolean): Promise<string> => {
  return FreeraspReactNative.blockScreenCapture(enable);
};
```

--------------------------------

### Initialize freeRASP with useFreeRasp Hook

Source: https://github.com/talsec/free-rasp-reactnative/wiki/Home

Use this hook in your root component's entry point (e.g., App.jsx/tsx) to initialize freeRASP. Call it outside of useEffect. Configure threat reactions by passing an actions object.

```typescript
// reactions for detected threats
const actions = {
  // Android & iOS
  privilegedAccess: () => {
    console.log('privilegedAccess');
  },
  // Android & iOS
  debug: () => {
    console.log('debug');
  },
  // Android & iOS
  simulator: () => {
    console.log('simulator');
  },
  // Android & iOS
  appIntegrity: () => {
    console.log('appIntegrity');
  },
  // Android & iOS
  unofficialStore: () => {
    console.log('unofficialStore');
  },
  // Android & iOS
  hooks: () => {
    console.log('hooks');
  },
  // Android & iOS
  deviceBinding: () => {
    console.log('deviceBinding');
  },
  // Android & iOS
  secureHardwareNotAvailable: () => {
    console.log('secureHardwareNotAvailable');
  },
  // Android & iOS
  systemVPN: () => {
    console.log('systemVPN');
  },
  // Android & iOS
  passcode: () => {
    console.log('passcode');
  },
  // iOS only
  deviceID: () => {
    console.log('deviceID');
  },
  // Android only
  obfuscationIssues: () => {
    console.log('obfuscationIssues');
  },
  // Android only
  devMode: () => {
    console.log('devMode');
  },
};

useFreeRasp(config, actions);
```

--------------------------------

### Free-RASP Configuration Object

Source: https://github.com/talsec/free-rasp-reactnative/wiki/Home

Define the configuration object for Free-RASP, including platform-specific settings for Android and iOS, and your watcher email. Ensure all required values are provided.

```typescript
// app configuration
const config = {
  androidConfig: {
    packageName: 'com.awesomeproject',
    certificateHashes: ['your_signing_certificate_hash_base64'],
    supportedAlternativeStores: ['com.sec.android.app.samsungapps'],
  },
  iosConfig: {
    appBundleId: 'com.awesomeproject',
    appTeamId: 'your_team_ID',
  },
  watcherMail: 'your_email_address@example.com',
  isProd: true,
};
```

--------------------------------

### Error handling for native methods

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-methods.md

Shows how to handle errors when adding items to the whitelist or retrieving app icons. Note that onInvalidCallback should not be called from application code as it aborts the app.

```ts
import { addToWhitelist, getAppIcon, onInvalidCallback } from 'freerasp-react-native';

try {
  const ok = await addToWhitelist('com.suspect.app');
  console.info(`Whitelisted: ${ok}`);
} catch (error) {
  // iOS: 'Malware detection not available on iOS', or TypeError where Promise.reject is undefined
  console.error('Whitelist failed:', error);
}

try {
  const iconB64 = await getAppIcon('com.suspect.app');
  console.info(`Icon bytes: ${iconB64.length}`);
} catch (error) {
  console.error('Icon retrieval failed:', error);
}

// Never call onInvalidCallback from application code — it aborts the app.
```

--------------------------------

### Configure React Native codegen

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-module.md

Configuration block for the New Architecture in android/build.gradle.

```groovy
if (isNewArchitectureEnabled()) {
  react {
    jsRootDir = file("../src/")
    libraryName = "FreeraspReactNative"
    codegenJavaPackageName = "com.freeraspreactnative"
  }
}
```

--------------------------------

### Project Module Graph Structure

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/index.md

A visual representation of the file hierarchy and module dependencies within the FreeRASP React Native project.

```text
src/index.tsx  (public re-exports)
├── types/types.ts                  → all exported types (see types.md)
├── api/methods/native.ts           → talsecStart, addToWhitelist, blockScreenCapture,
│                                      isScreenCaptureBlocked, storeExternalId,
│                                      removeExternalId, getAppIcon, onInvalidCallback,
│                                      removeListenerForEvent
├── api/methods/reactNative.ts      → useFreeRasp (React hook)
├── api/listeners/threat.ts         → setThreatListeners, removeThreatListener
└── api/listeners/raspExecutionState.ts → setRaspExecutionStateListener,
                                           removeRaspExecutionStateEventListener

Internal (not re-exported from src/index.tsx)
├── api/nativeModules.ts            → FreeraspReactNative (NativeModules binding)
├── models/threat.ts                → Threat class
├── models/raspExecutionState.ts    → RaspExecutionState class
├── channels/threat.ts              → getThreatIdentifiers, getThreatChannelData, prepareThreatMapping
├── channels/raspExecutionState.ts  → getRaspExecutionStateIdentifiers,
│                                      getRaspExecutionStateChannelData,
│                                      prepareRaspExecutionStateMapping
├── utils/config.ts                 → withDefaults, normalizeAndroidConfig
├── utils/malware.ts                → parseMalwareData, toSuspiciousAppInfo
├── utils/utils.ts                  → getThreatCount, getRaspExecutionStateCount, itemsHaveType
└── internal.ts                     → deprecated, empty (export {})

Native / build-time surface
├── ios/FreeraspReactNative.swift   → RCT_EXTERN_MODULE FreeraspReactNative (RCTEventEmitter)
├── ios/FreeraspReactNative.m       → RCT_EXTERN_METHOD bridging header
├── ios/dispatchers/*.swift         → ThreatDispatcher, ExecutionStateDispatcher
├── ios/models/*.swift              → SecurityThreat extension, RaspExecutionStates enum
├── ios/utils/*.swift               → EventIdentifiers, RandomGenerator, Utils
├── android/build.gradle            → Android native build (binary TalsecSecurity-Community-ReactNative)
├── freerasp-react-native.podspec   → iOS CocoaPods spec
├── freerasp_spm.rb                 → freerasp_embed_talsec_spm! ruby helper
└── plugin/src/index.ts             → Expo config plugin (separate entry: plugin/build/index.js)
```

--------------------------------

### prepareThreatMapping function

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/channels-and-utils.md

Mutates shared Threat static instances to align their values with native identifiers. Relies on the order provided by getThreatIdentifiers.

```ts
export const prepareThreatMapping = async (): Promise<void> => {
  const newValues = await getThreatIdentifiers();
  const threats = Threat.getValues();
  threats.map((threat, index) => {
    threat.value = newValues[index]!;
  });
};
```

--------------------------------

### Set Android Minimum SDK

Source: https://github.com/talsec/free-rasp-reactnative/wiki/Home

Update the `minSdkVersion` in your Android `build.gradle` file to at least 23 to ensure compatibility with freeRASP.

```groovy
buildscript {
    ext {
      minSdkVersion 23
      ...
    }
}
```

--------------------------------

### Importing Talsec types

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/types.md

Shows how to import the primary configuration types from the freerasp-react-native package.

```ts
import type { TalsecConfig, ThreatEventActions, SuspiciousAppInfo } from 'freerasp-react-native';
```

--------------------------------

### Enable Code Obfuscation in Android Gradle

Source: https://github.com/talsec/free-rasp-reactnative/wiki/Home

Configure your app's `build.gradle` file to enable code minification and obfuscation for release builds. This helps protect your application's code from reverse engineering.

```groovy
android {
    buildTypes {
        release {
            ... 
            minifyEnabled true
            shrinkResources true
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}
```

--------------------------------

### Modify TalsecRuntime.swift header for Rosetta

Source: https://github.com/talsec/free-rasp-reactnative/wiki/Home

Adjust the TalsecRuntime.swift header file to ensure the arm64 macro is set under Rosetta. This resolves 'Unsupported Swift architecture' errors.

```swift
#ifndef TALSECRUNTIME_SWIFT_H
#define TALSECRUNTIME_SWIFT_H

```

--------------------------------

### Ruby Helper freerasp_embed_talsec_spm! Method

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/plugin.md

The helper method invoked from the Podfile to manage TalsecRuntime Swift Package Manager dependencies.

```ruby
def freerasp_embed_talsec_spm!(installer,
  package_path: File.expand_path('ios/TalsecRuntimePackage', __dir__),
  product: 'TalsecRuntime')
```

--------------------------------

### PackageInfo Type Definition

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/types.md

Contains metadata for a detected app, such as package name, version, and icon. Used within SuspiciousAppInfo.

```ts
export type PackageInfo = {
  packageName: string;
  appName?: string;
  version?: string;
  appIcon?: string;
  installerStore?: string;
};
```

--------------------------------

### Initialize Free RASP within useEffect

Source: https://github.com/talsec/free-rasp-reactnative/wiki/Home

Use this pattern to initialize Free RASP when calling hooks inside useEffect. Ensure 'actions' and 'config' are properly defined.

```typescript
import {
  setThreatListeners,
  talsecStart,
  removeThreatListeners,
} from 'freerasp-react-native';

... 

useEffect(() => {
  setThreatListeners(actions);
  talsecStart(config);

  return () => {
    removeThreatListeners();
  };
}, []);
```

--------------------------------

### getThreatChannelData function

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/channels-and-utils.md

Retrieves a tuple containing the threat channel name, channel key, and malware key. Validates that the returned data is a string array of length 3.

```ts
export const getThreatChannelData = async (): Promise<
  [string, string, string]
> => {
  const data = await FreeraspReactNative.getThreatChannelData();
  if (data.length !== 3 || !itemsHaveType(data, 'string')) {
    onInvalidCallback();
  }
  return data;
};
```

--------------------------------

### parseMalwareData function

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/channels-and-utils.md

Parses an array of base64-encoded strings into SuspiciousAppInfo objects. Rejects with an error message if decoding or parsing fails.

```ts
export const parseMalwareData = async (
  data: string[]
): Promise<SuspiciousAppInfo[]> => {
  return new Promise((resolve, reject) => {
    try {
      resolve(data.map((entry) => toSuspiciousAppInfo(entry)));
    } catch (error: any) {
      reject(`Error while parsing app data: ${error}`);
    }
  });
};
```

--------------------------------

### Configuration defaults in src/utils/config.ts

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/channels-and-utils.md

Defines default scan scope and reason mode, and provides functions to normalize configuration objects with these defaults.

```ts
const DEFAULT_SCAN_SCOPE: ScanScope = {
  scopeType: 'SIDELOADED_ONLY',
};

const DEFAULT_REASON_MODE: ReasonMode = 'HIGHEST_CONFIDENCE';

const withDetectionDefaults = (
  config: SuspiciousAppDetectionConfig
): SuspiciousAppDetectionConfig => ({
  ...config,
  scanScope: config.scanScope ?? DEFAULT_SCAN_SCOPE,
  reasonMode: config.reasonMode ?? DEFAULT_REASON_MODE,
});

export const normalizeAndroidConfig = (
  androidConfig: TalsecAndroidConfig
): TalsecAndroidConfig => {
  if (!androidConfig.suspiciousAppDetectionConfig) {
    return androidConfig;
  }
  return {
    ...androidConfig,
    suspiciousAppDetectionConfig: withDetectionDefaults(
      androidConfig.suspiciousAppDetectionConfig
    ),
  };
};

export const withDefaults = (options: TalsecConfig): TalsecConfig => ({
  ...options,
  androidConfig: options.androidConfig
    ? normalizeAndroidConfig(options.androidConfig)
    : undefined,
});
```

--------------------------------

### Plugin Configuration Interface in pluginConfig.ts

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/plugin.md

Defines the structure for iOS and Android plugin configurations, including options for Swift Package Manager usage and Android build settings.

```ts
export interface PluginConfigType {
  ios?: PluginConfigTypeIos;
  android?: PluginConfigTypeAndroid;
}

/** @platform ios */
export interface PluginConfigTypeIos {
  /**
   * Use Swift Package Manager to deliver TalsecRuntime. Defaults to `true`.
   */
  useSpm?: boolean;
}

export interface PluginConfigTypeAndroid {
  /**
   * Override the default `minSdkVersion` version number in **build.gradle**.
   * */
  minSdkVersion?: number;
  R8Version?: string;
}
```

--------------------------------

### blockScreenCapture

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-methods.md

Enables or disables screen capture blocking on the protected window.

```APIDOC
## blockScreenCapture

### Description
Controls the ability to capture the screen on the protected window.

### Signature
`blockScreenCapture(enable: boolean): Promise<string>`

### Parameters
- **enable** (boolean) - Required - Set to true to block screen capture, or false to re-enable it.

### Returns
- **Promise<string>** - Resolves with a status message indicating the new state.

### Errors
- Rejects on iOS with 'BlockScreenCaptureError' if no protected window is found.
```

--------------------------------

### addToWhitelist

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-methods.md

Adds a package name to the malware whitelist on Android.

```APIDOC
## addToWhitelist

### Description
Adds a specific package name to the native malware whitelist. This functionality is only available on Android.

### Signature
`addToWhitelist(packageName: string): Promise<boolean>`

### Parameters
- **packageName** (string) - Required - Package name of an app to add to the malware whitelist.

### Returns
- **Promise<boolean>** - Resolves to true when the package is successfully stored.

### Notes
- Rejects on iOS with the message 'Malware detection not available on iOS'.
```

--------------------------------

### Declare TalsecSecurity dependency

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-module.md

The Android native code is provided as a binary dependency in android/build.gradle.

```text
com.aheaditec.talsec.security:TalsecSecurity-Community-ReactNative:19.2.3
```

--------------------------------

### Default Plugin Export

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/plugin.md

The default export of the plugin, which uses createRunOncePlugin to ensure the configuration logic executes only once.

```ts
export default createRunOncePlugin(withRnTalsecApp, pkg.name, pkg.version);
```

--------------------------------

### Expo Plugin Configuration for freeRASP

Source: https://github.com/talsec/free-rasp-reactnative/wiki/Home

Add this plugin configuration to your app.json to automatically set up freeRASP dependencies. Ensure minSdkVersion is at least 23. For Expo 50, specify R8Version to support sealed classes.

```json
"plugins": [
      [
        "freerasp-react-native/app.plugin.js",
        {
          "android": {
            "minSdkVersion": "23",
            "R8Version": "8.3.37" // optional for Expo 50
          }
        }
      ]
    ],

```

--------------------------------

### toSuspiciousAppInfo

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/channels-and-utils.md

Converts a single base64-encoded JSON string into a SuspiciousAppInfo object.

```APIDOC
## toSuspiciousAppInfo(base64Value: string)

### Description
Decodes a single base64-encoded JSON string and maps it to a SuspiciousAppInfo object.

### Parameters
- **base64Value** (string) - Required - A single base64-encoded JSON entry.

### Returns
- **SuspiciousAppInfo** - The parsed object containing packageInfo, reasons, and permissions.

### Errors
- Throws an error if JSON parsing or base64 decoding fails.
```

--------------------------------

### getAppIcon

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-methods.md

Retrieves the base64-encoded PNG icon of a detected suspicious app.

```APIDOC
## getAppIcon(packageName)

### Description
Retrieves the base64-encoded PNG icon of a detected suspicious app. Note: This method is not available on iOS.

### Parameters
- **packageName** (string) - Required - Package name of a detected suspicious app.

### Return Type
Promise<string>

### Rejects
- On iOS with message: 'App icon retrieval for Malware detection not available on iOS'.
```

--------------------------------

### Importing Native Module Dependencies

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-methods.md

Required imports for interacting with the native FreeraspReactNative module and handling configuration types.

```ts
import { Platform } from 'react-native';
import { FreeraspReactNative } from '../nativeModules';
import type { TalsecConfig } from '../../types/types';
import { withDefaults } from '../../utils/config';
```

--------------------------------

### prepareRaspExecutionStateMapping function

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/channels-and-utils.md

Assigns native identifiers to the RaspExecutionState values.

```ts
export const prepareRaspExecutionStateMapping = async (): Promise<void> => {
  const newValues = await getRaspExecutionStateIdentifiers();
  const threats = RaspExecutionState.getValues();
  threats.map((threat, index) => {
    threat.value = newValues[index]!;
  });
};
```

--------------------------------

### getAppIcon method

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-methods.md

Retrieves the base64-encoded PNG icon of a detected suspicious app by its package name. This method is not available on iOS and will reject if called.

```ts
export const getAppIcon = (packageName: string): Promise<string> => {
  if (Platform.OS === 'ios') {
    return Promise.reject(
      'App icon retrieval for Malware detection not available on iOS'
    );
  }
  return FreeraspReactNative.getAppIcon(packageName);
};
```

--------------------------------

### addToWhitelist method

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-methods.md

Adds a package name to the malware whitelist on Android. This method is not available on iOS and will reject if called.

```ts
export const addToWhitelist = async (packageName: string): Promise<boolean> => {
  if (Platform.OS === 'ios') {
    return Promise.reject('Malware detection not available on iOS');
  }
  return FreeraspReactNative.addToWhitelist(packageName);
};
```

--------------------------------

### Utility Functions

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/channels-and-utils.md

Helper functions for retrieving threat counts and performing type validation.

```APIDOC
## getThreatCount()
Returns the platform-dependent threat roster size (22 on Android, 14 on iOS).

## getRaspExecutionStateCount()
Returns the current RASP execution state count (always 1).

## itemsHaveType(data: any[], desidedType: string)
Checks if every element in the provided array matches the specified type string.
- **data** (any[]) - The array to check.
- **desidedType** (string) - The type string to validate against (e.g., 'string', 'number').
- **Returns** (boolean) - True if all elements match the type.
```

--------------------------------

### parseMalwareData

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/channels-and-utils.md

Parses an array of base64-encoded malware data strings into a list of SuspiciousAppInfo objects.

```APIDOC
## parseMalwareData(data: string[])

### Description
Parses an array of base64-encoded strings, each containing a JSON object with package information, reasons, and permissions, into a list of SuspiciousAppInfo objects.

### Parameters
- **data** (string[]) - Required - An array of base64-encoded JSON strings.

### Returns
- **Promise<SuspiciousAppInfo[]>** - A promise that resolves to the parsed malware information.

### Errors
- Rejects with a string 'Error while parsing app data: <error>' if decoding or parsing fails.
```

--------------------------------

### getRaspExecutionStateChannelData function

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/channels-and-utils.md

Retrieves the channel name and key as a tuple. The returned data must be a string array of length 2.

```ts
export const getRaspExecutionStateChannelData = async (): Promise<
  [string, string]
> => {
  const dataLength = 2;
  const data = await FreeraspReactNative.getRaspExecutionStateChannelData();
  if (data.length !== dataLength || !itemsHaveType(data, 'string')) {
    onInvalidCallback();
  }
  return data;
};
```

--------------------------------

### Default Export - ConfigPlugin

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/plugin.md

The default export is a ConfigPlugin that ensures the freeRASP native integration logic runs exactly once during the Expo prebuild process.

```APIDOC
## Expo Config Plugin

### Description
The default export is a `ConfigPlugin<PluginConfigType>` that automates the configuration of native Android and iOS projects for freeRASP. It uses `createRunOncePlugin` to ensure the configuration logic is applied only once per project.

### Usage
```js
module.exports = require('freerasp-react-native/app.plugin.js');
```

### Plugin Pipeline
The plugin performs the following steps during `expo prebuild`:
1. **withBuildscriptDependency**: Adds Maven repositories to `build.gradle`.
2. **withAndroidMinSdkVersion**: Configures the `minSdkVersion` in Android build properties.
3. **withAndroidR8Version**: Optionally configures the R8 version in `build.gradle`.
4. **withRnTalsecIos**: Configures iOS Podfile properties and frameworks.
```

--------------------------------

### toSuspiciousAppInfo function

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/channels-and-utils.md

Decodes a single base64-encoded JSON string into a SuspiciousAppInfo object. Uses the Buffer package for decoding.

```ts
export const toSuspiciousAppInfo = (base64Value: string): SuspiciousAppInfo => {
  const data = JSON.parse(Buffer.from(base64Value, 'base64').toString('utf8'));
  const packageInfo = data.packageInfo as PackageInfo;
  return {
    packageInfo,
    reasons: data.reasons,
    permissions: data.permissions,
  } as SuspiciousAppInfo;
};
```

--------------------------------

### Import freeRASP Methods for Class Components

Source: https://github.com/talsec/free-rasp-reactnative/wiki/Home

Import the necessary methods from the freerasp-react-native plugin when initializing freeRASP within a class component.

```typescript
import {
  talsecStart,
  setThreatListeners,
  removeThreatListeners,
} from 'freerasp-react-native';
```

--------------------------------

### blockScreenCapture

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-module.md

Enables or disables screen capture blocking for the application.

```APIDOC
## blockScreenCapture(enable: Bool)

### Description
Controls whether screen capture is blocked or allowed.

### Parameters
- **enable** (Bool) - Required - Set to true to block screen capture, false to allow it.

### Response
- **Success** - Resolves with a confirmation string indicating the new state.
- **Reject** - Rejects with "BlockScreenCaptureError" if no windows are found to apply the setting.
```

--------------------------------

### Import paths for FreeRASP React Native

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/index.md

Shows the public API exports from the library and the required Expo configuration plugin export.

```ts
// Public API (what src/index.tsx re-exports):
import {
  talsecStart,
  addToWhitelist,
  blockScreenCapture,
  isScreenCaptureBlocked,
  storeExternalId,
  removeExternalId,
  getAppIcon,
  onInvalidCallback,
  removeListenerForEvent,
  useFreeRasp,
  setThreatListeners,
  removeThreatListener,
  setRaspExecutionStateListener,
  removeRaspExecutionStateEventListener,
  type TalsecConfig,
  type ThreatEventActions,
  type RaspExecutionStateEventActions,
  type SuspiciousAppInfo,
  // ... see types.md
} from 'freerasp-react-native';

// Expo config plugin (Expo app config):
module.exports = require('freerasp-react-native/plugin');
```

--------------------------------

### configureIosSpmProperties export and definition

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/plugin.md

Exports and defines the configureIosSpmProperties function used to manage iOS SPM properties. It handles storing previous values and marking properties as managed.

```ts
export default configureIosSpmProperties;
```

```ts
const FRAMEWORKS_PROPERTY = 'ios.useFrameworks';
const MANAGED_PROPERTY = 'freerasp.iosUseFrameworks';
const PREVIOUS_VALUE_PROPERTY = 'freerasp.previousIosUseFrameworks';
const UNSET_VALUE = '__freerasp_unset__';

const configureIosSpmProperties = (
  properties: Record<string, string>,
  spmEnabled: boolean
): Record<string, string> => { ... };
```

--------------------------------

### getRaspExecutionStateChannelData

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/channels-and-utils.md

Retrieves the channel name and key for the RASP execution state.

```APIDOC
## getRaspExecutionStateChannelData

### Description
Retrieves the channel configuration data from the native layer.

### Return Type
`Promise<[string, string]>` - A tuple containing `[channelName, channelKey]`.
```

--------------------------------

### Public API Methods

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/index.md

The primary methods exported by the freerasp-react-native package for security monitoring and configuration.

```APIDOC
## Public API Methods

### Description
Methods available for import from 'freerasp-react-native' to manage security features and threat detection.

### Methods
- **talsecStart(config: TalsecConfig)**: Initializes the FreeRASP security engine.
- **useFreeRasp(config: TalsecConfig)**: React hook to initialize the security engine.
- **addToWhitelist(item: string)**: Adds an item to the whitelist (Android only).
- **blockScreenCapture(enabled: boolean)**: Toggles screen capture blocking.
- **isScreenCaptureBlocked()**: Checks if screen capture is currently blocked.
- **storeExternalId(id: string)**: Stores an external identifier.
- **removeExternalId()**: Removes the stored external identifier.
- **getAppIcon()**: Retrieves the application icon (Android only).
- **onInvalidCallback(callback: Function)**: Sets a callback for invalid events.
- **setThreatListeners(listeners: ThreatEventActions)**: Configures listeners for security threat events.
- **removeThreatListener(type: string)**: Removes a specific threat listener.
- **setRaspExecutionStateListener(listeners: RaspExecutionStateEventActions)**: Configures listeners for RASP execution state changes.
- **removeRaspExecutionStateEventListener(type: string)**: Removes a specific RASP execution state listener.
- **removeListenerForEvent(type: string)**: Removes a generic event listener.
```

--------------------------------

### setRaspExecutionStateListener

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/listeners.md

Registers a listener to monitor RASP execution state changes.

```APIDOC
## setRaspExecutionStateListener

### Description
Registers a listener for RASP execution state events. It includes a re-entrancy guard, performs prior-listener removal, and handles channel discovery and mapping preparation.

### Signature
`setRaspExecutionStateListener(config: RaspExecutionStateEventActions): Promise<void>`

### Parameters
- **config** (RaspExecutionStateEventActions) - Required - An object containing callback functions for execution state events. Currently supports `allChecksFinished?: () => any`.

### Returns
- **Promise<void>** - Resolves when the listener is successfully set.
```

--------------------------------

### setRaspExecutionStateListener function

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/listeners.md

Sets up a listener for RASP execution state events. It includes a re-entrancy guard, removes prior listeners, and performs one-time channel discovery and mapping preparation.

```ts
export const setRaspExecutionStateListener = async (
  config: RaspExecutionStateEventActions
) => {
  if (isInitializing) {
    return;
  }

  isInitializing = true;

  await removeRaspExecutionStateEventListener();

  if (!executionStateChannel || !executionStateKey) {
    [executionStateChannel, executionStateKey] =
      await getRaspExecutionStateChannelData();
  }

  if (!isMappingPrepared) {
    await prepareRaspExecutionStateMapping();
    isMappingPrepared = true;
  }

  const listener = async (event: NativeEvent) => {
    if (!executionStateKey) {
      onInvalidCallback();
      return;
    }

    switch (event[executionStateKey]) {
      case RaspExecutionState.AllChecksFinished.value:
        config.allChecksFinished?.();
        break;
      default:
        onInvalidCallback();
        break;
    }
  };
  eventsListener = eventEmitter.addListener(executionStateChannel, listener);
  isInitializing = false;
};
```

--------------------------------

### RaspExecutionState.getValues method signature

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/models.md

The signature for the static getValues method which returns an array of RaspExecutionState instances.

```ts
static getValues(): RaspExecutionState[]
```

--------------------------------

### TalsecConfig

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/types.md

The TalsecConfig type is the primary configuration object used to initialize the FreeRASP security engine. It includes platform-specific configurations and global security settings.

```APIDOC
## TalsecConfig

### Description
Configuration object for initializing the Talsec security engine.

### Parameters
- **androidConfig** (TalsecAndroidConfig) - Optional - Android-specific RASP configuration.
- **iosConfig** (TalsecIosConfig) - Optional - iOS-specific RASP configuration.
- **watcherMail** (string) - Required - E-mail address that receives security incident reports.
- **isProd** (boolean) - Optional - Production mode flag.
- **killOnBypass** (boolean) - Optional - Whether the app process is killed when the RASP engine is bypassed.
```

--------------------------------

### isScreenCaptureBlocked

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-methods.md

Checks the current blocked state of the protected window.

```APIDOC
## isScreenCaptureBlocked()

### Description
Checks the current blocked state of the protected window.

### Return Type
Promise<boolean>

### Rejects
- On iOS with `IsScreenCaptureBlockedError` (Error while checking if screen capture is blocked).
```

--------------------------------

### useFreeRasp function signature

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/useFreeRasp.md

The primary React hook for initializing freeRASP. It accepts configuration, threat callbacks, and optional lifecycle state actions.

```ts
export const useFreeRasp = (
  config: TalsecConfig,
  actions: ThreatEventActions,
  raspExecutionStateActions?: RaspExecutionStateEventActions
) => {
  useEffect(() => {
    (async () => {
      await setThreatListeners(actions);
      raspExecutionStateActions &&
        (await setRaspExecutionStateListener(raspExecutionStateActions));

      if (isRaspStarted) {
        return;
      }

      try {
        const response = await talsecStart(config);
        if (response !== 'freeRASP started') {
          onInvalidCallback();
        }
        isRaspStarted = true;
      } catch (e: any) {
        console.error(`${e.code}: ${e.message}`);
      }
    })();

    return () => {
      (async () => {
        await removeThreatListener();
        await removeRaspExecutionStateEventListener();
      })();
    };
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);
};
```

--------------------------------

### PluginConfigType

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/types.md

Configuration interface for the FreeRASP React Native plugin, allowing customization of iOS and Android build settings.

```APIDOC
## PluginConfigType

### Description
Configuration object used by the plugin's default `ConfigPlugin` export to define platform-specific build settings.

### Fields
- **ios** (PluginConfigTypeIos) - Optional - iOS specific configuration.
- **android** (PluginConfigTypeAndroid) - Optional - Android specific configuration.

### PluginConfigTypeIos
- **useSpm** (boolean) - Optional - Default: `true`. Deliver TalsecRuntime through Swift Package Manager.

### PluginConfigTypeAndroid
- **minSdkVersion** (number) - Optional - Default: `23`. Override the default `minSdkVersion` version number in build.gradle.
- **R8Version** (string) - Optional - Drops `com.android.tools:r8:<version>` into the gradle buildscript.
```

--------------------------------

### Re-export module in src/index.tsx

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/index.md

The top-level entry point for the package, which re-exports all necessary types, native methods, and listeners.

```tsx
export * from './types/types';
export * from './api/methods/native';
export * from './api/methods/reactNative';
export * from './api/listeners/threat';
export * from './api/listeners/raspExecutionState';
```

--------------------------------

### isScreenCaptureBlocked method

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-methods.md

Checks the current blocked state of the protected window. Returns a Promise that resolves to a boolean. Rejects on iOS with IsScreenCaptureBlockedError.

```ts
export const isScreenCaptureBlocked = (): Promise<boolean> => {
  return FreeraspReactNative.isScreenCaptureBlocked();
};
```

--------------------------------

### SuspiciousAppDetectionConfig Type Definition

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/types.md

Defines the configuration for detecting suspicious applications, including package names, hashes, and permission-based scanning. Used by TalsecAndroidConfig.suspiciousAppDetectionConfig.

```ts
export type SuspiciousAppDetectionConfig = {
  packageNames?: string[];
  hashes?: string[];
  requestedPermissions?: string[][];
  grantedPermissions?: string[][];
  scanScope: ScanScope;
  reasonMode: ReasonMode;
};
```

--------------------------------

### getRaspExecutionStateIdentifiers

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/channels-and-utils.md

Retrieves the RASP execution state identifiers from the native layer.

```APIDOC
## getRaspExecutionStateIdentifiers

### Description
Retrieves a single-element array containing the `AllChecksFinished` callback identifier.

### Return Type
`Promise<number[]>`

### Validation
The returned array length must equal the result of `getRaspExecutionStateCount()` (1) and all elements must be of type number.
```

--------------------------------

### storeExternalId method

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/native-methods.md

Persists an external ID string on the device to correlate security events with app users. Returns a Promise resolving to a string.

```ts
export const storeExternalId = (data: string): Promise<string> => {
  return FreeraspReactNative.storeExternalId(data);
};
```

--------------------------------

### RaspExecutionState class definition

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/models.md

Defines the RaspExecutionState class with a value property and a static AllChecksFinished instance.

```ts
export class RaspExecutionState {
  value: number;

  static AllChecksFinished = new RaspExecutionState(0);

  constructor(value: number) {
    this.value = value;
  }

  static getValues(): RaspExecutionState[] {
    return [this.AllChecksFinished];
  }
}
```

--------------------------------

### Threat.getValues() Method Signature

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/api-reference/models.md

The signature for the static getValues method which returns an array of Threat instances based on the current platform.

```ts
static getValues(): Threat[]
```

--------------------------------

### RaspExecutionStateEventActions type definition

Source: https://github.com/talsec/free-rasp-reactnative/blob/master/_autodocs/types.md

Defines the actions available for RASP execution state events, specifically the allChecksFinished callback.

```ts
export type RaspExecutionStateEventActions = {
  allChecksFinished?: () => any;
};
```
Tokens:
Raw