@trustchex/react-native-sdk 1.409.0 → 1.464.0

package/src/Shared/EIDReader/protocol/paceResult.ts

@@ -0,0 +1,62 @@
+import type { AccessKeySpec } from '../accessKeySpec';
+import type { SecureMessagingWrapper } from '../secureMessagingWrapper';
+import type { MappingType } from '../paceInfo';
+
+/**
+ * Result of PACE protocol execution.
+ */
+export class PACEResult {
+  private paceKey: AccessKeySpec;
+  private mappingType: MappingType;
+  private agreementAlg: string;
+  private cipherAlg: string;
+  private digestAlg: string;
+  private keyLength: number;
+  private wrapper: SecureMessagingWrapper;
+
+  constructor(
+    paceKey: AccessKeySpec,
+    mappingType: MappingType,
+    agreementAlg: string,
+    cipherAlg: string,
+    digestAlg: string,
+    keyLength: number,
+    wrapper: SecureMessagingWrapper
+  ) {
+    this.paceKey = paceKey;
+    this.mappingType = mappingType;
+    this.agreementAlg = agreementAlg;
+    this.cipherAlg = cipherAlg;
+    this.digestAlg = digestAlg;
+    this.keyLength = keyLength;
+    this.wrapper = wrapper;
+  }
+
+  public getPACEKey(): AccessKeySpec {
+    return this.paceKey;
+  }
+
+  public getMappingType(): MappingType {
+    return this.mappingType;
+  }
+
+  public getAgreementAlg(): string {
+    return this.agreementAlg;
+  }
+
+  public getCipherAlg(): string {
+    return this.cipherAlg;
+  }
+
+  public getDigestAlg(): string {
+    return this.digestAlg;
+  }
+
+  public getKeyLength(): number {
+    return this.keyLength;
+  }
+
+  public getWrapper(): SecureMessagingWrapper {
+    return this.wrapper;
+  }
+}

package/src/Shared/EIDReader/secureMessagingWrapper.ts

@@ -87,7 +87,7 @@ export abstract class SecureMessagingWrapper implements APDUWrapper {
       dataOutputStream.push(...paddedData);
       let cc2 = Uint8Array.from(
         Buffer.from(
-          cryptoUtils.computeMac(
+          this.computeMAC(
             Buffer.from(dataOutputStream).toString('hex'),
             this.ksMac
           ),
@@ -116,6 +116,30 @@ export abstract class SecureMessagingWrapper implements APDUWrapper {
 
   protected abstract getEncodedSendSequenceCounter(): Uint8Array;
 
+  /**
+   * Encrypt data using the session encryption key.
+   * Subclasses override for AES vs 3DES.
+   */
+  protected encrypt(dataHex: string, keyHex: string): string {
+    return cryptoUtils.encryptWith3DES(dataHex, keyHex);
+  }
+
+  /**
+   * Decrypt data using the session encryption key.
+   * Subclasses override for AES vs 3DES.
+   */
+  protected decrypt(dataHex: string, keyHex: string): string {
+    return cryptoUtils.decryptWith3DES(dataHex, keyHex);
+  }
+
+  /**
+   * Compute MAC over data using the session MAC key.
+   * Subclasses override for AES-CMAC vs 3DES MAC.
+   */
+  protected computeMAC(dataHex: string, keyHex: string): string {
+    return cryptoUtils.computeMac(dataHex, keyHex);
+  }
+
   private wrapCommandAPDU(commandAPDU: CommandAPDU): CommandAPDU {
     const cla = commandAPDU.getCLA();
     const ins = commandAPDU.getINS();
@@ -149,10 +173,7 @@ export abstract class SecureMessagingWrapper implements APDUWrapper {
         this.getPadLength()
       );
       const ciphertext = Buffer.from(
-        cryptoUtils.encryptWith3DES(
-          Buffer.from(data).toString('hex'),
-          this.ksEnc
-        ),
+        this.encrypt(Buffer.from(data).toString('hex'), this.ksEnc),
         'hex'
       );
       output.push(hasDO85 ? 0x85 : 0x87);
@@ -180,7 +201,7 @@ export abstract class SecureMessagingWrapper implements APDUWrapper {
     );
 
     const cc = Buffer.from(
-      cryptoUtils.computeMac(Buffer.from(n).toString('hex'), this.ksMac),
+      this.computeMAC(Buffer.from(n).toString('hex'), this.ksMac),
       'hex'
     );
     let ccLength = cc.length;
@@ -329,10 +350,7 @@ export abstract class SecureMessagingWrapper implements APDUWrapper {
     inputStream.readFully(ciphertext);
     const paddedData = Array.from(
       Buffer.from(
-        cryptoUtils.decryptWith3DES(
-          Buffer.from(ciphertext).toString('hex'),
-          this.ksEnc
-        ),
+        this.decrypt(Buffer.from(ciphertext).toString('hex'), this.ksEnc),
         'hex'
       )
     );

package/src/Shared/EIDReader/smartcards/commandAPDU.ts

@@ -18,7 +18,8 @@ export class CommandAPDU {
     ne?: number
   ) {
     this.nc = dataLength || 0;
-    this.ne = ne || 0;
+    // Java JMRTD uses -1 to mean "no Le field" (ne=0). Guard against negatives.
+    this.ne = ne == null || ne < 0 ? 0 : ne;
     this.apdu = this.buildAPDU(
       cla,
       ins,

package/src/Shared/EIDReader/tlv/tlv.helpers.ts

@@ -88,7 +88,7 @@ export class TLVHelpers extends ASN1Constants {
   private static log(n: number, base: number): number {
     let result = 0;
     while (n > 0) {
-      n = n / base;
+      n = Math.floor(n / base);
       result++;
     }
     return result;

package/src/Shared/EIDReader/tlv/tlv.utils.ts

@@ -6,7 +6,6 @@ import { Buffer } from 'buffer';
 import { TLVHelpers } from './tlv.helpers';
 
 class TLVUtil extends TLVHelpers {
-
   public static wrapDO(tag: number, data: number[]): Uint8Array {
     if (data == null) {
       throw new Error('Data to wrap is null');
@@ -49,7 +48,7 @@ class TLVUtil extends TLVHelpers {
       const actualTag = await tlvInputStream.readTag();
       if (actualTag !== expectedTag) {
         throw new Error(
-          `Expected tag ${expectedTag.toString(16)}, found tag ${actualTag.toString(16)}`
+          `Expected TLV tag 0x${expectedTag.toString(16)}, found 0x${actualTag.toString(16)} in data: ${Buffer.from(wrappedData.slice(0, 16)).toString('hex')}`
         );
       }
 
@@ -61,8 +60,13 @@ class TLVUtil extends TLVHelpers {
       }
       return result;
     } catch (ioe) {
-      // Never happens.
-      throw new Error('Error reading from stream');
+      // Re-throw original error with context rather than masking it
+      if (ioe instanceof Error && ioe.message.includes('Expected TLV tag')) {
+        throw ioe;
+      }
+      throw new Error(
+        `TLV unwrap error (expected tag 0x${expectedTag.toString(16)}): ${ioe instanceof Error ? ioe.message : String(ioe)}`
+      );
     } finally {
       try {
         tlvInputStream.close();
@@ -72,7 +76,6 @@ class TLVUtil extends TLVHelpers {
       }
     }
   }
-
 }
 
 export default TLVUtil;

package/src/Shared/EIDReader/utils/aesCrypto.utils.ts

@@ -0,0 +1,217 @@
+import CryptoJS from 'crypto-js';
+import { Buffer } from 'buffer';
+import 'react-native-get-random-values';
+
+/**
+ * AES cryptographic utilities for PACE protocol.
+ */
+
+/**
+ * Encrypt data using AES in CBC mode with zero IV.
+ */
+export const aesEncryptCBC = (
+  dataHex: string,
+  keyHex: string,
+  ivHex: string = '00000000000000000000000000000000'
+): string => {
+  const data = CryptoJS.enc.Hex.parse(dataHex);
+  const key = CryptoJS.enc.Hex.parse(keyHex);
+  const iv = CryptoJS.enc.Hex.parse(ivHex);
+
+  const encrypted = CryptoJS.AES.encrypt(data, key, {
+    mode: CryptoJS.mode.CBC,
+    padding: CryptoJS.pad.NoPadding,
+    iv,
+  });
+
+  return encrypted.ciphertext.toString(CryptoJS.enc.Hex);
+};
+
+/**
+ * Decrypt data using AES in CBC mode with zero IV.
+ */
+export const aesDecryptCBC = (
+  dataHex: string,
+  keyHex: string,
+  ivHex: string = '00000000000000000000000000000000'
+): string => {
+  const data = CryptoJS.enc.Hex.parse(dataHex);
+  const key = CryptoJS.enc.Hex.parse(keyHex);
+  const iv = CryptoJS.enc.Hex.parse(ivHex);
+
+  const cipherParams = CryptoJS.lib.CipherParams.create({
+    ciphertext: data,
+  });
+
+  const decrypted = CryptoJS.AES.decrypt(cipherParams, key, {
+    mode: CryptoJS.mode.CBC,
+    padding: CryptoJS.pad.NoPadding,
+    iv,
+  });
+
+  return decrypted.toString(CryptoJS.enc.Hex);
+};
+
+/**
+ * Encrypt a single block with AES in ECB mode (for SSC encryption).
+ */
+export const aesEncryptECB = (dataHex: string, keyHex: string): string => {
+  const data = CryptoJS.enc.Hex.parse(dataHex);
+  const key = CryptoJS.enc.Hex.parse(keyHex);
+
+  const encrypted = CryptoJS.AES.encrypt(data, key, {
+    mode: CryptoJS.mode.ECB,
+    padding: CryptoJS.pad.NoPadding,
+  });
+
+  return encrypted.ciphertext.toString(CryptoJS.enc.Hex);
+};
+
+/**
+ * Compute AES CMAC (OMAC1) as defined in RFC 4493.
+ */
+export const aesCMAC = (dataHex: string, keyHex: string): string => {
+  const key = Buffer.from(keyHex, 'hex');
+  const data = Buffer.from(dataHex, 'hex');
+  const blockSize = 16;
+
+  // Step 1: Generate subkeys
+  const zeroBlock = '00000000000000000000000000000000';
+  const L = Buffer.from(aesEncryptECB(zeroBlock, keyHex), 'hex');
+  const K1 = generateSubkey(L);
+  const K2 = generateSubkey(K1);
+
+  // Step 2: Determine if we need to pad
+  const n = data.length === 0 ? 1 : Math.ceil(data.length / blockSize);
+  const lastBlockComplete = data.length > 0 && data.length % blockSize === 0;
+
+  // Step 3: Process last block
+  const lastBlock = Buffer.alloc(blockSize);
+  if (lastBlockComplete) {
+    const start = (n - 1) * blockSize;
+    for (let i = 0; i < blockSize; i++) {
+      lastBlock[i] = data[start + i] ^ K1[i];
+    }
+  } else {
+    // Pad with 10*
+    const start = (n - 1) * blockSize;
+    const remaining = data.length - start;
+    const padded = Buffer.alloc(blockSize);
+    for (let i = 0; i < remaining; i++) {
+      padded[i] = data[start + i];
+    }
+    padded[remaining] = 0x80;
+    for (let i = 0; i < blockSize; i++) {
+      lastBlock[i] = padded[i] ^ K2[i];
+    }
+  }
+
+  // Step 4: CBC-MAC
+  let X = Buffer.alloc(blockSize);
+  for (let i = 0; i < n - 1; i++) {
+    const block = data.subarray(i * blockSize, (i + 1) * blockSize);
+    const Y = Buffer.alloc(blockSize);
+    for (let j = 0; j < blockSize; j++) {
+      Y[j] = X[j] ^ block[j];
+    }
+    X = Buffer.from(aesEncryptECB(Y.toString('hex'), keyHex), 'hex');
+  }
+
+  // Process last block
+  const Y = Buffer.alloc(blockSize);
+  for (let j = 0; j < blockSize; j++) {
+    Y[j] = X[j] ^ lastBlock[j];
+  }
+  const T = aesEncryptECB(Y.toString('hex'), keyHex);
+
+  return T;
+};
+
+function generateSubkey(input: Buffer): Buffer {
+  const blockSize = 16;
+  const Rb = Buffer.alloc(blockSize);
+  Rb[blockSize - 1] = 0x87;
+
+  // Left shift by 1
+  const output = Buffer.alloc(blockSize);
+  const msb = (input[0] & 0x80) !== 0;
+  for (let i = 0; i < blockSize - 1; i++) {
+    output[i] = ((input[i] << 1) | (input[i + 1] >> 7)) & 0xff;
+  }
+  output[blockSize - 1] = (input[blockSize - 1] << 1) & 0xff;
+
+  if (msb) {
+    for (let i = 0; i < blockSize; i++) {
+      output[i] ^= Rb[i];
+    }
+  }
+
+  return output;
+}
+
+/**
+ * Derive AES key from shared secret using KDF as per TR-SAC.
+ *
+ * @param sharedSecretHex the shared secret bytes as hex
+ * @param cipherAlg 'AES' or 'DESede'
+ * @param keyLength 128, 192, or 256
+ * @param mode 1 = ENC, 2 = MAC, 3 = PACE
+ */
+export const deriveKey = (
+  sharedSecretHex: string,
+  cipherAlg: string,
+  keyLength: number,
+  mode: number
+): string => {
+  const input = sharedSecretHex + '000000' + mode.toString(16).padStart(2, '0');
+
+  let hash: string;
+  if (cipherAlg === 'AES' && keyLength > 128) {
+    // Use SHA-256 for AES-192 and AES-256
+    hash = CryptoJS.SHA256(CryptoJS.enc.Hex.parse(input)).toString(
+      CryptoJS.enc.Hex
+    );
+  } else {
+    // Use SHA-1 for DESede and AES-128
+    hash = CryptoJS.SHA1(CryptoJS.enc.Hex.parse(input)).toString(
+      CryptoJS.enc.Hex
+    );
+  }
+
+  if (cipherAlg === 'DESede') {
+    // 3DES: 24-byte key (K1 || K2 || K1)
+    const ka = hash.substring(0, 16);
+    const kb = hash.substring(16, 32);
+    return ka + kb + ka;
+  } else {
+    // AES: return first keyLength/8 bytes
+    const keyBytes = keyLength / 4; // hex chars = keyLength / 8 * 2
+    return hash.substring(0, keyBytes);
+  }
+};
+
+/**
+ * Pad data using ISO 9797-1 method 2 with given block size.
+ */
+export const padISO9797 = (data: Buffer, blockSize: number = 16): Buffer => {
+  const n = data.length;
+  const padLength = blockSize - (n % blockSize);
+  const out = Buffer.alloc(n + padLength);
+  data.copy(out);
+  out[n] = 0x80;
+  return out;
+};
+
+/**
+ * Unpad ISO 9797-1 method 2.
+ */
+export const unpadISO9797 = (data: Buffer): Buffer => {
+  let i = data.length - 1;
+  while (i >= 0 && data[i] === 0x00) {
+    i--;
+  }
+  if (i >= 0 && data[i] === 0x80) {
+    return data.subarray(0, i);
+  }
+  return data;
+};

package/src/Shared/Libs/analytics.utils.ts

@@ -289,6 +289,10 @@ const STEP_EVENT_MAP: Record<
     started: AnalyticsEventName.LIVENESS_CHECK_STARTED,
     completed: AnalyticsEventName.LIVENESS_CHECK_COMPLETED,
   },
+  verbal_consent: {
+    started: AnalyticsEventName.VERBAL_CONSENT_VIDEO_STARTED,
+    completed: AnalyticsEventName.VERBAL_CONSENT_VIDEO_COMPLETED,
+  },
   video_call: {
     started: AnalyticsEventName.VIDEO_CALL_STARTED,
     completed: AnalyticsEventName.VIDEO_CALL_COMPLETED,

package/src/Shared/Libs/contains.ts

@@ -4,56 +4,3 @@ export interface Rect {
   width: number;
   height: number;
 }
-
-interface Contains {
-  outside: Rect;
-  inside: Rect;
-}
-
-export function contains({ outside, inside }: Contains) {
-  const outsideMaxX = outside.minX + outside.width;
-  const insideMaxX = inside.minX + inside.width;
-
-  const outsideMaxY = outside.minY + outside.height;
-  const insideMaxY = inside.minY + inside.height;
-
-  if (inside.minX < outside.minX) {
-    return false;
-  }
-  if (insideMaxX > outsideMaxX) {
-    return false;
-  }
-  if (inside.minY < outside.minY) {
-    return false;
-  }
-  if (insideMaxY > outsideMaxY) {
-    return false;
-  }
-
-  return true;
-}
-
-export function contains2({ outside, inside }: Contains) {
-  const outsideMaxX = outside.minX + outside.width;
-  const insideMaxX = inside.minX + inside.width;
-
-  const outsideMaxY = outside.minY + outside.height;
-  const insideMaxY = inside.minY + inside.height;
-
-  const xIntersect = Math.max(
-    0,
-    Math.min(insideMaxX, outsideMaxX) - Math.max(inside.minX, outside.minX)
-  );
-  const yIntersect = Math.max(
-    0,
-    Math.min(insideMaxY, outsideMaxY) - Math.max(inside.minY, outside.minY)
-  );
-  const intersectArea = xIntersect * yIntersect;
-
-  const insideArea = inside.width * inside.height;
-  const outsideArea = outside.width * outside.height;
-
-  const unionArea = insideArea + outsideArea - intersectArea;
-
-  return unionArea === outsideArea;
-}

package/src/Shared/Libs/country-display.utils.ts

@@ -0,0 +1,55 @@
+import { ISOCountry } from '../EIDReader/data/isoCountry';
+import { UnicodeCountry } from '../EIDReader/data/unicodeCountry';
+
+const COUNTRY_NAME_OVERRIDES: Record<string, string> = {
+  TUR: 'Türkiye',
+};
+
+const findCountryByAlpha3 = (alpha3Code: string) => {
+  return [...UnicodeCountry.VALUES, ...ISOCountry.VALUES].find(
+    (country) => country.toAlpha3Code() === alpha3Code
+  );
+};
+
+export const getLocalizedCountryName = (
+  alpha3Code?: string | null,
+  _language?: string | null
+): string => {
+  if (!alpha3Code) return '';
+
+  const normalizedCode = alpha3Code.trim().toUpperCase();
+  const overrideName = COUNTRY_NAME_OVERRIDES[normalizedCode];
+
+  if (overrideName) {
+    return overrideName;
+  }
+
+  const country = findCountryByAlpha3(normalizedCode);
+  if (!country) {
+    return normalizedCode;
+  }
+
+  if (
+    typeof Intl !== 'undefined' &&
+    'Locale' in Intl &&
+    typeof Intl.Locale === 'function' &&
+    'DisplayNames' in Intl &&
+    typeof Intl.DisplayNames === 'function'
+  ) {
+    const nativeLanguage = new Intl.Locale(
+      `und-${country.toAlpha2Code()}`
+    ).maximize().language;
+
+    if (nativeLanguage) {
+      const nativeName = new Intl.DisplayNames([nativeLanguage], {
+        type: 'region',
+      }).of(country.toAlpha2Code());
+
+      if (nativeName) {
+        return nativeName;
+      }
+    }
+  }
+
+  return country.getName();
+};

package/src/Shared/Libs/crypto.utils.ts

@@ -9,8 +9,8 @@ const getSessionKey = async (apiUrl: string, sessionId: string) => {
   const clientPrivateKey = secp256k1.utils.randomPrivateKey();
   const clientPublicKey = secp256k1.getPublicKey(clientPrivateKey);
   const serverResponse = await httpClient.post<
-    { serverPublicKey: String },
-    { clientPublicKey: String }
+    { serverPublicKey: string },
+    { clientPublicKey: string }
   >(`${apiUrl}/verification-sessions/${sessionId}/auth`, {
     clientPublicKey: Buffer.from(clientPublicKey).toString('hex'),
   });

package/src/Shared/Libs/demo.utils.ts

@@ -36,6 +36,16 @@ const demoSession = {
         },
       },
     },
+    {
+      type: 'VERBAL_CONSENT',
+      required: false,
+      data: {
+        voiceGuidanceActive: true,
+        verbalConsentTitle: 'Verbal Consent',
+        verbalConsentText:
+          'I hereby provide my verbal consent for identity verification purposes. I confirm that all information provided is accurate and complete.',
+      },
+    },
     {
       type: 'IDENTITY_DOCUMENT_SCAN',
       required: false,

package/src/Shared/Libs/http-client.ts

@@ -66,7 +66,10 @@ const request = async <TResponse, TBody>(
 
   console.log(`[HTTP] ${httpMethod} ${url}`);
   if (body) {
-    console.log('[HTTP] Request body:', JSON.stringify(body).substring(0, 200) + '...');
+    console.log(
+      '[HTTP] Request body:',
+      JSON.stringify(body).substring(0, 200) + '...'
+    );
   }
 
   try {
@@ -80,14 +83,19 @@ const request = async <TResponse, TBody>(
 
     statusCode = response.status;
     success = response.ok;
-    console.log(`[HTTP] Response status: ${statusCode} ${response.ok ? '✓' : '✗'}`);
+    console.log(
+      `[HTTP] Response status: ${statusCode} ${response.ok ? '✓' : '✗'}`
+    );
 
     let responseJson = null;
 
     try {
       responseJson = await response.json();
       if (responseJson) {
-        console.log('[HTTP] Response body:', JSON.stringify(responseJson).substring(0, 200) + '...');
+        console.log(
+          '[HTTP] Response body:',
+          JSON.stringify(responseJson).substring(0, 200) + '...'
+        );
       }
     } catch (error) {
       // Invalid JSON response
@@ -214,7 +222,7 @@ const post = <TResponse, TBody>(
 
 const put = <TResponse, TBody>(
   url: string,
-  body?: any,
+  body?: TBody,
   simulatedResponse?: TResponse
 ) => {
   return request<TResponse, TBody>('PUT', url, body, simulatedResponse);

package/src/Shared/Libs/mrz.utils.ts

@@ -114,8 +114,9 @@ const fixMRZ = (rawText: string): string => {
       // Must contain filler characters
       if (!/<+/.test(line)) return false;
 
-      // Prioritize lines starting with I< (document code)
-      if (line.startsWith('I<')) return true;
+      // Lines starting with a valid MRZ document code (ICAO 9303):
+      // I (ID cards), A (residence permits, admin docs), C (crew), P (passport), V (visa)
+      if (/^[IACPV][<A-Z]/.test(line)) return true;
 
       // Or lines with numbers and fillers (second line of TD1: birth date, expiry, etc.)
       if (/\d{5,}/.test(line) && /<{3,}/.test(line)) return true;

package/src/Shared/Libs/status-bar.utils.ts

@@ -1,4 +1,4 @@
-import { StatusBar } from 'react-native';
+import { Platform, StatusBar } from 'react-native';
 import { useEffect } from 'react';
 
 /**
@@ -6,7 +6,9 @@ import { useEffect } from 'react';
  */
 export const configureStatusBarForWhiteBackground = (): void => {
   StatusBar.setBarStyle('dark-content', true);
-  StatusBar.setBackgroundColor('#ffffff', true);
+  if (Platform.OS === 'android') {
+    StatusBar.setBackgroundColor('#ffffff', true);
+  }
 };
 
 /**

package/src/Shared/Services/VideoSessionService.ts

@@ -127,7 +127,7 @@ export class VideoSessionService {
       console.log('[VideoSessionService] Creating SSE connection to:', url);
 
       const es = new EventSource(url);
-      let heartbeatInterval: NodeJS.Timeout | null = null;
+      let heartbeatInterval: ReturnType<typeof setInterval> | null = null;
 
       es.addEventListener('open', () => {
         console.log('[VideoSessionService] Queue SSE connected');

package/src/Shared/Types/analytics.types.ts

@@ -82,6 +82,8 @@ export enum AnalyticsEventName {
   IDENTITY_DOCUMENT_EID_SCAN_COMPLETED = 'identity_document_eid_scan_completed',
   LIVENESS_CHECK_STARTED = 'liveness_check_started',
   LIVENESS_CHECK_COMPLETED = 'liveness_check_completed',
+  VERBAL_CONSENT_VIDEO_STARTED = 'verbal_consent_video_started',
+  VERBAL_CONSENT_VIDEO_COMPLETED = 'verbal_consent_video_completed',
   VIDEO_CALL_STARTED = 'video_call_started',
   VIDEO_CALL_COMPLETED = 'video_call_completed',
 

package/src/Shared/Types/identificationInfo.ts

@@ -14,6 +14,14 @@ export interface IdentificationInfo {
   authToken?: string;
   videoSessionId?: string;
   mediaUploadedDuringVideoCall?: boolean;
+  verbalConsentVideos?: VerbalConsentVideo[];
+}
+
+export interface VerbalConsentVideo {
+  title: string;
+  text: string;
+  videoPath: string;
+  recordedSeconds?: number;
 }
 
 export interface ScannedIdentityDocument {
@@ -42,6 +50,7 @@ export interface WorkflowStep {
     | 'IDENTITY_DOCUMENT_SCAN'
     | 'IDENTITY_DOCUMENT_EID_SCAN'
     | 'LIVENESS_CHECK'
+    | 'VERBAL_CONSENT'
     | 'AML_CHECK'
     | 'VIDEO_CALL';
   data?: {
@@ -61,6 +70,8 @@ export interface WorkflowStep {
     allowedCountries?: 'TUR'[] | null;
     allowedLivenessInstructionTypes?: LivenessInstructionType[] | null;
     voiceGuidanceActive?: boolean;
+    verbalConsentTitle?: string | null;
+    verbalConsentText?: string | null;
   };
   required: boolean;
 }