@myazahq/kyc-sdk-react-native 2.5.0 → 2.6.0

package/src/lib/map-tiles.ts

@@ -0,0 +1,143 @@
+// Web Mercator math for the dependency-free map pin picker. Pure and
+// unit-tested — the picker is a thin gesture shell over these.
+//
+// Deliberately NOT react-native-maps: that means native modules, per-platform
+// setup and a Google Maps API key per org for what the picker needs — pan,
+// zoom, one pin. The standard slippy-map maths below is ~60 lines, fully
+// testable, and the tiles are plain <Image>s.
+//
+// A MIRROR of the web SDK's lib/map-tiles.ts — keep the two in lockstep.
+
+export const TILE_SIZE = 256;
+export const MIN_ZOOM = 3;
+export const MAX_ZOOM = 19;
+
+// Web Mercator's poles — beyond this the projection diverges.
+const MAX_LAT = 85.05112878;
+
+export interface LatLng {
+  lat: number;
+  lng: number;
+}
+
+export function clampLat(lat: number): number {
+  return Math.max(-MAX_LAT, Math.min(MAX_LAT, lat));
+}
+
+function wrapLng(lng: number): number {
+  let l = lng;
+  while (l > 180) l -= 360;
+  while (l < -180) l += 360;
+  return l;
+}
+
+/** World size in pixels at a zoom level. */
+export function worldSize(zoom: number): number {
+  return TILE_SIZE * 2 ** zoom;
+}
+
+/** Project a coordinate to world pixels at a zoom level. */
+export function latLngToWorld(point: LatLng, zoom: number): { x: number; y: number } {
+  const size = worldSize(zoom);
+  const lat = clampLat(point.lat);
+  const sin = Math.sin((lat * Math.PI) / 180);
+  // Clamped into the world: at the pole cap the log term lands a float
+  // epsilon outside [0, size], which would render as a phantom tile row.
+  const y = (0.5 - Math.log((1 + sin) / (1 - sin)) / (4 * Math.PI)) * size;
+  return {
+    x: ((wrapLng(point.lng) + 180) / 360) * size,
+    y: Math.min(size, Math.max(0, y)),
+  };
+}
+
+/** Unproject world pixels back to a coordinate. */
+export function worldToLatLng(x: number, y: number, zoom: number): LatLng {
+  const size = worldSize(zoom);
+  const n = Math.PI - (2 * Math.PI * y) / size;
+  return {
+    lat: (180 / Math.PI) * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n))),
+    lng: wrapLng((x / size) * 360 - 180),
+  };
+}
+
+export interface TilePlacement {
+  key: string;
+  url: string;
+  /** CSS position relative to the viewport's top-left corner. */
+  left: number;
+  top: number;
+}
+
+/**
+ * The OSM tiles covering a viewport centred on `center`. Tiles outside the
+ * world (above/below the poles) are skipped; longitude wraps.
+ */
+export function visibleTiles(
+  center: LatLng,
+  zoom: number,
+  width: number,
+  height: number,
+): TilePlacement[] {
+  const world = latLngToWorld(center, zoom);
+  const tiles: TilePlacement[] = [];
+  const tileCount = 2 ** zoom;
+  const originX = world.x - width / 2;
+  const originY = world.y - height / 2;
+  const first = { x: Math.floor(originX / TILE_SIZE), y: Math.floor(originY / TILE_SIZE) };
+  const last = {
+    x: Math.floor((originX + width) / TILE_SIZE),
+    y: Math.floor((originY + height) / TILE_SIZE),
+  };
+  for (let ty = first.y; ty <= last.y; ty += 1) {
+    if (ty < 0 || ty >= tileCount) continue;
+    for (let tx = first.x; tx <= last.x; tx += 1) {
+      const wrappedX = ((tx % tileCount) + tileCount) % tileCount;
+      tiles.push({
+        key: `${zoom}/${tx}/${ty}`,
+        url: `https://tile.openstreetmap.org/${zoom}/${wrappedX}/${ty}.png`,
+        left: tx * TILE_SIZE - originX,
+        top: ty * TILE_SIZE - originY,
+      });
+    }
+  }
+  return tiles;
+}
+
+/** The centre after a drag of (dx, dy) viewport pixels. */
+export function panCenter(center: LatLng, zoom: number, dx: number, dy: number): LatLng {
+  const world = latLngToWorld(center, zoom);
+  const next = worldToLatLng(world.x - dx, world.y - dy, zoom);
+  return { lat: clampLat(next.lat), lng: next.lng };
+}
+
+/** Sensible starting views: gov-DB countries at country zoom, else a world view. */
+const COUNTRY_CENTERS: Record<string, LatLng> = {
+  NG: { lat: 9.06, lng: 8.68 },
+  GH: { lat: 7.95, lng: -1.02 },
+  KE: { lat: 0.02, lng: 37.9 },
+  ZA: { lat: -28.48, lng: 24.68 },
+  CI: { lat: 7.54, lng: -5.55 },
+};
+
+export function defaultMapView(country: string | undefined): { center: LatLng; zoom: number } {
+  const center = country ? COUNTRY_CENTERS[country.toUpperCase()] : undefined;
+  return center ? { center, zoom: 6 } : { center: { lat: 6.5, lng: 12 }, zoom: 3 };
+}
+
+/**
+ * The height of the map surface on the pin step, from the viewport.
+ *
+ * A phone gets 40% of its height, clamped to 240–360: on a phone the map
+ * owns every touch, so the taller it is the less page is left to scroll on,
+ * and Continue has to stay reachable. From a tablet-class width (the web
+ * SDK's `sm` breakpoint) it is a flat 420. Mirrors the web SDK's
+ * `h-[40vh] min-h-[240px] max-h-[360px] sm:h-[420px]` on AddressCollectionStep
+ * and the Flutter `mapSurfaceHeight`; keep the three in lockstep.
+ */
+export const MAP_SURFACE = { phoneFraction: 0.4, phoneMin: 240, phoneMax: 360, wideBreakpoint: 640, wide: 420 } as const;
+
+export function mapSurfaceHeight(viewport: { width: number; height: number }): number {
+  if (viewport.width >= MAP_SURFACE.wideBreakpoint) return MAP_SURFACE.wide;
+  const fraction = Math.round(viewport.height * MAP_SURFACE.phoneFraction);
+  return Math.min(MAP_SURFACE.phoneMax, Math.max(MAP_SURFACE.phoneMin, fraction));
+}

package/src/lib/poa-country-gate.ts

@@ -0,0 +1,27 @@
+// ---------------------------------------------------------------------------
+// The Proof of Address step's country gate.
+//
+// On the ADDRESS scope the declared country is the applicant's own claim about
+// their market: it picks the document kinds on offer, the PoA vendor market and
+// rides the submission as the verification's country, and the scope seeds none
+// (see AddressCountryControl). A document uploaded with no country behind it is
+// not yet a complete answer, so Continue holds until one is declared (user
+// decision 2026-09-08). Elsewhere the flow's own country stands and the gate
+// never bites; an org that accepts exactly ONE country has the control show it
+// as a settled fact, which counts as declared.
+//
+// A THREE-WAY MIRROR of the web SDK's lib/poa-country-gate.ts and Flutter's
+// config/poa_country_gate.dart; change the rule in one and change all three.
+// ---------------------------------------------------------------------------
+
+/** Whether the Proof of Address step may continue as far as the COUNTRY is
+ *  concerned (the upload has its own gate). */
+export function poaCountryDeclared(facts: {
+  scope: string | null;
+  selectedCountry: string | null | undefined;
+  offered: readonly string[];
+}): boolean {
+  if (facts.scope !== 'address') return true;
+  if (facts.selectedCountry?.trim()) return true;
+  return facts.offered.length === 1;
+}

package/src/lib/result-copy.ts

@@ -0,0 +1,116 @@
+import type { VerificationOutcome } from './result-wait';
+import type { BiometricCopyText } from '../config/biometricOptions';
+
+// ─── What the terminal screens say ──────────────────────────────────────────
+//
+// Pure so it is testable without React. The server's own reason wins on a
+// decline or an error when it sent one: it is written for the applicant.
+// UK English, no em dashes (user-facing copy rule).
+
+export type ResultTone = 'success' | 'error' | 'info';
+
+export interface ResultCopy {
+  tone: ResultTone;
+  title: string;
+  description: string;
+}
+
+export interface WaitingCopy {
+  title: string;
+  description: string;
+}
+
+/**
+ * The ONE loading screen after the capture. On a re-authentication that waits
+ * for its verdict it spans the selfie upload, the submission and the poll, so
+ * it names the check rather than any of the three steps behind it. A retry in
+ * flight replaces the description, never the title: the person is still
+ * waiting for the same thing. `override` is the org's own words for the
+ * screen (lib/biometric-copy.ts), field by field over the default.
+ */
+export function describeWaiting(opts: {
+  scope: string | null;
+  waitsForResult: boolean;
+  retry?: { attempt: number; total: number } | null;
+  override?: BiometricCopyText | null;
+}): WaitingCopy {
+  const base = withOverride(waitingCopyFor(opts.scope, opts.waitsForResult), opts.override);
+  if (opts.retry) {
+    return { title: base.title, description: `Connection issue, retrying (${opts.retry.attempt}/${opts.retry.total}).` };
+  }
+  return base;
+}
+
+function waitingCopyFor(scope: string | null, waitsForResult: boolean): WaitingCopy {
+  if (scope === 'biometric-authentication') {
+    return waitsForResult
+      ? { title: "Checking it's you", description: 'Matching your selfie against the photo on record. This usually takes a few seconds.' }
+      : { title: 'Sending your face check', description: 'This only takes a moment.' };
+  }
+  if (scope === 'biometric-enrollment') {
+    return { title: 'Saving your selfie', description: 'It becomes the reference for your future face checks.' };
+  }
+  return { title: 'Submitting your verification', description: 'Please wait a moment.' };
+}
+
+/** The org's own words for a screen, over the default, field by field. */
+function withOverride<T extends { title: string; description: string }>(base: T, override?: BiometricCopyText | null): T {
+  if (!override) return base;
+  return {
+    ...base,
+    ...(override.title ? { title: override.title } : {}),
+    ...(override.description ? { description: override.description } : {}),
+  };
+}
+
+/** What the person is told, per outcome. The server's own reason wins on a
+ *  decline or an error when it sent one; it is written for the applicant.
+ *  `copy` is the org's own words for the two verdict screens: on a decline
+ *  its description wins even over the server's reason, since the org chose
+ *  to say that. */
+export function describeOutcome(
+  outcome: VerificationOutcome,
+  copy?: { verified?: BiometricCopyText | null; declined?: BiometricCopyText | null },
+): ResultCopy {
+  if (outcome.kind === 'timeout') {
+    return {
+      tone: 'info',
+      title: 'Still checking',
+      description: "This is taking longer than usual. You'll be notified as soon as it's done.",
+    };
+  }
+  switch (outcome.status) {
+    case 'approved':
+      return withOverride(
+        { tone: 'success', title: "You're verified", description: 'Your face matched the photo on record.' },
+        copy?.verified,
+      );
+    case 'declined':
+      return withOverride(
+        {
+          tone: 'error',
+          title: "We couldn't confirm it's you",
+          description: outcome.reason ?? "Your face didn't match the photo on record.",
+        },
+        copy?.declined,
+      );
+    case 'in_review':
+      return {
+        tone: 'info',
+        title: 'Under review',
+        description: "A reviewer will take a look. You'll be notified of the outcome.",
+      };
+    case 'error':
+      return {
+        tone: 'error',
+        title: 'Something went wrong',
+        description: outcome.reason ?? "We couldn't complete your check. Please try again in a moment.",
+      };
+    default:
+      return {
+        tone: 'info',
+        title: 'Check submitted',
+        description: "You'll be notified of the result.",
+      };
+  }
+}

package/src/lib/result-wait.ts

@@ -0,0 +1,53 @@
+import type { SessionStatus, VerificationStatusResponse } from '../services/api-types';
+
+// ─── Waiting for a verdict in the flow ──────────────────────────────────────
+//
+// The platform is fire-and-forget: /verify answers in milliseconds and the
+// worker settles the check afterwards. A re-authentication is the one flow
+// whose verdict the person is waiting for RIGHT THERE, so the submitted step
+// polls the publishable status endpoint (state + reason, never result data)
+// until the check leaves its pending states. Pure and injectable, like the
+// presence watch wait: the screen owns nothing but the rendering.
+
+export const RESULT_WAIT_MS = 60 * 1000;
+export const RESULT_POLL_MS = 1500;
+
+/** The states a submitted check passes through before it settles. */
+const PENDING: ReadonlySet<SessionStatus> = new Set(['not_started', 'in_progress', 'processing']);
+
+export type VerificationOutcome =
+  | { kind: 'settled'; status: SessionStatus; reason: string | null; reasonCode: string | null }
+  | { kind: 'timeout' };
+
+export interface AwaitOutcomeDeps {
+  /** One status read; null on any failure (the wait keeps going). */
+  fetchStatus: () => Promise<VerificationStatusResponse | null>;
+  sleep?: (ms: number) => Promise<void>;
+  now?: () => number;
+  waitMs?: number;
+  pollMs?: number;
+}
+
+export function isPendingStatus(status: SessionStatus): boolean {
+  return PENDING.has(status);
+}
+
+/**
+ * Poll until the check settles or the budget runs out. A failed read is not
+ * a verdict: it is skipped and the next poll tries again, so a network blip
+ * mid-wait never reads as an outcome.
+ */
+export async function awaitVerificationOutcome(deps: AwaitOutcomeDeps): Promise<VerificationOutcome> {
+  const sleep = deps.sleep ?? ((ms) => new Promise<void>((resolve) => setTimeout(resolve, ms)));
+  const now = deps.now ?? Date.now;
+  const deadline = now() + (deps.waitMs ?? RESULT_WAIT_MS);
+  const pollMs = deps.pollMs ?? RESULT_POLL_MS;
+  for (;;) {
+    const read = await deps.fetchStatus();
+    if (read && !isPendingStatus(read.status)) {
+      return { kind: 'settled', status: read.status, reason: read.reason ?? null, reasonCode: read.reasonCode ?? null };
+    }
+    if (now() >= deadline) return { kind: 'timeout' };
+    await sleep(pollMs);
+  }
+}

package/src/lib/review-map-surface.ts

@@ -0,0 +1,26 @@
+// The review card's map falls back in the SAME order on every SDK: the picture
+// (the Maps Static API through the server), then the framed Google map the pin
+// step drew, then the built-in tiles. Pure, so a test can pin the order — the
+// Flutter card skipped the middle rung and confirmed the address on
+// OpenStreetMap where RN confirmed it on Google (user report 2026-09-08).
+// Mirrors kyc-sdk-flutter's reviewMapSurface; keep the two in lockstep.
+
+export type ReviewMapSurface = 'stub' | 'picture' | 'pending' | 'framed' | 'builtIn';
+
+export function reviewMapSurface(facts: {
+  vendorsStubbed: boolean;
+  /** The picture's bytes have landed. */
+  hasStaticMap: boolean;
+  /** The picture was refused (a project without the Static API 404s). */
+  staticMapFailed: boolean;
+  /** A server-minted maps frame URL this install can render. */
+  hasFrame: boolean;
+}): ReviewMapSurface {
+  if (facts.vendorsStubbed) return 'stub';
+  if (facts.hasStaticMap) return 'picture';
+  // Nothing to draw yet and no verdict either: hold the picture's space rather
+  // than flashing the live map for the half second before the bytes land.
+  if (!facts.staticMapFailed) return 'pending';
+  if (facts.hasFrame) return 'framed';
+  return 'builtIn';
+}

package/src/lib/scope.ts

@@ -0,0 +1,31 @@
+// Workflow SCOPE — what a flow verifies about the subject (mirror of the
+// server's lib/workflows/scope.ts and the web SDK's lib/scope.ts; keep the
+// three in lockstep). Absent = the full verification.
+
+export type WorkflowScope =
+  | 'address'
+  | 'biometric-authentication'
+  | 'biometric-enrollment'
+  | 'questionnaire'
+  | 'contact';
+
+/** The marker idType a scoped submission carries (the KYB product-in-idType
+ *  convention — the server requires the matching published workflow). */
+export const SCOPE_ID_TYPES: Record<WorkflowScope, string> = {
+  address: 'address',
+  'biometric-authentication': 'biometric-auth',
+  'biometric-enrollment': 'biometric-enroll',
+  questionnaire: 'questionnaire',
+  contact: 'contact',
+};
+
+export function configScope(config: { scope?: WorkflowScope | string }): WorkflowScope | null {
+  const value = config.scope;
+  return value && value in SCOPE_ID_TYPES ? (value as WorkflowScope) : null;
+}
+
+/** The biometric scopes run the liveness capture; every other scope has no
+ *  camera step at all. */
+export function isFaceScope(scope: WorkflowScope | null): boolean {
+  return scope === 'biometric-authentication' || scope === 'biometric-enrollment';
+}

package/src/lib/selfie-upload-wait.ts

@@ -0,0 +1,79 @@
+// ─── Waiting for the selfie upload from a later step ────────────────────────
+//
+// With the selfie review hidden (the biometric scopes' default), the liveness
+// step hands over the moment the capture ring has closed rather than when the
+// upload lands, so the person sees ONE loading screen from the shutter to the
+// verdict instead of three. The upload keeps running in the background and
+// reports to the store (`selfieUpload`, written by liveness/useSelfieUpload);
+// the submitted step waits on that record before it submits. Pure and
+// injectable, like the result wait: the screen owns nothing but the rendering.
+
+export type SelfieUploadStatus = 'idle' | 'uploading' | 'done' | 'failed';
+
+export interface SelfieUploadState {
+  status: SelfieUploadStatus;
+  /** The failure message, set only on `failed`. */
+  message: string | null;
+}
+
+export const IDLE_SELFIE_UPLOAD: SelfieUploadState = { status: 'idle', message: null };
+
+export type SelfieUploadWait = { ok: true } | { ok: false; message: string };
+
+export interface SelfieUploadSnapshot {
+  selfieUpload: SelfieUploadState;
+  /** `mediaIds.selfie`: the durable proof the selfie is on the server. */
+  selfieMediaId: string | undefined;
+}
+
+export const SELFIE_UPLOAD_WAIT_MS = 90 * 1000;
+
+const TIMED_OUT = 'Your selfie could not be sent. Check your connection and try again.';
+
+/**
+ * Whether the upload has settled, and how. A restored session carries the
+ * media id with the status still `idle` (nothing uploaded this visit), which
+ * counts as settled; an `idle` record with no media id is an upload that has
+ * not started yet, so the caller keeps waiting.
+ */
+export function selfieUploadSettled(snapshot: SelfieUploadSnapshot): SelfieUploadWait | null {
+  const { status, message } = snapshot.selfieUpload;
+  if (status === 'failed') return { ok: false, message: message ?? TIMED_OUT };
+  if (status === 'done' || (status === 'idle' && !!snapshot.selfieMediaId)) return { ok: true };
+  return null;
+}
+
+export interface AwaitSelfieUploadDeps {
+  read: () => SelfieUploadSnapshot;
+  /** Fires the listener on every store change; returns the unsubscribe. */
+  subscribe: (listener: () => void) => () => void;
+  timeoutMs?: number;
+  setTimer?: (fn: () => void, ms: number) => unknown;
+  clearTimer?: (handle: unknown) => void;
+}
+
+/** Resolve once the upload has settled, or with a failure at the deadline. */
+export function awaitSelfieUpload(deps: AwaitSelfieUploadDeps): Promise<SelfieUploadWait> {
+  const settled = selfieUploadSettled(deps.read());
+  if (settled) return Promise.resolve(settled);
+  const setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+  const clearTimer = deps.clearTimer ?? ((h) => clearTimeout(h as ReturnType<typeof setTimeout>));
+  return new Promise((resolve) => {
+    let done = false;
+    const finish = (result: SelfieUploadWait) => {
+      if (done) return;
+      done = true;
+      unsubscribe();
+      clearTimer(timer);
+      resolve(result);
+    };
+    const unsubscribe = deps.subscribe(() => {
+      const next = selfieUploadSettled(deps.read());
+      if (next) finish(next);
+    });
+    const timer = setTimer(() => finish({ ok: false, message: TIMED_OUT }), deps.timeoutMs ?? SELFIE_UPLOAD_WAIT_MS);
+    // The store may have moved between the first read and the subscription.
+    const again = selfieUploadSettled(deps.read());
+    if (again) finish(again);
+  });
+}

package/src/lib/street-view-fov.ts

@@ -0,0 +1,42 @@
+// The Street View entrance frame's maths. A mirror of the web SDK's
+// StreetViewFramer `frameFov` and the Flutter street_view_fov.dart; keep the
+// three in lockstep.
+
+export const clamp = (v: number, lo: number, hi: number): number => Math.min(hi, Math.max(lo, v));
+
+/** The frame the applicant captured: coordinates only, so the server fetches
+ *  the image with its own key. */
+export interface StreetViewFrame {
+  panoId: string;
+  heading: number;
+  pitch: number;
+  fov: number;
+}
+
+/**
+ * The field of view a centred sub-frame of the viewport actually subtends.
+ * The frame is entrance-sized guidance, so the STORED image must be what the
+ * frame showed, not the whole panorama — otherwise "fit your gate in the
+ * frame" captures a streetscape with the gate somewhere in it. Exact
+ * projection maths (a perspective view is a flat plane, so a width fraction
+ * maps through tan, not linearly).
+ */
+export function frameFov(viewportFovDeg: number, widthFraction: number): number {
+  const fraction = clamp(widthFraction, 0.1, 1);
+  const half = (viewportFovDeg * Math.PI) / 360;
+  return (2 * Math.atan(fraction * Math.tan(half)) * 180) / Math.PI;
+}
+
+/** The frame to store for a reported view: the slice the frame subtends when
+ *  both widths are known, else the whole view; fov 10..120, pitch ±90. */
+export function captureStreetViewFrame(
+  pov: { panoId: string; heading: number; pitch: number; viewFov: number },
+  frameWidth: number,
+  viewWidth: number,
+): StreetViewFrame {
+  const fov =
+    frameWidth > 0 && viewWidth > 0
+      ? clamp(frameFov(pov.viewFov, frameWidth / viewWidth), 10, 120)
+      : clamp(pov.viewFov, 10, 120);
+  return { panoId: pov.panoId, heading: pov.heading, pitch: clamp(pov.pitch, -90, 90), fov };
+}

package/src/lib/webview-available.ts

@@ -0,0 +1,47 @@
+import type React from 'react';
+
+import { tryRequire } from '../services/fingerprint-sources';
+
+// `react-native-webview` is an OPTIONAL peer. Absent, every surface that
+// would ride it (the framed Google map, the framed Street View) degrades to
+// its dependency-free path (the OSM picker, the entrance photo), and the
+// FLOW MODEL must know that too, or it would offer a step the phone cannot
+// render. Resolved once and cached: a require that failed will fail again.
+
+export interface WebViewLike {
+  injectJavaScript(script: string): void;
+}
+
+export type WebViewComponent = React.ComponentType<{
+  ref?: React.Ref<WebViewLike>;
+  source: { uri: string };
+  style?: object;
+  javaScriptEnabled?: boolean;
+  /** Android: ask a parent ScrollView not to intercept the WebView's drags. */
+  nestedScrollEnabled?: boolean;
+  onMessage?: (event: { nativeEvent: { data: string } }) => void;
+  onError?: () => void;
+}>;
+
+let resolved: WebViewComponent | null | undefined;
+
+export function loadWebView(): WebViewComponent | null {
+  if (resolved === undefined) {
+    const mod = tryRequire<{ WebView?: WebViewComponent; default?: WebViewComponent }>(() =>
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      require('react-native-webview'),
+    );
+    resolved = mod?.WebView ?? mod?.default ?? null;
+  }
+  return resolved;
+}
+
+/** Whether a WebView can be rendered on this install. */
+export function webViewAvailable(): boolean {
+  return loadWebView() != null;
+}
+
+/** Test seam: forget the cached answer. */
+export function __resetWebViewAvailability(): void {
+  resolved = undefined;
+}

package/src/liveness/useLiveness.ts

@@ -562,7 +562,12 @@ export function useLiveness(opts: UseLivenessOptions = {}): UseLivenessReturn {
     setState((s) => ({
       ...s,
       phase: 'complete',
-      instruction: 'Capture complete',
+      // No line at all. The ring closing green on the same frame as the
+      // shutter IS the completion signal, and the review screen follows within
+      // the beat — narrating the upload over it said nothing the user needed
+      // and read as a delay. The instruction also drives the voice guidance,
+      // so an empty one is silent as well as blank.
+      instruction: '',
       activeChallenge: null,
       positionGuidance: null,
     }));