@trustchex/react-native-sdk 1.512.0 → 1.513.0

package/src/Shared/Libs/addressProofHeuristic.ts

@@ -0,0 +1,197 @@
+/**
+ * On-device, best-effort check that a captured address-proof photo actually
+ * looks like a document containing the holder's NAME and ADDRESS information.
+ *
+ * MASAK Tebliğ No. 32 Art. 4/C(1)(d) requires an OPERATOR to manually review the
+ * address proof, so this is only a soft quality gate: it nudges the user to
+ * retake an obviously-wrong photo (a selfie, a blank wall, the wrong document)
+ * before it wastes an operator's time. A negative result NEVER blocks the user.
+ *
+ * Input is the OCR text recognised on the captured proof photo (full image,
+ * via the native still-image recognizer), plus the holder's name and any chip
+ * (DG11) address tokens — no extra ML models, no network, works offline.
+ */
+
+import { foldDiacritics } from './vizName';
+
+export interface AddressProofSignals {
+  /** True if the holder's name appears (fuzzily) in the recognised text. */
+  hasName: boolean;
+  /** True if address-like signals (postal code, street/place keywords, or chip
+   *  address tokens) appear in the recognised text. */
+  hasAddress: boolean;
+  /** True when both are present — the photo plausibly is an address document. */
+  ok: boolean;
+}
+
+export interface AddressProofContext {
+  /** Holder name parts (first/last, any Unicode form). Used to look for the name. */
+  nameParts: Array<string | null | undefined>;
+  /** The chip's DG11 address, if any — its tokens are strong address evidence. */
+  chipAddress?: string | null;
+}
+
+/**
+ * Address keywords across the languages this SDK targets (TR + common EU/EN).
+ * Matched as whole words after normalisation. A Set so membership is O(1) and
+ * duplicates collapse. Deliberately broad — recall over precision, since the
+ * operator makes the real decision — BUT we exclude very short tokens
+ * ('NO','IL','ST','SK','RD') that collide with everyday non-address text and
+ * would make the address signal fire on almost any document.
+ */
+const ADDRESS_KEYWORDS = new Set([
+  // Turkish
+  'MAH',
+  'MAHALLE',
+  'MAHALLESI',
+  'CAD',
+  'CADDE',
+  'CADDESI',
+  'SOK',
+  'SOKAK',
+  'APT',
+  'DAIRE',
+  'BINA',
+  'BLOK',
+  'KAPI',
+  'ILCE',
+  'SEHIR',
+  'POSTA',
+  'ADRES',
+  'BULVAR',
+  'BULVARI',
+  'SITE',
+  // English / generic
+  'STREET',
+  'AVENUE',
+  'AVE',
+  'ROAD',
+  'LANE',
+  'BLVD',
+  'BOULEVARD',
+  'APARTMENT',
+  'SUITE',
+  'FLOOR',
+  'BUILDING',
+  'CITY',
+  'TOWN',
+  'POSTAL',
+  'POSTCODE',
+  'ZIP',
+  'ADDRESS',
+  'DISTRICT',
+  'PROVINCE',
+  // German (passports/utility bills are common)
+  'STRASSE',
+  'PLATZ',
+  'GASSE',
+  'STADT',
+  'PLZ',
+  'ADRESSE',
+]);
+
+/**
+ * Strip diacritics + uppercase so "Şişli" ~ "SISLI" and OCR variants align.
+ * Shares the SDK's canonical diacritic fold ({@link foldDiacritics}) so the
+ * address path and the VIZ-name path stay in sync (ß→SS, ø→O, ł→L, …).
+ */
+function normalize(input: string): string {
+  return foldDiacritics(input);
+}
+
+/** Split into alphabetic / numeric tokens, dropping punctuation. */
+function tokenize(input: string): string[] {
+  return normalize(input)
+    .split(/[^A-Z0-9]+/)
+    .filter((t) => t.length > 0);
+}
+
+/**
+ * A postal-code-like run, REQUIRED to be flanked by address-ish context to
+ * avoid matching invoice/account/order numbers. We accept a 4–6 digit run only
+ * when it is not part of a longer digit run (so account numbers like 1234567890
+ * don't count) — `\b\d{4,6}\b` already excludes longer runs.
+ */
+const POSTAL_RE = /\b\d{4,6}\b/;
+
+/**
+ * Levenshtein distance ≤ 1 check (single insert/delete/substitute), used to
+ * tolerate one OCR slip in a name token (e.g. "SAYGI" read as "SAYGL").
+ */
+function withinEditDistance1(a: string, b: string): boolean {
+  if (a === b) return true;
+  const la = a.length;
+  const lb = b.length;
+  if (Math.abs(la - lb) > 1) return false;
+  // Substitution (equal length): at most one differing char.
+  if (la === lb) {
+    let diffs = 0;
+    for (let i = 0; i < la; i++) {
+      if (a[i] !== b[i] && ++diffs > 1) return false;
+    }
+    return true;
+  }
+  // Insertion/deletion (length differs by 1): the shorter is a subsequence
+  // of the longer with exactly one extra char.
+  const [short, long] = la < lb ? [a, b] : [b, a];
+  let i = 0;
+  let j = 0;
+  let skips = 0;
+  while (i < short.length && j < long.length) {
+    if (short[i] === long[j]) {
+      i++;
+      j++;
+    } else if (++skips > 1) {
+      return false;
+    } else {
+      j++;
+    }
+  }
+  return true;
+}
+
+/**
+ * Assess whether the OCR text from a captured proof plausibly contains the
+ * holder's name and an address. Best-effort and tolerant of OCR noise.
+ */
+export function assessAddressProof(
+  recognizedText: string | undefined | null,
+  ctx: AddressProofContext
+): AddressProofSignals {
+  const text = (recognizedText ?? '').trim();
+  if (!text) {
+    // No text recognised at all (blank/sideways/too blurry) — fail soft.
+    return { hasName: false, hasAddress: false, ok: false };
+  }
+
+  const normText = normalize(text);
+  const tokens = tokenize(text);
+  const textTokens = new Set(tokens);
+
+  // --- Name: a name part (>=3 chars) appears as a token in the OCR text,
+  //     tolerating a single OCR slip (edit distance ≤1) on tokens of 4+ chars
+  //     so the holder's own document isn't flagged over one misread letter. ---
+  const nameTokens = ctx.nameParts
+    .flatMap((p) => (p ? tokenize(p) : []))
+    .filter((t) => t.length >= 3 && !/^\d+$/.test(t));
+  const hasName = nameTokens.some(
+    (n) =>
+      textTokens.has(n) ||
+      (n.length >= 4 && tokens.some((t) => withinEditDistance1(n, t)))
+  );
+
+  // --- Address: postal code OR an address keyword OR overlap with the chip
+  //     address tokens (a strong, holder-specific signal). ---
+  const hasPostal = POSTAL_RE.test(normText);
+  const hasKeyword = tokens.some((t) => ADDRESS_KEYWORDS.has(t));
+
+  const chipTokens = (ctx.chipAddress ? tokenize(ctx.chipAddress) : []).filter(
+    (t) => t.length >= 3
+  );
+  const chipOverlap = chipTokens.filter((t) => textTokens.has(t)).length;
+  const hasChipMatch = chipOverlap >= 2; // ≥2 chip-address words present
+
+  const hasAddress = hasPostal || hasKeyword || hasChipMatch;
+
+  return { hasName, hasAddress, ok: hasName && hasAddress };
+}

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

@@ -56,6 +56,11 @@ const demoSession = {
       required: false,
       data: { voiceGuidanceActive: true },
     },
+    {
+      type: 'ADDRESS_CAPTURE',
+      required: false,
+      data: {},
+    },
     {
       type: 'LIVENESS_CHECK',
       required: false,

package/src/Shared/Libs/sendDiagnosticReport.ts

@@ -17,6 +17,7 @@
  *  - `scanDataJson`   — the scanned identity data (PII),
  *  - `images`         — the captured document/face images (base64, PII).
  */
+import { NativeModules } from 'react-native';
 import { diagnostics } from './diagnostics';
 import { gatherDeviceDetails } from './native-device-info.utils';
 import {
@@ -37,6 +38,56 @@ export interface DiagnosticImage {
   mime: 'jpg' | 'png';
 }
 
+// Diagnostic images are for a support inbox, not archival — full capture
+// resolution is wasteful and makes the upload (and the on-JS-thread
+// JSON.stringify of the payload) slow. Cap the longest edge and recompress so
+// the whole bundle is a few hundred KB instead of several MB.
+const DIAGNOSTIC_IMAGE_MAX_DIM = 1024;
+const DIAGNOSTIC_IMAGE_JPEG_QUALITY = 70;
+
+interface OpenCVNativeModule {
+  resizeAndCompress?: (
+    base64: string,
+    maxDim: number,
+    quality: number
+  ) => Promise<string>;
+}
+
+/**
+ * Downscale + recompress the report images off the JS thread (native OpenCV
+ * module), in parallel. Best-effort per image: if the native method is missing
+ * or throws, that image falls back to its original base64 so the report still
+ * sends. Already-small images are returned near-unchanged (native never
+ * upscales).
+ */
+async function shrinkDiagnosticImages(
+  images: DiagnosticImage[]
+): Promise<DiagnosticImage[]> {
+  const opencv = (NativeModules as { OpenCVModule?: OpenCVNativeModule })
+    .OpenCVModule;
+  if (!opencv?.resizeAndCompress) return images;
+  return Promise.all(
+    images.map(async (img) => {
+      if (!img.base64) return img;
+      try {
+        const shrunk = await opencv.resizeAndCompress!(
+          img.base64,
+          DIAGNOSTIC_IMAGE_MAX_DIM,
+          DIAGNOSTIC_IMAGE_JPEG_QUALITY
+        );
+        // On any failure the native side resolves the ORIGINAL base64 unchanged
+        // (same string) — in that case keep the original mime, since a PNG that
+        // failed to shrink is still PNG. Only when it actually recompressed (a
+        // new string) is the output guaranteed JPEG, so relabel then.
+        if (!shrunk || shrunk === img.base64) return img;
+        return { ...img, base64: shrunk, mime: 'jpg' as const };
+      } catch {
+        return img;
+      }
+    })
+  );
+}
+
 export interface SendDiagnosticParams {
   /** Backend base URL (same value the SDK was initialised with). */
   baseUrl: string;
@@ -110,6 +161,15 @@ export const sendDiagnosticReport = async (
         ? `NFC-${(nfc.errorCategory ?? 'reading_error').toUpperCase()}${failingSw ? `-${failingSw}` : ''}`
         : null;
 
+    // Shrink images natively before they go into the (JS-stringified) payload —
+    // this is the dominant cost of the send, not the proof-of-work.
+    const shrunkImages = await shrinkDiagnosticImages(
+      images.filter((img) => img.base64)
+    );
+    if (shouldCancel?.()) {
+      return { uploaded: false, cancelled: true };
+    }
+
     const payload = {
       // metadata (stored in plaintext, no PII)
       platform: device.platform,
@@ -123,13 +183,11 @@ export const sendDiagnosticReport = async (
       // full report (PII, encrypted at rest by the backend)
       diagnosticsJson: report.diagnosticsJson,
       scanDataJson: report.scanDataJson,
-      images: images
-        .filter((img) => img.base64)
-        .map((img) => ({
-          name: img.name,
-          base64: img.base64,
-          mimeType: mimeToType(img.mime),
-        })),
+      images: shrunkImages.map((img) => ({
+        name: img.name,
+        base64: img.base64,
+        mimeType: mimeToType(img.mime),
+      })),
     };
 
     // Authenticity via proof of work: mint a server-signed challenge, solve it,

package/src/Shared/Libs/vizName.ts

@@ -82,13 +82,14 @@ export interface VizNameCandidate {
 }
 
 /**
- * Fold a string to bare ASCII upper-case letters for comparison: strip
- * combining marks via NFD, map the handful of letters that have no combining
- * decomposition (ı, ł, ø, đ, ð, ß, æ, œ, þ), drop everything that is not A–Z.
- * This is the canonical form in which an MRZ name and its printed counterpart
- * become directly comparable.
+ * Fold diacritics to bare ASCII letters but PRESERVE digits, spaces and other
+ * separators (uppercased). This is the shared normalization core: strip
+ * combining marks via NFD, then map the handful of letters that have no
+ * combining decomposition. Used by both {@link foldAscii} (which then drops
+ * non-letters) and the address-proof heuristic (which keeps digits/separators
+ * so it can tokenize and detect postal codes).
  */
-export function foldAscii(value: string | null | undefined): string {
+export function foldDiacritics(value: string | null | undefined): string {
   if (!value) return '';
   return value
     .normalize('NFD')
@@ -103,17 +104,59 @@ export function foldAscii(value: string | null | undefined): string {
     .replace(/ß/g, 'SS')
     .replace(/æ/gi, 'AE')
     .replace(/œ/gi, 'OE')
-    .toUpperCase()
-    .replace(/[^A-Z]/g, '');
+    .toUpperCase();
+}
+
+export function foldAscii(value: string | null | undefined): string {
+  // Bare letters only — drop digits, spaces and punctuation after folding.
+  return foldDiacritics(value).replace(/[^A-Z]/g, '');
+}
+
+/**
+ * True when a line looks like a machine-readable-zone (MRZ) line rather than a
+ * printed field. MRZ lines are long OCR-B runs of `[A-Z0-9<]` padded with `<`
+ * filler (e.g. `P<TURSIMSEK<<CAGRI<<<<<…`). They MUST be excluded from the name
+ * search: the MRZ literally contains the folded target name, so if an MRZ line
+ * leaked into the candidate lines it would "match" and return the ASCII name
+ * with no diacritics restored — silently defeating the whole VIZ recovery. This
+ * is a content check (not a position guess), so it holds no matter where the OCR
+ * places the MRZ block or how many blocks it spans.
+ */
+function isMrzLine(line: string): boolean {
+  const compact = line.replace(/\s+/g, '');
+  // A run of ≥2 consecutive fillers is unique to the MRZ; printed name lines
+  // never contain `<<`. Also treat a long, dense OCR-B run as MRZ.
+  return (
+    /<{2,}/.test(compact) ||
+    (compact.length >= 20 && /^[A-Z0-9<]+$/i.test(compact) && /</.test(compact))
+  );
+}
+
+/**
+ * Upper-case a printed token for display, honouring Turkish casing when the
+ * document is Turkish, and normalising to NFC.
+ *
+ * Two Turkish-specific glitches this fixes (both reported from the field):
+ *  - "different i": the default (invariant) `toUpperCase()` maps a lower-case
+ *    dotted `i` to a DOTLESS `I`, so an OCR'd "İsmail" becomes "İSMAIL" instead
+ *    of the correct "İSMAİL". Turkish-locale uppercasing maps `i`→`İ` and the
+ *    dotless `ı`→`I`, preserving the dot distinction Turkish depends on.
+ *  - "dot leaned to the right": some sources/fonts carry the dotted capital as a
+ *    DECOMPOSED `I`+combining-dot (U+0049 U+0307), which renders with an offset
+ *    dot. NFC precomposes it to the single glyph `İ` (U+0130).
+ */
+function upperForDisplay(word: string, locale?: string): string {
+  const upper = locale ? word.toLocaleUpperCase(locale) : word.toUpperCase();
+  return upper.normalize('NFC');
 }
 
 /** Split a printed-name line into upper-case word tokens (letters + marks). */
-function tokenize(line: string): string[] {
+function tokenize(line: string, locale?: string): string[] {
   return line
     .split(/[\s,]+/)
     .map((w) => w.trim())
     .filter((w) => w.length > 0 && /\p{L}/u.test(w))
-    .map((w) => w.toUpperCase());
+    .map((w) => upperForDisplay(w, locale));
 }
 
 /**
@@ -125,12 +168,16 @@ function tokenize(line: string): string[] {
  * Because the comparison is on the FOLDED form, only an exact same-name match
  * succeeds — a different printed name will not fold-match and yields null.
  */
-function recoverPrintedName(lines: string[], mrzName: string): string | null {
+function recoverPrintedName(
+  lines: string[],
+  mrzName: string,
+  locale?: string
+): string | null {
   const target = foldAscii(mrzName);
   if (!target) return null;
 
   for (const line of lines) {
-    const tokens = tokenize(line);
+    const tokens = tokenize(line, locale);
     // Slide a window over the tokens; the printed name may sit among other
     // label text on the same block ("Surname / Nom  ÖZTÜRK").
     for (let start = 0; start < tokens.length; start++) {
@@ -160,22 +207,35 @@ function recoverPrintedName(lines: string[], mrzName: string): string | null {
  *                 sit ABOVE the MRZ on the data page; passing this restricts the
  *                 search to blocks above it, avoiding false matches in the MRZ
  *                 itself. When undefined, all blocks are searched.
+ * @param issuingCountry ICAO 3-letter issuing state, used to pick locale-correct
+ *                 casing for the recovered name (Turkish `i`/`İ` handling). When
+ *                 omitted, invariant uppercasing is used.
  */
 export function recoverVizName(
   blocks: VizTextBlock[],
   mrzFirst: string,
   mrzLast: string,
-  mrzTop?: number
+  mrzTop?: number,
+  issuingCountry?: string | null
 ): VizNameCandidate {
+  // Turkish needs locale-aware uppercasing so the dotted/dotless i distinction
+  // survives (i→İ, ı→I). Other Latin scripts are unaffected by invariant casing.
+  const locale = issuingCountry?.toUpperCase() === 'TUR' ? 'tr' : undefined;
   const above =
-    typeof mrzTop === 'number'
-      ? blocks.filter((b) => b.top < mrzTop)
-      : blocks;
-  // Each block's text may hold several printed lines.
-  const lines = above.flatMap((b) => b.text.split(/\r?\n/));
+    typeof mrzTop === 'number' ? blocks.filter((b) => b.top < mrzTop) : blocks;
+  // Each block's text may hold several printed lines. Drop any MRZ line: the
+  // `mrzTop` position filter above is only a hint (the caller can't always know
+  // the true MRZ block, and the MRZ may span several blocks), so we also exclude
+  // MRZ lines by content — otherwise the MRZ's own name text would fold-match
+  // the target and be returned as the "printed" name with diacritics stripped.
+  const lines = above
+    .flatMap((b) => b.text.split(/\r?\n/))
+    .filter((l) => !isMrzLine(l));
 
-  const vizFirst = mrzFirst ? recoverPrintedName(lines, mrzFirst) : null;
-  const vizLast = mrzLast ? recoverPrintedName(lines, mrzLast) : null;
+  const vizFirst = mrzFirst
+    ? recoverPrintedName(lines, mrzFirst, locale)
+    : null;
+  const vizLast = mrzLast ? recoverPrintedName(lines, mrzLast, locale) : null;
 
   // Detect a letter-level discrepancy: a printed line clearly carries the name
   // field but its fold does not equal the MRZ name. We approximate this by
@@ -190,3 +250,81 @@ export function recoverVizName(
 
   return { vizFirst, vizLast, mismatch };
 }
+
+/**
+ * Pick the most frequent non-null value from a list of candidates.
+ *
+ * OCR is noisy: the same printed name can come back slightly different across
+ * passes (a diacritic dropped, an i-variant flipped, a stray combining mark).
+ * Rather than trust a single read, we run recovery over several images/frames
+ * and take the value that appeared MOST OFTEN as the truth. Ties are broken by
+ * first appearance (stable), and null/empty candidates never win — a pass that
+ * failed to recover the name doesn't dilute the ones that succeeded.
+ *
+ * Values are compared by NFC form so two spellings that only differ by
+ * composition (precomposed İ vs I+combining-dot) are counted as the same vote.
+ */
+function voteMostFrequent(
+  values: Array<string | null>,
+  minAgree: number
+): string | null {
+  const counts = new Map<string, { count: number; display: string }>();
+  let total = 0;
+  for (const v of values) {
+    if (!v) continue;
+    total += 1;
+    const key = v.normalize('NFC');
+    const entry = counts.get(key);
+    if (entry) entry.count += 1;
+    else counts.set(key, { count: 1, display: key });
+  }
+  let winner: { count: number; display: string } | null = null;
+  for (const entry of counts.values()) {
+    if (!winner || entry.count > winner.count) winner = entry;
+  }
+  if (!winner) return null;
+  // Require the winner to be corroborated by multiple samples — the name is
+  // only "decided" when frames AGREE. The exception is when there is only a
+  // single sample available at all (total < minAgree): with one OCR pass we
+  // can't reach a quorum, so we accept that lone reading rather than discard a
+  // legitimately-recovered name. (It is still non-destructive — recoverVizName
+  // only ever returns a value that folds to the same ASCII as the MRZ.)
+  if (winner.count < minAgree && total >= minAgree) return null;
+  return winner.display;
+}
+
+/**
+ * Fuse several VIZ recovery results into one by majority vote per field.
+ *
+ * Run {@link recoverVizName} over multiple frames/images (e.g. several camera
+ * frames of the data page, or the passport page plus ID front/back), then pass
+ * the candidates here. Each field (first/last) is decided independently by the
+ * value that MULTIPLE samples agree on — a single noisy OCR pass can neither
+ * corrupt the name nor decide it alone. When only one sample exists we fall
+ * back to it (can't form a quorum from one frame).
+ *
+ * Non-destructive by construction: this only ever surfaces a diacritic form
+ * that {@link recoverVizName} already confirmed folds to the same ASCII as the
+ * MRZ name, so the authoritative MRZ letters are never changed — only their
+ * diacritics restored. `mismatch` is reported only when NO sample recovered a
+ * field yet at least one saw printed name text that disagreed with the MRZ.
+ *
+ * @param candidates One {@link VizNameCandidate} per frame/image.
+ * @param minAgree   Minimum agreeing samples to "decide" a field (default 2).
+ */
+export function voteVizName(
+  candidates: VizNameCandidate[],
+  minAgree = 2
+): VizNameCandidate {
+  const vizFirst = voteMostFrequent(
+    candidates.map((c) => c.vizFirst),
+    minAgree
+  );
+  const vizLast = voteMostFrequent(
+    candidates.map((c) => c.vizLast),
+    minAgree
+  );
+  const anyMismatch = candidates.some((c) => c.mismatch);
+  const mismatch = anyMismatch && (vizFirst === null || vizLast === null);
+  return { vizFirst, vizLast, mismatch };
+}

package/src/Shared/Types/identificationInfo.ts

@@ -137,11 +137,6 @@ export interface WorkflowStep {
      * verdict and sends it to the backend, which decides. Defaults to off.
      */
     enforceChipVizMatch?: boolean;
-    /**
-     * Whether a proof document is required in the ADDRESS_CAPTURE step
-     * (MASAK 4/C(1)(d)). Defaults to true; set false to allow address-only.
-     */
-    addressProofRequired?: boolean;
     /**
      * Run Passive Authentication on the eID scan (ICAO 9303-11 §5.1 / MASAK
      * 4/C(1)(b),(c)): read EF.SOD, verify on-device DG-hash integrity, and send

package/src/Translation/Resources/en.ts

@@ -133,12 +133,37 @@ export default {
   'addressCaptureScreen.addressPlaceholder': 'Street, number, city, country',
   'addressCaptureScreen.proofLabel': 'Proof of address',
   'addressCaptureScreen.proofHint':
-    'A residence certificate, or a utility bill issued within the last 3 months, or a document from a public authority.',
+    'A residence certificate, a utility bill issued within the last 3 months, or a document from a public authority. Capture the whole document.',
   'addressCaptureScreen.captureProof': 'Capture proof document',
-  'addressCaptureScreen.retakeProof': 'Retake proof document',
+  'addressCaptureScreen.retakeProof': 'Retake',
   'addressCaptureScreen.proofCameraHint':
-    'Position the document within the frame and capture.',
+    'Fit the whole document inside the frame, then capture.',
   'addressCaptureScreen.capture': 'Capture',
+  'addressCaptureScreen.previewHint':
+    'Make sure the whole document is readable.',
+  'addressCaptureScreen.warnNoName':
+    "We couldn't find your name on this document. Make sure your name is visible, or continue if it's correct.",
+  'addressCaptureScreen.warnNoAddress':
+    "We couldn't detect an address on this document. Make sure the address is visible, or continue if it's correct.",
+  'addressCaptureScreen.warnNoText':
+    "We couldn't read this document. Make sure the whole page is in frame and readable, or continue if it's correct.",
+  'addressCaptureScreen.guideHeader': 'Proof of address',
+  'addressCaptureScreen.guideText':
+    'Please ensure the following for best results:',
+  'addressCaptureScreen.guidePointWholeDocument':
+    'Fit the entire document inside the frame.',
+  'addressCaptureScreen.guidePointLighting':
+    'Use good lighting and avoid glare or shadows.',
+  'addressCaptureScreen.guidePointSteady':
+    'Hold the device steady so the photo is sharp.',
+  'addressCaptureScreen.guidePointDocuments':
+    'A residence certificate, a utility bill no older than 3 months, or a public-authority document.',
+  'addressCaptureScreen.retakeTooDark':
+    'Too dark — move to better lighting and retake.',
+  'addressCaptureScreen.retakeTooBright':
+    'Too bright or glare — adjust the angle and retake.',
+  'addressCaptureScreen.retakeBlurry':
+    'Photo is blurry — hold steady and retake.',
   'eidScannerScreen.faceImageNotFound': 'Photo data not found on document.',
   'eidScannerScreen.documentCode': 'Document Type',
   'eidScannerScreen.nationality': 'Nationality',

package/src/Translation/Resources/tr.ts

@@ -133,12 +133,37 @@ export default {
   'addressCaptureScreen.addressPlaceholder': 'Cadde, numara, şehir, ülke',
   'addressCaptureScreen.proofLabel': 'Adres kanıtı',
   'addressCaptureScreen.proofHint':
-    'Yerleşim yeri belgesi veya son 3 ay içinde düzenlenmiş bir fatura ya da bir kamu kurumu tarafından verilen belge.',
+    'Yerleşim yeri belgesi, son 3 ay içinde düzenlenmiş bir fatura ya da bir kamu kurumu tarafından verilen belge. Belgenin tamamını çekin.',
   'addressCaptureScreen.captureProof': 'Kanıt belgesini çek',
-  'addressCaptureScreen.retakeProof': 'Kanıt belgesini yeniden çek',
+  'addressCaptureScreen.retakeProof': 'Yeniden çek',
   'addressCaptureScreen.proofCameraHint':
-    'Belgeyi çerçeveye yerleştirin ve fotoğraf çekin.',
+    'Belgenin tamamını çerçeveye sığdırın ve fotoğraf çekin.',
   'addressCaptureScreen.capture': 'Çek',
+  'addressCaptureScreen.previewHint':
+    'Belgenin tamamının okunaklı olduğundan emin olun.',
+  'addressCaptureScreen.warnNoName':
+    'Bu belgede adınızı bulamadık. Adınızın göründüğünden emin olun ya da doğruysa devam edin.',
+  'addressCaptureScreen.warnNoAddress':
+    'Bu belgede bir adres tespit edemedik. Adresin göründüğünden emin olun ya da doğruysa devam edin.',
+  'addressCaptureScreen.warnNoText':
+    'Bu belgeyi okuyamadık. Sayfanın tamamının kadraja girdiğinden ve okunaklı olduğundan emin olun ya da doğruysa devam edin.',
+  'addressCaptureScreen.guideHeader': 'Adres kanıtı',
+  'addressCaptureScreen.guideText':
+    'En iyi sonuç için lütfen şunları sağlayın:',
+  'addressCaptureScreen.guidePointWholeDocument':
+    'Belgenin tamamını çerçeveye sığdırın.',
+  'addressCaptureScreen.guidePointLighting':
+    'İyi aydınlatma kullanın; yansıma ve gölgeden kaçının.',
+  'addressCaptureScreen.guidePointSteady':
+    'Fotoğrafın net olması için cihazı sabit tutun.',
+  'addressCaptureScreen.guidePointDocuments':
+    'Yerleşim yeri belgesi, son 3 aydan eski olmayan bir fatura ya da bir kamu kurumu belgesi.',
+  'addressCaptureScreen.retakeTooDark':
+    'Çok karanlık — daha aydınlık bir yere geçip tekrar çekin.',
+  'addressCaptureScreen.retakeTooBright':
+    'Çok parlak veya yansıma var — açıyı değiştirip tekrar çekin.',
+  'addressCaptureScreen.retakeBlurry':
+    'Fotoğraf bulanık — sabit tutup tekrar çekin.',
   'eidScannerScreen.faceImageNotFound': 'Belgede fotoğraf verisi bulunamadı.',
   'eidScannerScreen.documentCode': 'Belge Türü',
   'eidScannerScreen.nationality': 'Uyruk',

package/src/version.ts

@@ -1,3 +1,3 @@
 // This file is auto-generated. Do not edit manually.
 // Version is synced from package.json during build.
-export const SDK_VERSION = '1.512.0';
+export const SDK_VERSION = '1.513.0';