@smileid/usesmileid 12.0.1 → 12.0.2

package/src/data/model/token_payload.ts

@@ -0,0 +1,182 @@
+import { z } from "zod";
+
+/**
+ * User-detail and consent bindings delivered via the JWT auth token.
+ *
+ * The backend embeds this object under the top-level `payload` claim
+ * (JWT payload, base64url-decoded middle segment) when the partner
+ * binds user details and/or consent into the token on their backend.
+ * User-detail values in the claim are opaque vault references — only
+ * key PRESENCE is meaningful client-side. Consent subfields are
+ * plaintext. `country` / `id_type` / `id_number` / `callback_url` may
+ * also appear in the claim but are deliberately ignored.
+ *
+ * Every field is optional and every field tolerates a wrong wire type
+ * by degrading to absent — a malformed claim never rejects the token.
+ *
+ * Field names are a deliberate cross-SDK shared contract that
+ * intentionally omits the `UseSmileID` prefix. Internal — not
+ * re-exported from the package entrypoint (`src/index.ts`).
+ */
+
+const tokenConsentClaimSchema = z.object({
+  /** Only a literal `true` counts — `false` or a non-boolean is never trusted as a binding. */
+  granted: z.literal(true).optional().catch(undefined),
+  granted_at: z.string().optional().catch(undefined),
+  notice_language: z.string().optional().catch(undefined),
+  notice_privacy_policy_url: z.string().optional().catch(undefined),
+});
+
+/**
+ * Tolerant wire schema for the `payload` claim. Unknown keys are
+ * stripped; a wrong-typed field degrades to `undefined` (per-field
+ * `.catch`) instead of failing the whole claim.
+ */
+export const tokenPayloadSchema = z.object({
+  given_names: z.string().optional().catch(undefined),
+  last_name: z.string().optional().catch(undefined),
+  email: z.string().optional().catch(undefined),
+  phone_number: z.string().optional().catch(undefined),
+  /** Non-object / array consent values degrade to absent. */
+  consent: tokenConsentClaimSchema.optional().catch(undefined),
+});
+
+/**
+ * Consent subfields bound into the token. Token consent always wins:
+ * a complete binding (see {@link isTokenConsentComplete}) supersedes
+ * every local consent source, and a partial binding is a build-time
+ * validation error naming the missing subfields (see
+ * {@link tokenConsentMissingSubfields}).
+ */
+export type TokenConsent = {
+  /** Present (and `true`) only when the claim carried a literal `granted: true`. */
+  readonly granted?: boolean;
+  /** ISO-8601 timestamp from the claim's `granted_at`. */
+  readonly grantedAt?: string;
+  /** Language code from the claim's `notice_language`. */
+  readonly noticeLanguage?: string;
+  /** URL from the claim's `notice_privacy_policy_url`. */
+  readonly noticePrivacyPolicyUrl?: string;
+};
+
+/**
+ * Presence flags for the identity fields the token binds, parsed from
+ * the `payload` claim. A flag is `true` iff the claim carries the key
+ * with a non-empty string value (the value itself is an opaque vault
+ * reference — the server injects the real value at submission).
+ */
+export type TokenPayload = {
+  readonly hasGivenNames: boolean;
+  readonly hasLastName: boolean;
+  readonly hasEmail: boolean;
+  readonly hasPhoneNumber: boolean;
+  readonly consent?: TokenConsent;
+};
+
+/**
+ * Parse a raw `payload` claim value into a `TokenPayload`, or
+ * `undefined` when the claim is absent or not a JSON object. Mirrors
+ * the `sdk_config` degradation semantics: never throws, tolerates
+ * unknown keys, and degrades wrong-typed fields to absent.
+ */
+export function parseTokenPayload(rawClaim: unknown): TokenPayload | undefined {
+  if (
+    rawClaim === null ||
+    typeof rawClaim !== "object" ||
+    Array.isArray(rawClaim)
+  ) {
+    return undefined;
+  }
+  const parseResult = tokenPayloadSchema.safeParse(rawClaim);
+  if (!parseResult.success) {
+    // Unreachable in practice (every field carries a `.catch`), but
+    // degrade gracefully to preserve the never-throws contract.
+    return undefined;
+  }
+  const claim = parseResult.data;
+  const consent = tokenConsentFromClaim(claim.consent);
+  return {
+    hasGivenNames: isPresent(claim.given_names),
+    hasLastName: isPresent(claim.last_name),
+    hasEmail: isPresent(claim.email),
+    hasPhoneNumber: isPresent(claim.phone_number),
+    ...(consent !== undefined ? { consent } : {}),
+  };
+}
+
+/**
+ * Token consent is COMPLETE when `granted` is `true` and every other
+ * subfield is non-blank. A complete binding — granted with every
+ * notice subfield non-blank — satisfies the consent requirement
+ * without a local source. Token consent always wins, so a partial
+ * binding is a build-time validation error.
+ */
+export function isTokenConsentComplete(
+  consent: TokenConsent | undefined,
+): boolean {
+  return (
+    consent !== undefined && tokenConsentMissingSubfields(consent).length === 0
+  );
+}
+
+/**
+ * Wire-key names of the consent subfields the binding is missing. A
+ * token that carries a consent object must carry all four subfields —
+ * a non-empty list is a build-time validation error naming exactly
+ * what the token must add.
+ */
+export function tokenConsentMissingSubfields(
+  consent: TokenConsent,
+): readonly string[] {
+  const missing: string[] = [];
+  if (consent.granted !== true) missing.push("granted");
+  if (!isNonBlank(consent.grantedAt)) missing.push("granted_at");
+  if (!isNonBlank(consent.noticeLanguage)) missing.push("notice_language");
+  if (!isNonBlank(consent.noticePrivacyPolicyUrl)) {
+    missing.push("notice_privacy_policy_url");
+  }
+  return missing;
+}
+
+/**
+ * Whether the token binds every user-detail field the SDK would
+ * otherwise require from the builder: `given_names` AND `last_name`
+ * AND at least one of `email` / `phone_number`. Only then may
+ * `builder.userDetails` be omitted entirely.
+ */
+export function bindsRequiredUserDetails(
+  payload: TokenPayload | undefined,
+): boolean {
+  if (payload === undefined) return false;
+  return (
+    payload.hasGivenNames &&
+    payload.hasLastName &&
+    (payload.hasEmail || payload.hasPhoneNumber)
+  );
+}
+
+function tokenConsentFromClaim(
+  claim: z.infer<typeof tokenConsentClaimSchema> | undefined,
+): TokenConsent | undefined {
+  if (claim === undefined) return undefined;
+  const consent: TokenConsent = {
+    ...(claim.granted === true ? { granted: true } : {}),
+    ...(claim.granted_at !== undefined ? { grantedAt: claim.granted_at } : {}),
+    ...(claim.notice_language !== undefined
+      ? { noticeLanguage: claim.notice_language }
+      : {}),
+    ...(claim.notice_privacy_policy_url !== undefined
+      ? { noticePrivacyPolicyUrl: claim.notice_privacy_policy_url }
+      : {}),
+  };
+  // An empty consent object binds nothing — treat it as absent.
+  return Object.keys(consent).length > 0 ? consent : undefined;
+}
+
+function isPresent(value: string | undefined): boolean {
+  return value !== undefined && value.length > 0;
+}
+
+function isNonBlank(value: string | undefined): boolean {
+  return value !== undefined && value.trim().length > 0;
+}

package/src/data/model/user_details_payload.ts

@@ -0,0 +1,84 @@
+import type { UserDetails } from "../../core/models/params";
+import type { TokenPayload } from "./token_payload";
+
+/**
+ * Wire carrier for the `user_details` multipart part.
+ *
+ * Unlike `UserDetails` — the partner-facing input model whose names are
+ * required — every field here is optional so the part can carry only the
+ * fields the token does **not** already bind. Token-bound fields are dropped
+ * at assembly (`userDetailsPayloadFrom`): the server injects the bound values
+ * and they take precedence over anything the client sends. When nothing
+ * remains, assembly omits the part entirely (`isUserDetailsPayloadEmpty`).
+ *
+ * Type and helper names are a deliberate cross-SDK shared contract and
+ * intentionally omit the `UseSmileID` prefix (like `TokenPayload`).
+ */
+export type UserDetailsPayload = {
+  readonly givenNames?: string;
+  readonly lastName?: string;
+  readonly email?: string;
+  readonly phoneNumber?: string;
+};
+
+/**
+ * Build the payload from builder-supplied details, dropping every field the
+ * token binds. With no token binding this reproduces `UserDetails`' wire
+ * encoding unchanged.
+ */
+export function userDetailsPayloadFrom(
+  userDetails: UserDetails,
+  droppingFieldsBoundBy: TokenPayload | undefined,
+): UserDetailsPayload {
+  return {
+    ...(droppingFieldsBoundBy?.hasGivenNames
+      ? {}
+      : { givenNames: userDetails.givenNames }),
+    ...(droppingFieldsBoundBy?.hasLastName
+      ? {}
+      : { lastName: userDetails.lastName }),
+    ...(droppingFieldsBoundBy?.hasEmail || userDetails.email === undefined
+      ? {}
+      : { email: userDetails.email }),
+    ...(droppingFieldsBoundBy?.hasPhoneNumber ||
+    userDetails.phoneNumber === undefined
+      ? {}
+      : { phoneNumber: userDetails.phoneNumber }),
+  };
+}
+
+/**
+ * True when `userDetailsPayloadToWire` would produce an empty object — the
+ * caller omits the part instead of sending `{}`. Blank contacts count as
+ * empty, mirroring the wire encoding that trims and drops them.
+ */
+export function isUserDetailsPayloadEmpty(
+  payload: UserDetailsPayload,
+): boolean {
+  return Object.keys(userDetailsPayloadToWire(payload)).length === 0;
+}
+
+/**
+ * Wire shape: snake_case keys. Names are emitted as supplied when non-blank;
+ * contact fields are trimmed and omitted when blank.
+ */
+export function userDetailsPayloadToWire(
+  payload: UserDetailsPayload,
+): Record<string, string> {
+  const wire: Record<string, string> = {};
+  if (payload.givenNames !== undefined && payload.givenNames.trim() !== "") {
+    wire["given_names"] = payload.givenNames;
+  }
+  if (payload.lastName !== undefined && payload.lastName.trim() !== "") {
+    wire["last_name"] = payload.lastName;
+  }
+  const trimmedEmail = payload.email?.trim();
+  if (trimmedEmail) {
+    wire["email"] = trimmedEmail;
+  }
+  const trimmedPhone = payload.phoneNumber?.trim();
+  if (trimmedPhone) {
+    wire["phone_number"] = trimmedPhone;
+  }
+  return wire;
+}

package/src/data/repository/__tests__/network_retries.test.ts

@@ -34,7 +34,7 @@ const CONSENT: ConsentInformation = Object.freeze({
 });
 
 const METADATA = new UseSmileIDMetadata({
-  sdkVersion: "12.0.1",
+  sdkVersion: "12.0.2",
   sdk: "react-native-expo",
   deviceOs: "",
   deviceModel: "",

package/src/data/repository/__tests__/repository_dispatch.test.ts

@@ -0,0 +1,366 @@
+import { describe, expect, it, beforeEach, vi } from "vitest";
+
+// `vi.mock` is hoisted above the imports, so anything its factory closes over
+// must be created with `vi.hoisted` or it is still in the TDZ when the factory
+// runs.
+const { compress } = vi.hoisted(() => ({ compress: vi.fn() }));
+
+vi.mock("axios", () => ({
+  __esModule: true,
+  default: { create: vi.fn(), isAxiosError: () => false },
+  isAxiosError: () => false,
+}));
+
+// The compression runner touches `expo-file-system` and the native re-encoder;
+// the repository only cares that it produces (or fails to produce) size hints.
+vi.mock("../../compression/payload_compression_runner", () => ({
+  PayloadCompressionRunner: { compress },
+}));
+
+import { UseSmileIDRepositoryImpl } from "../use_smile_id_repository_impl";
+import {
+  RetryStrategy,
+  type RetryConfig,
+} from "../../../core/models/network_config";
+import { JobType } from "../../../core/models/job_type";
+import { UseSmileIDMetadata } from "../../../metadata/use_smile_id_metadata";
+import { UseSmileIDValidationException } from "../../../core/exception/use_smile_id_validation_exception";
+import { UseSmileIDNetworkException } from "../../../core/exception/use_smile_id_network_exception";
+import type { JobRequest } from "../../model/job_request";
+import type { JobSubmissionResponse } from "../../model/job_submission_response";
+import type { ConsentInformation } from "../../../core/models/params";
+
+/**
+ * Repository dispatch + pre-flight compression tests: every job type must
+ * reach its matching API method, the compression sizes must land on the
+ * submitted metadata, and a compression failure must never block the
+ * submission. The BVN short-circuit lives in `use_smile_id_repository.test.ts`.
+ */
+
+const NO_RETRY: RetryConfig = Object.freeze({
+  maxAttempts: 1,
+  strategy: RetryStrategy.none,
+  initialDelay: 0,
+  multiplier: 1,
+  maxDelay: 0,
+  jitter: 0,
+  fixedDelay: 0,
+});
+
+const CONSENT: ConsentInformation = Object.freeze({
+  granted: true,
+  grantedAt: "2026-04-30T00:00:00.000Z",
+  noticeLanguage: "EN",
+  noticePrivacyPolicyUrl: "https://example.test/p",
+});
+
+const METADATA = new UseSmileIDMetadata({
+  sdkVersion: "12.0.2",
+  sdk: "react-native-expo",
+  deviceOs: "",
+  deviceModel: "",
+  appName: "",
+  sessionId: "test-session-id",
+  clientIp: "",
+  networkConnection: "",
+  carrierInfo: "",
+  timezone: "",
+  locale: "",
+  screenResolution: "",
+  memoryInfoMb: 0,
+  deviceOrientation: "",
+  systemArchitecture: "",
+  numberOfCameras: 0,
+  hostApplication: "",
+  securityPolicyVersion: "12.0.0",
+  sdkConfigSource: "default",
+  imageWidth: 0,
+  imageHeight: 0,
+  livenessImageWidth: 0,
+  livenessImageHeight: 0,
+});
+
+const RESPONSE: JobSubmissionResponse = {
+  jobId: "job-1",
+  userId: "user-1",
+  status: "approved",
+  message: "ok",
+};
+
+const USER_DETAILS = {
+  givenNames: "A",
+  lastName: "B",
+  email: "a@b.test",
+} as const;
+
+type StubApi = Record<string, ReturnType<typeof vi.fn>>;
+
+function makeApi(): StubApi {
+  return {
+    enhancedKyc: vi.fn(async () => RESPONSE),
+    biometricKyc: vi.fn(async () => RESPONSE),
+    smartSelfieEnrollment: vi.fn(async () => RESPONSE),
+    smartSelfieAuthentication: vi.fn(async () => RESPONSE),
+    documentVerification: vi.fn(async () => RESPONSE),
+    enhancedDocumentVerification: vi.fn(async () => RESPONSE),
+  };
+}
+
+function makeRepository(api: StubApi, retry: RetryConfig = NO_RETRY) {
+  return new UseSmileIDRepositoryImpl(
+    api as unknown as ConstructorParameters<typeof UseSmileIDRepositoryImpl>[0],
+    retry,
+  );
+}
+
+const selfieEnrollment: JobRequest = {
+  jobType: JobType.smartSelfieEnrollment,
+  selfieImage: "file:///selfie.jpg",
+  livenessImages: ["file:///liveness-1.jpg"],
+  userDetails: USER_DETAILS,
+  enhanced: false,
+  expectedLivenessImageCount: 1,
+  consent: CONSENT,
+  metadata: METADATA,
+};
+
+const selfieAuthentication: JobRequest = {
+  jobType: JobType.smartSelfieAuthentication,
+  selfieImage: "file:///selfie.jpg",
+  livenessImages: [],
+  userDetails: USER_DETAILS,
+  userId: "user-1",
+  enhanced: true,
+  expectedLivenessImageCount: 0,
+  consent: CONSENT,
+  metadata: METADATA,
+};
+
+const biometricKyc: JobRequest = {
+  jobType: JobType.biometricKyc,
+  selfieImage: "file:///selfie.jpg",
+  livenessImages: [],
+  params: { idType: "NIN", idNumber: "1", country: "NG" },
+  userDetails: USER_DETAILS,
+  expectedLivenessImageCount: 0,
+  consent: CONSENT,
+  metadata: METADATA,
+};
+
+const enhancedKyc: JobRequest = {
+  jobType: JobType.enhancedKyc,
+  params: { idType: "NIN", idNumber: "1", country: "NG" },
+  userDetails: USER_DETAILS,
+  consent: CONSENT,
+  metadata: METADATA,
+};
+
+const documentVerification: JobRequest = {
+  jobType: JobType.documentVerification,
+  selfieImage: "file:///selfie.jpg",
+  livenessImages: [],
+  frontDocument: "file:///front.jpg",
+  backDocument: "file:///back.jpg",
+  country: "NG",
+  userDetails: USER_DETAILS,
+  expectedLivenessImageCount: 0,
+  consent: CONSENT,
+  metadata: METADATA,
+};
+
+const enhancedDocumentVerification: JobRequest = {
+  jobType: JobType.enhancedDocumentVerification,
+  selfieImage: "file:///selfie.jpg",
+  livenessImages: [],
+  frontDocument: "file:///front.jpg",
+  country: "NG",
+  idType: "NATIONAL_ID",
+  userDetails: USER_DETAILS,
+  expectedLivenessImageCount: 0,
+  consent: CONSENT,
+  metadata: METADATA,
+};
+
+function metadataNames(request: unknown): readonly string[] {
+  const { metadata } = request as { metadata: UseSmileIDMetadata };
+  return metadata.toEntries().map((entry) => entry.name);
+}
+
+function metadataValue(request: unknown, name: string): string | undefined {
+  const { metadata } = request as { metadata: UseSmileIDMetadata };
+  return metadata.toEntries().find((entry) => entry.name === name)?.value;
+}
+
+describe("UseSmileIDRepositoryImpl — dispatch", () => {
+  beforeEach(() => {
+    compress.mockReset().mockResolvedValue({});
+  });
+
+  const cases: ReadonlyArray<readonly [string, JobRequest, string]> = [
+    ["smart selfie enrollment", selfieEnrollment, "smartSelfieEnrollment"],
+    [
+      "smart selfie authentication",
+      selfieAuthentication,
+      "smartSelfieAuthentication",
+    ],
+    ["enhanced KYC", enhancedKyc, "enhancedKyc"],
+    ["biometric KYC", biometricKyc, "biometricKyc"],
+    ["document verification", documentVerification, "documentVerification"],
+    [
+      "enhanced document verification",
+      enhancedDocumentVerification,
+      "enhancedDocumentVerification",
+    ],
+  ];
+
+  for (const [label, request, method] of cases) {
+    it(`routes ${label} to api.${method}`, async () => {
+      const api = makeApi();
+      const result = await makeRepository(api).submit(request);
+
+      expect(result.status).toBe("success");
+      expect(api[method]).toHaveBeenCalledTimes(1);
+      for (const [, , other] of cases) {
+        if (other !== method) expect(api[other]).not.toHaveBeenCalled();
+      }
+    });
+  }
+});
+
+describe("UseSmileIDRepositoryImpl — pre-flight compression", () => {
+  beforeEach(() => {
+    compress.mockReset().mockResolvedValue({});
+  });
+
+  it("compresses the selfie bundle for selfie job types", async () => {
+    const api = makeApi();
+    await makeRepository(api).submit(selfieEnrollment);
+
+    expect(compress).toHaveBeenCalledTimes(1);
+    const args = compress.mock.calls[0]?.[0] as Record<string, unknown>;
+    expect(args.selfieImage).toBe("file:///selfie.jpg");
+    expect(args.livenessImages).toEqual(["file:///liveness-1.jpg"]);
+    expect(args.frontDocument).toBeUndefined();
+    expect(args.metadataBytes).toBeGreaterThan(0);
+  });
+
+  it("includes both document sides for document job types", async () => {
+    const api = makeApi();
+    await makeRepository(api).submit(documentVerification);
+
+    const args = compress.mock.calls[0]?.[0] as Record<string, unknown>;
+    expect(args.frontDocument).toBe("file:///front.jpg");
+    expect(args.backDocument).toBe("file:///back.jpg");
+  });
+
+  it("skips compression entirely for image-less job types", async () => {
+    const api = makeApi();
+    await makeRepository(api).submit(enhancedKyc);
+
+    expect(compress).not.toHaveBeenCalled();
+    expect(metadataNames(api.enhancedKyc.mock.calls[0]?.[0])).not.toContain(
+      "selfie_original_size",
+    );
+  });
+
+  it("stamps every measured size onto the submitted metadata", async () => {
+    compress.mockResolvedValue({
+      selfieOriginalMb: 1.5,
+      selfieFinalMb: 0.5,
+      frontOriginalMb: 2,
+      frontFinalMb: 1,
+      backOriginalMb: 3,
+      backFinalMb: 1.25,
+    });
+    const api = makeApi();
+    await makeRepository(api).submit(documentVerification);
+
+    const submitted = api.documentVerification.mock.calls[0]?.[0];
+    expect(metadataValue(submitted, "selfie_original_size")).toBe("1.5");
+    expect(metadataValue(submitted, "selfie_final_compressed_size")).toBe(
+      "0.5",
+    );
+    expect(metadataValue(submitted, "document_front_original_size")).toBe("2");
+    expect(
+      metadataValue(submitted, "document_front_final_compressed_size"),
+    ).toBe("1");
+    expect(metadataValue(submitted, "document_back_original_size")).toBe("3");
+    expect(
+      metadataValue(submitted, "document_back_final_compressed_size"),
+    ).toBe("1.25");
+    // The caller's metadata instance is never mutated.
+    expect(METADATA.toEntries().map((entry) => entry.name)).not.toContain(
+      "selfie_original_size",
+    );
+  });
+
+  it("drops absent and zero sizes rather than stamping them", async () => {
+    compress.mockResolvedValue({
+      selfieOriginalMb: 1.5,
+      selfieFinalMb: 0,
+      frontOriginalMb: undefined,
+    });
+    const api = makeApi();
+    await makeRepository(api).submit(documentVerification);
+
+    const submitted = api.documentVerification.mock.calls[0]?.[0];
+    const stamped = metadataNames(submitted);
+    expect(stamped).toContain("selfie_original_size");
+    expect(stamped).not.toContain("selfie_final_compressed_size");
+    expect(stamped).not.toContain("document_front_original_size");
+  });
+
+  it("leaves the metadata untouched when nothing was measured", async () => {
+    compress.mockResolvedValue({});
+    const api = makeApi();
+    await makeRepository(api).submit(selfieEnrollment);
+
+    const submitted = api.smartSelfieEnrollment.mock.calls[0]?.[0];
+    expect(submitted).toBe(selfieEnrollment);
+  });
+
+  it("submits the captured images as-is when compression throws", async () => {
+    compress.mockRejectedValue(new Error("native re-encoder unavailable"));
+    const api = makeApi();
+    const result = await makeRepository(api).submit(selfieEnrollment);
+
+    expect(result.status).toBe("success");
+    expect(api.smartSelfieEnrollment).toHaveBeenCalledTimes(1);
+    expect(
+      metadataNames(api.smartSelfieEnrollment.mock.calls[0]?.[0]),
+    ).not.toContain("selfie_original_size");
+  });
+});
+
+describe("UseSmileIDRepositoryImpl — error mapping", () => {
+  beforeEach(() => {
+    compress.mockReset().mockResolvedValue({});
+  });
+
+  it("surfaces a validation exception unchanged rather than as a network error", async () => {
+    const validationError = new UseSmileIDValidationException({
+      message: "liveness image count mismatch",
+    });
+    const api = makeApi();
+    api.smartSelfieEnrollment.mockRejectedValue(validationError);
+
+    const result = await makeRepository(api).submit(selfieEnrollment);
+
+    expect(result.status).toBe("failure");
+    if (result.status === "failure") {
+      expect(result.error).toBe(validationError);
+    }
+  });
+
+  it("maps any other thrown error into the network exception hierarchy", async () => {
+    const api = makeApi();
+    api.enhancedKyc.mockRejectedValue(new Error("socket hang up"));
+
+    const result = await makeRepository(api).submit(enhancedKyc);
+
+    expect(result.status).toBe("failure");
+    if (result.status === "failure") {
+      expect(result.error).toBeInstanceOf(UseSmileIDNetworkException);
+    }
+  });
+});

package/src/data/repository/__tests__/use_smile_id_repository.test.ts

@@ -51,7 +51,7 @@ const CONSENT: ConsentInformation = Object.freeze({
 // BVN path short-circuits before the API serializes it, but the field
 // is required on `BaseJobRequest` so the fixture must supply one.
 const METADATA = new UseSmileIDMetadata({
-  sdkVersion: "12.0.1",
+  sdkVersion: "12.0.2",
   sdk: "react-native-expo",
   deviceOs: "",
   deviceModel: "",