@trustchex/react-native-sdk 1.334.0 → 1.354.0

package/lib/module/Shared/Libs/camera.utils.js

@@ -1,5 +1,59 @@
 "use strict";
 
+/**
+ * Check if frame is blurry using Laplacian variance
+ * Uses both horizontal and vertical gradients for more accurate blur detection
+ * Lower variance indicates a blurrier image
+ * @param frame - The camera frame to analyze
+ * @param threshold - Variance threshold below which image is considered blurry (default: 10)
+ * @returns true if image is blurry, false otherwise
+ */
+const isBlurry = (frame, threshold = 10) => {
+  'worklet';
+
+  const buffer = frame.toArrayBuffer();
+  const data = new Uint8Array(buffer);
+  const width = frame.width;
+  const height = frame.height;
+  let sum = 0;
+  let sumSq = 0;
+  let count = 0;
+
+  // Sample central 50% region (matching Flutter algorithm)
+  const startY = Math.floor(height / 4);
+  const endY = Math.floor(3 * height / 4) - 1;
+  const startX = Math.floor(width / 4);
+  const endX = Math.floor(3 * width / 4) - 1;
+
+  // Sample at 5-pixel intervals for better accuracy (matching Flutter)
+  for (let y = startY; y < endY; y += 5) {
+    for (let x = startX; x < endX; x += 5) {
+      const idx = y * width + x;
+      const idxRight = idx + 1;
+      const idxDown = idx + width;
+
+      // Check bounds for both horizontal and vertical neighbors
+      if (idxRight < data.length && idxDown < data.length && data[idx] !== undefined && data[idxRight] !== undefined && data[idxDown] !== undefined) {
+        // Horizontal gradient
+        const diffH = Math.abs(data[idx] - data[idxRight]);
+        // Vertical gradient
+        const diffV = Math.abs(data[idx] - data[idxDown]);
+        // Combined Laplacian-like measure
+        const laplacian = diffH + diffV;
+        sum += laplacian;
+        sumSq += laplacian * laplacian;
+        count++;
+      }
+    }
+  }
+  if (count === 0) return false;
+
+  // Calculate variance: E[X²] - E[X]²
+  const mean = sum / count;
+  const variance = sumSq / count - mean * mean;
+  return variance < threshold;
+};
+
 /**
  * Get average brightness for entire frame (center area)
  */
@@ -85,4 +139,170 @@ const isCircularRegionBright = (frame, circleRect, threshold = 60) => {
 
   return getCircularRegionBrightness(frame, circleRect) > threshold;
 };
-export { isFrameBright, getAverageBrightness, getCircularRegionBrightness, isCircularRegionBright };
+
+/**
+ * Get average brightness for a specific rectangular region
+ */
+const getRegionBrightness = (frame, bounds) => {
+  'worklet';
+
+  const buffer = frame.toArrayBuffer();
+  const data = new Uint8Array(buffer);
+  const width = frame.width;
+  const height = frame.height;
+  const minX = Math.max(0, Math.floor(bounds.minX));
+  const maxX = Math.min(width - 1, Math.floor(bounds.minX + bounds.width));
+  const minY = Math.max(0, Math.floor(bounds.minY));
+  const maxY = Math.min(height - 1, Math.floor(bounds.minY + bounds.height));
+  let luminanceSum = 0;
+  let pixelCount = 0;
+  for (let y = minY; y <= maxY; y++) {
+    for (let x = minX; x <= maxX; x++) {
+      const index = y * width + x;
+      if (data[index] !== undefined) {
+        luminanceSum += data[index];
+        pixelCount++;
+      }
+    }
+  }
+  return pixelCount > 0 ? luminanceSum / pixelCount : 0;
+};
+
+/**
+ * Calculate adaptive exposure step based on distance from target brightness
+ * Uses smooth scaling to prevent abrupt exposure changes that could cause dark frames
+ */
+const calculateExposureStep = (currentBrightness, targetBrightness) => {
+  'worklet';
+
+  const difference = Math.abs(targetBrightness - currentBrightness);
+  // Use smaller steps for smoother transitions: max 2, min 1
+  // Use floor + 1 to ensure at least step of 1 and prevent over-correction
+  const step = Math.min(2, Math.max(1, Math.floor(difference / 25)));
+  return step;
+};
+
+/**
+ * Get the center point of the scan area
+ * Scan area is typically 36%-64% of vertical space
+ */
+const getScanAreaCenterPoint = (width, height) => {
+  const scanAreaTop = height * 0.36;
+  const scanAreaBottom = height * 0.64;
+  const scanAreaCenterY = (scanAreaTop + scanAreaBottom) / 2;
+  const scanAreaCenterX = width / 2;
+  return {
+    x: scanAreaCenterX,
+    y: scanAreaCenterY
+  };
+};
+
+/**
+ * Document dimensions (in mm) for reference
+ */
+const DOCUMENT_DIMENSIONS = {
+  ID_CARD: {
+    width: 85.6,
+    height: 53.98,
+    ratio: 1.586
+  },
+  PASSPORT: {
+    width: 125,
+    height: 88,
+    ratio: 1.42
+  }
+};
+
+/**
+ * Detected document information
+ */
+
+/**
+ * Detect document contours and estimate document type based on aspect ratio
+ * This is a simplified detection that looks for rectangular contours in the scan area
+ * @param frame - The camera frame to analyze
+ * @param scanAreaBounds - The bounds of the scan area {x, y, width, height}
+ * @returns Detected document info or null if no document detected
+ */
+const detectDocumentInFrame = (frame, scanAreaBounds) => {
+  'worklet';
+
+  // For now, we'll use a simple edge-based detection
+  // In production, this would integrate with OpenCV findContours
+  // This is a placeholder that estimates based on brightness patterns
+  const buffer = frame.toArrayBuffer();
+  const data = new Uint8Array(buffer);
+  const frameWidth = frame.width;
+  const frameHeight = frame.height;
+
+  // Sample edges of scan area to detect document boundaries
+  const scanX = Math.floor(scanAreaBounds.x * frameWidth);
+  const scanY = Math.floor(scanAreaBounds.y * frameHeight);
+  const scanWidth = Math.floor(scanAreaBounds.width * frameWidth);
+  const scanHeight = Math.floor(scanAreaBounds.height * frameHeight);
+
+  // Calculate average brightness in scan area to detect presence of document
+  // Documents typically have good contrast against backgrounds
+  let totalBrightness = 0;
+  let sampleCount = 0;
+  const sampleStep = 20; // Sample every 20 pixels for performance
+
+  // Sample brightness across the scan area
+  for (let y = scanY; y < scanY + scanHeight; y += sampleStep) {
+    for (let x = scanX; x < scanX + scanWidth; x += sampleStep) {
+      const idx = y * frameWidth + x;
+      if (idx >= 0 && idx < data.length) {
+        totalBrightness += data[idx];
+        sampleCount++;
+      }
+    }
+  }
+  const avgBrightness = sampleCount > 0 ? totalBrightness / sampleCount : 0;
+
+  // Calculate standard deviation to measure contrast
+  let variance = 0;
+  for (let y = scanY; y < scanY + scanHeight; y += sampleStep) {
+    for (let x = scanX; x < scanX + scanWidth; x += sampleStep) {
+      const idx = y * frameWidth + x;
+      if (idx >= 0 && idx < data.length) {
+        const diff = data[idx] - avgBrightness;
+        variance += diff * diff;
+      }
+    }
+  }
+  const stdDev = sampleCount > 0 ? Math.sqrt(variance / sampleCount) : 0;
+
+  // Document is present if there's ANY reasonable content in scan area
+  // Lower threshold: stdDev > 10 indicates some content (not blank surface)
+  // Brightness between 20-240 covers most lighting conditions
+  const documentPresent = stdDev > 10 && avgBrightness > 20 && avgBrightness < 240;
+  if (!documentPresent) {
+    return null;
+  }
+
+  // Default to ID_CARD since scan area matches ID card proportions
+  // Passport detection would require actual contour detection
+  const type = 'ID_CARD';
+  const confidence = Math.min(1, stdDev / 50);
+
+  // Calculate how much of frame the document occupies
+  const framePercentage = scanWidth * scanHeight / (frameWidth * frameHeight);
+  const aspectRatio = scanWidth / scanHeight;
+
+  // Determine size feedback based on contrast level
+  // Higher contrast usually means document is closer/larger
+  let size = 'GOOD';
+  if (stdDev < 25) {
+    size = 'TOO_SMALL'; // Low contrast - probably far away
+  } else if (stdDev > 80) {
+    size = 'TOO_LARGE'; // Very high contrast - probably too close
+  }
+  return {
+    type,
+    size,
+    aspectRatio,
+    confidence: Math.min(1, confidence),
+    framePercentage
+  };
+};
+export { isBlurry, isFrameBright, getAverageBrightness, getCircularRegionBrightness, isCircularRegionBright, getRegionBrightness, calculateExposureStep, getScanAreaCenterPoint, detectDocumentInFrame, DOCUMENT_DIMENSIONS };

package/lib/module/Shared/Libs/frame-enhancement.utils.js

@@ -0,0 +1,133 @@
+"use strict";
+
+import { ColorConversionCodes, DataTypes, ObjectType, OpenCV } from 'react-native-fast-opencv';
+import { ENHANCEMENT_CONFIG } from "../Config/camera-enhancement.config.js";
+
+// Cast OpenCV for methods not in type definitions
+const OpenCVAny = OpenCV;
+
+/**
+ * Convert YUV frame to BGR Mat for OpenCV processing
+ */
+const convertYUVToBGR = frame => {
+  'worklet';
+
+  const buffer = frame.toArrayBuffer();
+  const data = new Uint8Array(buffer);
+  const width = frame.width;
+  const height = frame.height;
+
+  // Create YUV Mat from frame buffer
+  const yuvMat = OpenCV.createObject(ObjectType.Mat, height + height / 2, width, DataTypes.CV_8UC1);
+
+  // Copy frame data to YUV Mat
+  OpenCVAny.invoke('matSetData', yuvMat, data);
+
+  // Convert YUV to BGR
+  const bgrMat = OpenCV.createObject(ObjectType.Mat, height, width, DataTypes.CV_8UC3);
+  OpenCV.invoke('cvtColor', yuvMat, bgrMat, ColorConversionCodes.COLOR_YUV2BGR_NV21);
+  return bgrMat;
+};
+
+/**
+ * Apply CLAHE (Contrast Limited Adaptive Histogram Equalization) to enhance frame
+ * This improves text and face recognition in varying lighting conditions
+ */
+const enhanceFrameForOCR = (frame, options) => {
+  'worklet';
+
+  const clipLimit = options?.clipLimit ?? ENHANCEMENT_CONFIG.contrast.clahe.clipLimit;
+  const tileGridSize = options?.tileGridSize ?? ENHANCEMENT_CONFIG.contrast.clahe.tileGridSize[0];
+  try {
+    // 1. Convert YUV to BGR
+    const bgrMat = convertYUVToBGR(frame);
+
+    // 2. Convert BGR to LAB color space (better for luminance enhancement)
+    const labMat = OpenCV.createObject(ObjectType.Mat, frame.height, frame.width, DataTypes.CV_8UC3);
+    OpenCV.invoke('cvtColor', bgrMat, labMat, ColorConversionCodes.COLOR_BGR2Lab);
+
+    // 3. Split LAB channels
+    const channels = OpenCVAny.invoke('split', labMat);
+    const lChannel = channels[0]; // Luminance channel
+    const aChannel = channels[1]; // a channel
+    const bChannel = channels[2]; // b channel
+
+    // 4. Apply CLAHE to L channel
+    const clahe = OpenCVAny.invoke('createCLAHE', clipLimit, [tileGridSize, tileGridSize]);
+    const enhancedL = OpenCV.createObject(ObjectType.Mat, frame.height, frame.width, DataTypes.CV_8UC1);
+    OpenCVAny.invoke('apply', clahe, lChannel, enhancedL);
+
+    // 5. Merge enhanced L channel with original a and b channels
+    const enhancedLab = OpenCVAny.invoke('merge', [enhancedL, aChannel, bChannel]);
+
+    // 6. Convert back to BGR
+    const enhancedBGR = OpenCV.createObject(ObjectType.Mat, frame.height, frame.width, DataTypes.CV_8UC3);
+    OpenCV.invoke('cvtColor', enhancedLab, enhancedBGR, ColorConversionCodes.COLOR_Lab2BGR);
+
+    // Cleanup intermediate Mats
+    OpenCVAny.invoke('delete', bgrMat);
+    OpenCVAny.invoke('delete', labMat);
+    OpenCVAny.invoke('delete', lChannel);
+    OpenCVAny.invoke('delete', aChannel);
+    OpenCVAny.invoke('delete', bChannel);
+    OpenCVAny.invoke('delete', enhancedL);
+    OpenCVAny.invoke('delete', enhancedLab);
+    return enhancedBGR;
+  } catch (error) {
+    console.warn('Error enhancing frame:', error);
+    // Return original frame converted to BGR if enhancement fails
+    return convertYUVToBGR(frame);
+  }
+};
+
+/**
+ * Apply sharpening to enhance text clarity
+ * Uses unsharp mask technique
+ */
+const sharpenForText = (mat, amount = 1.5) => {
+  'worklet';
+
+  try {
+    const blurred = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8UC3);
+
+    // Apply Gaussian blur
+    OpenCVAny.invoke('GaussianBlur', mat, blurred, [0, 0], 3.0);
+
+    // Create sharpened image: original * (1 + amount) - blurred * amount
+    const sharpened = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8UC3);
+    OpenCV.invoke('addWeighted', mat, 1.0 + amount, blurred, -amount, 0, sharpened);
+
+    // Cleanup
+    OpenCVAny.invoke('delete', blurred);
+    return sharpened;
+  } catch (error) {
+    console.warn('Error sharpening frame:', error);
+    return mat;
+  }
+};
+
+/**
+ * Determine if frame should be enhanced based on current scanning state
+ */
+const shouldEnhanceFrame = (nextStep, detectedFaces, mrzRetryCount) => {
+  'worklet';
+
+  const config = ENHANCEMENT_CONFIG.contrast.applyWhen;
+
+  // Always enhance for document back side (MRZ scanning)
+  if (config.documentBackSide && nextStep === 'SCAN_ID_BACK') {
+    return true;
+  }
+
+  // Enhance if faces are failing to detect on front/passport
+  if (config.faceFailing && nextStep === 'SCAN_ID_FRONT_OR_PASSPORT' && detectedFaces === 0) {
+    return true;
+  }
+
+  // Enhance if MRZ detection is failing
+  if (config.mrzFailing && mrzRetryCount >= config.retryThreshold) {
+    return true;
+  }
+  return false;
+};
+export { convertYUVToBGR, enhanceFrameForOCR, sharpenForText, shouldEnhanceFrame };

package/lib/module/Shared/Libs/mrz.utils.js

@@ -53,13 +53,110 @@ const getMRZText = fixedText => {
   }
   return null;
 };
+
+/**
+ * Apply common OCR corrections for MRZ text
+ * Common confusions: 0/O, 1/I, 8/B, 5/S, 2/Z
+ */
+const applyOCRCorrections = mrzText => {
+  const corrections = [];
+
+  // Common OCR substitutions to try
+  // In MRZ: letters should be in name fields, numbers in date/checksum fields
+  const substitutions = [
+  // Try replacing O with 0 in numeric positions (dates, checksums)
+  {
+    from: /O/g,
+    to: '0'
+  },
+  // Try replacing 0 with O in alphabetic positions (names, country codes)
+  {
+    from: /0/g,
+    to: 'O'
+  },
+  // I and 1 confusion
+  {
+    from: /I(?=\d)/g,
+    to: '1'
+  },
+  // I followed by digit -> likely 1
+  {
+    from: /1(?=[A-Z])/g,
+    to: 'I'
+  },
+  // 1 followed by letter -> likely I
+  // B and 8 confusion
+  {
+    from: /B(?=\d)/g,
+    to: '8'
+  }, {
+    from: /8(?=[A-Z])/g,
+    to: 'B'
+  },
+  // S and 5 confusion
+  {
+    from: /S(?=\d)/g,
+    to: '5'
+  }, {
+    from: /5(?=[A-Z])/g,
+    to: 'S'
+  },
+  // Z and 2 confusion
+  {
+    from: /Z(?=\d)/g,
+    to: '2'
+  }, {
+    from: /2(?=[A-Z])/g,
+    to: 'Z'
+  }];
+  for (const sub of substitutions) {
+    const corrected = mrzText.replace(sub.from, sub.to);
+    if (corrected !== mrzText) {
+      corrections.push(corrected);
+    }
+  }
+  return corrections;
+};
 const getMRZData = ocrText => {
   const fixedText = fixMRZ(ocrText);
   const mrzText = getMRZText(fixedText);
   if (mrzText) {
-    const parsedResult = parse(mrzText, {
+    // First attempt with original text
+    let parsedResult = parse(mrzText, {
       autocorrect: true
     });
+
+    // Check if parse is valid with all required fields
+    const isValidParse = result => {
+      return result.valid && result.fields.firstName && result.fields.lastName && result.fields.birthDate && result.fields.expirationDate && result.fields.documentNumber && result.fields.issuingState;
+    };
+    if (isValidParse(parsedResult)) {
+      return {
+        mrzText,
+        parsedResult
+      };
+    }
+
+    // If not valid, try OCR corrections
+    const corrections = applyOCRCorrections(mrzText);
+    for (const correctedMRZ of corrections) {
+      try {
+        const correctedResult = parse(correctedMRZ, {
+          autocorrect: true
+        });
+        if (isValidParse(correctedResult)) {
+          console.log('[MRZ] OCR correction applied successfully');
+          return {
+            mrzText: correctedMRZ,
+            parsedResult: correctedResult
+          };
+        }
+      } catch (e) {
+        // Continue trying other corrections
+      }
+    }
+
+    // Return original result even if not fully valid (for partial matches)
     if (parsedResult.fields.firstName && parsedResult.fields.lastName && parsedResult.fields.birthDate && parsedResult.fields.expirationDate && parsedResult.fields.documentNumber && parsedResult.fields.issuingState) {
       return {
         mrzText,

package/lib/module/Translation/Resources/en.js

@@ -91,6 +91,11 @@ export default {
   'eidScannerScreen.readingDocument': 'Please hold steady and wait until the reading process is complete.',
   'eidScannerScreen.checkYourInformation': "Please review your information. To continue, press 'Approve and Continue'.",
   'eidScannerScreen.approveAndContinue': 'Approve and Continue',
+  'eidScannerScreen.connecting': 'Connecting to chip...',
+  'eidScannerScreen.readingMRZ': 'Reading document information...',
+  'eidScannerScreen.readingFaceImage': 'Reading photo...',
+  'eidScannerScreen.completing': 'Completing scan...',
+  'eidScannerScreen.progress': 'Progress',
   'identityDocumentCamera.guideHeader': 'Is Your Identity Document Ready?',
   'identityDocumentCamera.guideText': 'Before you begin, please note the following:',
   'identityDocumentCamera.guidePoint1': 'The document must be clear and legible',
@@ -102,6 +107,31 @@ export default {
   'identityDocumentCamera.alignIDFrontSide': 'Align the front side of your identity document with the camera.',
   'identityDocumentCamera.alignIDBackSide': 'Align the back side of your identity document with the camera.',
   'identityDocumentCamera.scanCompleted': 'Scan completed successfully.',
+  'identityDocumentCamera.frontSideScanned': 'Front side scanned!',
+  'identityDocumentCamera.passportScanned': 'Passport scanned!',
+  'identityDocumentCamera.backSideScanned': 'Back side scanned!',
+  'identityDocumentCamera.hologramVerified': 'Scanned!',
+  'identityDocumentCamera.searchingDocument': 'Position your document inside the frame',
+  'identityDocumentCamera.faceDetected': 'Photo detected! Hold steady...',
+  'identityDocumentCamera.readingDocument': 'Reading document...',
+  'identityDocumentCamera.processing': 'Processing...',
+  'identityDocumentCamera.stepProgress': 'Step {{current}} of {{total}}',
+  'identityDocumentCamera.frontSide': 'Front Side',
+  'identityDocumentCamera.backSide': 'Back Side',
+  'identityDocumentCamera.hologramCheck': 'Hologram Verification',
+  'identityDocumentCamera.keepSteady': 'Keep the document steady',
+  'identityDocumentCamera.avoidBlur': 'Hold steady or move document away to refocus',
+  'identityDocumentCamera.wrongSideFront': 'Wrong side! Please show the front side',
+  'identityDocumentCamera.wrongSideBack': 'Wrong side! Please flip to the back side',
+  'identityDocumentCamera.idCardDetected': 'ID card detected',
+  'identityDocumentCamera.idCardFrontDetected': 'ID card front detected! Hold steady...',
+  'identityDocumentCamera.passportDetected': 'Passport detected! Hold steady...',
+  'identityDocumentCamera.moveCloser': 'Move closer to the document',
+  'identityDocumentCamera.moveFarther': 'Move farther from the document',
+  'identityDocumentCamera.documentTooSmall': 'Document too small - move closer',
+  'identityDocumentCamera.documentTooLarge': 'Document too large - move back',
+  'identityDocumentCamera.holdSteady': 'Hold steady',
+  'identityDocumentCamera.centerDocument': 'Center the document in frame',
   'navigationManager.skipStepWarning': 'It is recommended to complete this step. Are you sure you want to skip it?',
   'navigationManager.skipStepLabel': 'Skip This Step'
 };

package/lib/module/Translation/Resources/tr.js

@@ -91,6 +91,11 @@ export default {
   'eidScannerScreen.readingDocument': 'Lütfen sabit tutun ve okuma işlemi tamamlanana kadar bekleyin.',
   'eidScannerScreen.checkYourInformation': "Lütfen bilgilerinizi kontrol edin. Devam etmek için 'Onayla ve Devam Et' düğmesine basın.",
   'eidScannerScreen.approveAndContinue': 'Onayla ve Devam Et',
+  'eidScannerScreen.connecting': 'Çipe bağlanılıyor...',
+  'eidScannerScreen.readingMRZ': 'Belge bilgileri okunuyor...',
+  'eidScannerScreen.readingFaceImage': 'Fotoğraf okunuyor...',
+  'eidScannerScreen.completing': 'Tarama tamamlanıyor...',
+  'eidScannerScreen.progress': 'İlerleme',
   'identityDocumentCamera.guideHeader': 'Kimlik Belgeniz Hazır Mı?',
   'identityDocumentCamera.guideText': 'Başlamadan önce lütfen aşağıdaki hususlara dikkat edin:',
   'identityDocumentCamera.guidePoint1': 'Belge açık ve okunaklı olmalı',
@@ -102,6 +107,31 @@ export default {
   'identityDocumentCamera.alignIDFrontSide': 'Kimlik belgenizin ön yüzünü kameraya hizalayın.',
   'identityDocumentCamera.alignIDBackSide': 'Kimlik belgenizin arka yüzünü kameraya hizalayın.',
   'identityDocumentCamera.scanCompleted': 'Tarama başarıyla tamamlandı.',
+  'identityDocumentCamera.frontSideScanned': 'Ön yüz tarandı!',
+  'identityDocumentCamera.passportScanned': 'Pasaport tarandı!',
+  'identityDocumentCamera.backSideScanned': 'Arka yüz tarandı!',
+  'identityDocumentCamera.hologramVerified': 'Tarandı!',
+  'identityDocumentCamera.searchingDocument': 'Belgenizi çerçeve içine konumlandırın',
+  'identityDocumentCamera.faceDetected': 'Fotoğraf algılandı! Sabit tutun...',
+  'identityDocumentCamera.readingDocument': 'Belge okunuyor...',
+  'identityDocumentCamera.processing': 'İşleniyor...',
+  'identityDocumentCamera.stepProgress': 'Adım {{current}} / {{total}}',
+  'identityDocumentCamera.frontSide': 'Ön Yüz',
+  'identityDocumentCamera.backSide': 'Arka Yüz',
+  'identityDocumentCamera.hologramCheck': 'Hologram Doğrulama',
+  'identityDocumentCamera.keepSteady': 'Belgeyi sabit tutun',
+  'identityDocumentCamera.avoidBlur': 'Sabit tutun veya yeniden odaklamak için belgeyi uzaklaştırın',
+  'identityDocumentCamera.wrongSideFront': 'Yanlış yüz! Lütfen ön yüzü gösterin',
+  'identityDocumentCamera.wrongSideBack': 'Yanlış yüz! Lütfen arka yüze çevirin',
+  'identityDocumentCamera.idCardDetected': 'Kimlik kartı algılandı',
+  'identityDocumentCamera.idCardFrontDetected': 'Kimlik kartı ön yüzü algılandı! Sabit tutun...',
+  'identityDocumentCamera.passportDetected': 'Pasaport algılandı! Sabit tutun...',
+  'identityDocumentCamera.moveCloser': 'Belgeye daha yakın gelin',
+  'identityDocumentCamera.moveFarther': 'Belgeden daha uzaklaşın',
+  'identityDocumentCamera.documentTooSmall': 'Belge çok küçük - yaklaşın',
+  'identityDocumentCamera.documentTooLarge': 'Belge çok büyük - uzaklaşın',
+  'identityDocumentCamera.holdSteady': 'Sabit tutun',
+  'identityDocumentCamera.centerDocument': 'Belgeyi çerçevede ortalayın',
   'navigationManager.skipStepWarning': 'Bu adımı tamamlamanız önerilir. Adımı atlamak istediğinize emin misiniz?',
   'navigationManager.skipStepLabel': 'Bu Adımı Atla'
 };