@incodetech/prizma-core-screens 0.1.0

package/src/ListScreen.tsx

@@ -0,0 +1,213 @@
+import React, { forwardRef, type ReactNode } from 'react';
+import { PrizmaTitle } from '@incodetech/prizma-core-web/title';
+import { PrizmaButton } from '@incodetech/prizma-core-web/button';
+import { PrizmaDisclaimer } from '@incodetech/prizma-core-web/disclaimer';
+import { PrizmaTag } from '@incodetech/prizma-core-web/tag';
+import { PrizmaScreenShell, type PrizmaScreenShellProps } from './ScreenShell';
+import { PrizmaScreenNav } from './ScreenNav';
+import type {
+  PrizmaScreenActionHandler,
+  PrizmaScreenChromeProps,
+  PrizmaScreenOverrides,
+} from './types';
+import './ScreenLayout.css';
+
+/** Same vocabulary as `PrizmaResultScreen`: `loading` renders Core's spinner
+ *  slot, the verdicts render its status mark, `none` shows the title alone. */
+export type PrizmaListStatus = 'loading' | 'success' | 'error' | 'warning' | 'none';
+
+export interface PrizmaListScreenProps
+  extends Omit<PrizmaScreenShellProps, 'dark' | 'title' | 'children'>,
+    PrizmaScreenChromeProps {
+  /** The status mark above the title. `none` (default) renders the title alone. */
+  status?: PrizmaListStatus;
+  /**
+   * An optional block between the logo nav and the content — a journey stepper.
+   * Video Selfie draws Core's `PrizmaStepper` on EVERY screen of the flow, not
+   * just its camera stages, and it is the only chrome that tells the steps
+   * apart; the archetypes had a slot on E alone, so the rest of the module shed
+   * it (owner-reported 2026-08-19). Takes a `ReactNode` so the module supplies
+   * Core's own component — no primitive invented, and both offsets live once in
+   * `ScreenLayout.css` (`.prizma-screen-layout__progress`). Omit it and nothing
+   * renders, so every existing consumer is byte-identical. DEVIATIONS #VS-4.
+   */
+  progress?: ReactNode;
+  /** H2 screen title ("Common issues", "Camera permission is required"). */
+  title: string;
+  /** Supporting copy below the title (H5). */
+  subtitle?: string;
+  /**
+   * A non-status glyph ABOVE the title — Core's `PrizmaTitle.icon` allowlist is
+   * `status | spinner | none`, so anything else (the question mark on ID
+   * Capture's common issues) is composed here. Wrap it in
+   * `prizma-screen-layout__glyph` (+ `--neutral` / `--negative`); the slot's
+   * geometry and its Spacing/16 live in `ScreenLayout.css`. DEVIATIONS #10.
+   */
+  glyph?: ReactNode;
+  /**
+   * THE list — a Core `PrizmaCardListCommonIssues`,
+   * `PrizmaCardListVerificationOptions`, `PrizmaCardDocumentList`… It fills the
+   * middle between the title block and the CTA band; the archetype supplies the
+   * Spacing/24 below the title and nothing else, so the list keeps its own row
+   * rhythm.
+   */
+  children?: ReactNode;
+  /** Hang the list off the BOTTOM of the middle instead of the top — the
+   *  document chooser's option rows. Default `'start'`. */
+  listAlign?: 'start' | 'end';
+  /**
+   * Let the list PAN inside the column when the section draws a middle taller
+   * than the 844 frame — the archetype-G twin of `scrollFields` on E. The
+   * title, the CTA band and the anchored tag hold still while the rows scroll,
+   * instead of the surplus painting over them. DEVIATIONS #VS-12.
+   */
+  scrollList?: boolean;
+  /** Legal/hint copy directly above the CTA. Supplies the designed 28px
+   *  text→CTA gap through its own padding (DEVIATIONS #8). */
+  disclaimer?: string;
+  /** Primary CTA. Omit for list screens whose rows ARE the actions (the
+   *  document chooser: Core makes each row a real `<button>`). */
+  ctaLabel?: string;
+  /** Secondary CTA (a second filled action) rendered ABOVE the primary. */
+  secondaryCtaLabel?: string;
+  /** Tertiary underlined LINK above the primary — "Take the photo manually"
+   *  (common issues) and "Quit process" (permission). Figma draws Core's
+   *  `tertiary-link` composite in the band's top slot. */
+  linkLabel?: string;
+  /** "verified by" attribution copy for the footer tag. */
+  verifiedLabel: string;
+  navLabel?: string;
+  screenId?: string;
+  overrides?: PrizmaScreenOverrides;
+  onAction?: PrizmaScreenActionHandler;
+}
+
+/**
+ * Archetype G — List.
+ *
+ * Nav (or reserved row) → optional glyph → title block → a Core card / option
+ * list filling the middle → CTA band → anchored footer tag.
+ *
+ * It exists because EIGHT screens hand-built it independently: ID Capture's
+ * common issues, permission, age verification and document chooser, Document
+ * Capture's common issues, and the document-error card lists. Each re-declared
+ * the title→list offset (24 on the ID screens, 32 on Document Capture's) and
+ * each inserted the verified tag by hand — which is how the tag ended up at 0 on
+ * some screens and 16 on others (DEVIATIONS #F-29, #F-31).
+ *
+ * CTA band order is the family's designed one: disclaimer → tertiary link →
+ * secondary → primary. The link sits ABOVE the primary here (Figma
+ * `tertiaryPosition="top"` on `1-5-2-id-common-issues` and `1-3-2-id`), which is
+ * the mirror of Archetype A, where it sits below. Stacked at the foundation's
+ * flat Spacing/16 (DEVIATIONS #8) — every offset comes from ScreenLayout.css and
+ * this file declares none of its own.
+ *
+ * Reach for `PrizmaResultScreen` instead when the middle is a centred verdict
+ * rather than a list.
+ */
+export const PrizmaListScreen = forwardRef<HTMLDivElement, PrizmaListScreenProps>(
+  (
+    {
+      progress,
+      status = 'none',
+      title,
+      subtitle,
+      glyph,
+      children,
+      listAlign = 'start',
+      scrollList = false,
+      disclaimer,
+      ctaLabel,
+      secondaryCtaLabel,
+      linkLabel,
+      verifiedLabel,
+      navLabel,
+      screenId,
+      showHeader = true,
+      showFooter = true,
+      overrides,
+      onAction,
+      ...shell
+    },
+    ref,
+  ) => (
+    <PrizmaScreenShell ref={ref} {...shell}>
+      <PrizmaScreenNav reserved={!showHeader} logo={overrides?.logo} navLabel={navLabel} />
+      {progress ? (
+        <div className="prizma-screen-layout__progress">{progress}</div>
+      ) : null}
+      <div className="prizma-screen-layout__content">
+        {glyph}
+        <PrizmaTitle
+          variant={overrides?.align === 'left' ? 'left' : 'centered'}
+          title={title}
+          showSubtitle={Boolean(subtitle)}
+          subtitle={subtitle}
+          icon={
+            status === 'loading'
+              ? { type: 'spinner' }
+              : status === 'none'
+                ? { type: 'none' }
+                : { type: 'status', status }
+          }
+        />
+        <div
+          className={[
+            'prizma-screen-layout__list',
+            listAlign === 'end' ? 'prizma-screen-layout__list--end' : '',
+            scrollList ? 'prizma-screen-layout__list--scroll' : '',
+          ]
+            .filter(Boolean)
+            .join(' ')}
+        >
+          {children}
+        </div>
+        {ctaLabel || secondaryCtaLabel || linkLabel || disclaimer ? (
+          <div className="prizma-screen-layout__band">
+            {disclaimer ? <PrizmaDisclaimer text={disclaimer} /> : null}
+            {linkLabel ? (
+              <PrizmaButton
+                variant="tertiary-link"
+                size="L"
+                onClick={() => onAction?.({ type: 'secondary', screenId })}
+              >
+                {linkLabel}
+              </PrizmaButton>
+            ) : null}
+            {/* THE PRIMARY ALWAYS SITS ABOVE THE SECONDARY (owner rule
+                2026-08-19, DEVIATIONS #GEO-1). The rule governs the
+                primary/secondary pair only — the tertiary link keeps this
+                archetype's own fixed position ABOVE both (§6-G, the mirror of
+                A where it sits below), which is an explicit exception. */}
+            {ctaLabel ? (
+              <PrizmaButton
+                variant="primary"
+                size="L"
+                onClick={() => onAction?.({ type: 'cta', screenId })}
+              >
+                {ctaLabel}
+              </PrizmaButton>
+            ) : null}
+            {secondaryCtaLabel ? (
+              <PrizmaButton
+                variant="secondary"
+                size="L"
+                onClick={() => onAction?.({ type: 'secondary', screenId })}
+              >
+                {secondaryCtaLabel}
+              </PrizmaButton>
+            ) : null}
+          </div>
+        ) : null}
+      </div>
+      {showFooter ? (
+        <div className="prizma-screen-layout__footer">
+          <PrizmaTag label={verifiedLabel} />
+        </div>
+      ) : null}
+    </PrizmaScreenShell>
+  ),
+);
+PrizmaListScreen.displayName = 'PrizmaListScreen';
+
+export default PrizmaListScreen;

package/src/LoaderScreen.tsx

@@ -0,0 +1,69 @@
+import React, { forwardRef } from 'react';
+import { PrizmaProcessingScreen, type PrizmaProcessingScreenProps } from './ProcessingScreen';
+import type { PrizmaScreenActionHandler, PrizmaScreenOverrides } from './types';
+import type { LoadersStrings, LoadersVariant } from './LoadersStrings';
+import './ScreenLayout.css';
+
+export interface LoaderScreenProps
+  extends Omit<
+    PrizmaProcessingScreenProps,
+    'status' | 'title' | 'subtitle' | 'verifiedLabel' | 'navLabel'
+  > {
+  /** Family copy — this screen reads the `variants` slice its `variant` names. */
+  strings: LoadersStrings;
+  /** Which copy pair to render. Default `processing`. */
+  variant?: LoadersVariant;
+  screenId?: string;
+  overrides?: PrizmaScreenOverrides;
+  onAction?: PrizmaScreenActionHandler;
+}
+
+/**
+ * Loaders — the generic wait screen, built on the Processing archetype
+ * (GUIDELINES.md §6-C, `PrizmaProcessingScreen`).
+ *
+ * Figma: `Module Generic Screens` frames `67:2388` ("Processing…") and
+ * `67:3593` ("Just a moment…"). ONE screen for both, and for every module
+ * loader after them: logo header → Core's spinner → status line → reassurance
+ * line → the verified tag, with no CTA. The archetype already IS this recipe;
+ * this component exists so the family has a name a designer can point at and a
+ * copy contract a host can fill, not to add layout.
+ *
+ * Reach for `PrizmaResultScreen` the moment a wait screen needs a button — a
+ * loader with a "Cancel" is a result screen, and the missing CTA band here is
+ * exactly what made three modules hand-build the skeleton (see
+ * `ResultScreen.tsx`).
+ */
+export const LoaderScreen = forwardRef<HTMLDivElement, LoaderScreenProps>(
+  (
+    {
+      strings,
+      variant = 'processing',
+      screenId = `loaders-${variant}`,
+      overrides,
+      onAction,
+      ...shell
+    },
+    ref,
+  ) => {
+    const copy = strings.variants[variant];
+
+    return (
+      <PrizmaProcessingScreen
+        ref={ref}
+        status="loading"
+        title={copy.title}
+        subtitle={copy.subtitle}
+        verifiedLabel={strings.verifiedLabel}
+        navLabel={strings.navLabel}
+        screenId={screenId}
+        overrides={overrides}
+        onAction={onAction}
+        {...shell}
+      />
+    );
+  },
+);
+LoaderScreen.displayName = 'LoaderScreen';
+
+export default LoaderScreen;

package/src/LoadersStrings.ts

@@ -0,0 +1,38 @@
+// Loaders — copy contract for the GENERIC family.
+//
+// Figma: `Module Generic Screens` (qGJjfL4O0JSjz1x4tOjJn8), frames `67:2388`
+// and `67:3593`.
+//
+// The wait screen every module shows while the server thinks. It is drawn once
+// in the generic file and reused verbatim — logo header, Core's spinner, a
+// status line, a reassurance line, the verified tag — because a user who sees a
+// different loader between two steps reads it as a different product.
+//
+// The family has no flow of its own: a loader is always ENTERED from the module
+// that is waiting and LEFT for that module's next screen, so there is nothing
+// to draw. Core Lab lists it as a library of states.
+//
+// No hardcoded English anywhere in a screen: every visible string arrives here.
+
+/**
+ * The two frames in the generic file. They are the same screen with different
+ * copy — which is the point of the family: the loader is a shape, and the two
+ * entries here are examples of filling it, not a closed set. A module that
+ * waits for something else supplies its own pair of strings under a new key.
+ */
+export type LoadersVariant = 'processing' | 'validating';
+
+export interface LoadersCopy {
+  /** H2 status line ("Processing…"). */
+  title: string;
+  /** Reassurance line under it ("This won't take long."). */
+  subtitle?: string;
+}
+
+export interface LoadersStrings {
+  /** Accessible name for the logo nav region (i18n — no baked-in English). */
+  navLabel?: string;
+  /** "verified by" attribution copy for the footer tag. */
+  verifiedLabel: string;
+  variants: Record<LoadersVariant, LoadersCopy>;
+}

package/src/NfcCommonIssuesScreen.tsx

@@ -0,0 +1,104 @@
+import React, { forwardRef, type ReactNode } from 'react';
+import {
+  IconChipNotFound,
+  IconIdTooFar,
+  IconPassportCover,
+  IconPassportTooFar,
+  IconPhoneCover,
+  IconPhoneMoved,
+} from '@incodetech/prizma-core-icons';
+import { PrizmaList } from '@incodetech/prizma-core-web/list';
+import { PrizmaListScreen, type PrizmaListScreenProps } from './ListScreen';
+import type { PrizmaScreenActionHandler, PrizmaScreenOverrides } from './types';
+import type { NfcDocumentType, NfcIssueKind, NfcStrings } from './NfcStrings';
+import './ScreenLayout.css';
+
+/**
+ * Issue kind → canonical bank glyph. Unlike Document Capture's and
+ * Geolocation's maps (#DC-23), NOTHING here is a substitution: the bank ships
+ * this module's five glyphs by name — the NFC sweep minted `passport-cover`,
+ * `passport-too-far`, `id-too-far`, `chip-not-found`, `phone-moved` and
+ * `phone-cover` — so every row draws the icon its Figma section draws.
+ */
+const ISSUE_ICONS: Record<NfcIssueKind, ReactNode> = {
+  passportInCover: <IconPassportCover size="m" />,
+  passportTooFar: <IconPassportTooFar size="m" />,
+  idTooFar: <IconIdTooFar size="m" />,
+  chipOtherPage: <IconChipNotFound size="m" />,
+  phoneMoved: <IconPhoneMoved size="m" />,
+  phoneCover: <IconPhoneCover size="m" />,
+};
+
+export interface NfcCommonIssuesScreenProps
+  extends Omit<
+    PrizmaListScreenProps,
+    'title' | 'children' | 'ctaLabel' | 'verifiedLabel' | 'navLabel'
+  > {
+  /** Module copy — this screen reads the `commonIssues` slice. */
+  strings: NfcStrings;
+  /** Which purple section: `nfc.commonissues.id` (3 rows) or `.passport` (5). */
+  documentType?: NfcDocumentType;
+  screenId?: string;
+  overrides?: PrizmaScreenOverrides;
+  onAction?: PrizmaScreenActionHandler;
+}
+
+/**
+ * NFC — the "Common issues" help sheet reached from the retry screen's Help
+ * button. Purple sections `nfc.commonissues.id` (19976:109863, three rows) and
+ * `nfc.commonissues.passport` (19976:112072, five), on the List archetype
+ * (GUIDELINES.md §6-G).
+ *
+ * Like ID Capture's and Document Capture's help sheets, these sections draw no
+ * logo, so `showHeader={false}` drops the wordmark while the nav row stays
+ * reserved — the content starts where every other screen's does and the tag
+ * keeps its one fixed position (#F-34, #F-29).
+ *
+ * The rows are Core's `PrizmaList variant="icons-m"`, which IS the `List`
+ * instance the sections place: a 40px leading icon slot, a single-line label,
+ * rows stacked by the component's own rhythm. (Figma spaces its rows 16 apart
+ * and Core's icons-m gap is Spacing/12 — Core wins, a 4px family-level
+ * difference that no module re-declares.) `PrizmaCardListCommonIssues`, which
+ * two other modules use for their help sheets, is deliberately NOT used here:
+ * it is the two-line title+description row, and these rows have one line.
+ */
+export const NfcCommonIssuesScreen = forwardRef<HTMLDivElement, NfcCommonIssuesScreenProps>(
+  (
+    {
+      strings,
+      documentType = 'passport',
+      screenId = `nfc-common-issues-${documentType}`,
+      showHeader = false,
+      overrides,
+      onAction,
+      ...shell
+    },
+    ref,
+  ) => (
+    <PrizmaListScreen
+      ref={ref}
+      showHeader={showHeader}
+      title={strings.commonIssues.title}
+      ctaLabel={strings.commonIssues.ctaLabel}
+      verifiedLabel={strings.verifiedLabel}
+      navLabel={strings.navLabel}
+      screenId={screenId}
+      overrides={overrides}
+      onAction={onAction}
+      {...shell}
+    >
+      <PrizmaList
+        variant="icons-m"
+        aria-label={strings.commonIssues.listLabel}
+        items={strings.commonIssues.issues[documentType].map((issue) => ({
+          variant: 'icon-m' as const,
+          label: issue.label,
+          icon: ISSUE_ICONS[issue.kind],
+        }))}
+      />
+    </PrizmaListScreen>
+  ),
+);
+NfcCommonIssuesScreen.displayName = 'NfcCommonIssuesScreen';
+
+export default NfcCommonIssuesScreen;

package/src/NfcErrorScreen.tsx

@@ -0,0 +1,83 @@
+import React, { forwardRef } from 'react';
+import { PrizmaResultScreen, type PrizmaResultScreenProps } from './ResultScreen';
+import type { PrizmaScreenActionHandler, PrizmaScreenOverrides } from './types';
+import type { NfcStrings } from './NfcStrings';
+import './ScreenLayout.css';
+
+/**
+ * Which error verdict. `unable` is the pre-flight refusal (the device or the
+ * document cannot do NFC at all); `general` is the read failing on a chip that
+ * should have worked.
+ */
+export type NfcErrorVariant = 'unable' | 'general';
+
+export interface NfcErrorScreenProps
+  extends Omit<
+    PrizmaResultScreenProps,
+    | 'status'
+    | 'title'
+    | 'subtitle'
+    | 'children'
+    | 'ctaLabel'
+    | 'secondaryCtaLabel'
+    | 'verifiedLabel'
+    | 'navLabel'
+  > {
+  /** Module copy — this screen reads the `error` slice. */
+  strings: NfcStrings;
+  /** Which purple section to render. Default `unable`. */
+  variant?: NfcErrorVariant;
+  screenId?: string;
+  overrides?: PrizmaScreenOverrides;
+  onAction?: PrizmaScreenActionHandler;
+}
+
+/**
+ * NFC — the two error verdicts, on the Result archetype (GUIDELINES.md §6-F):
+ *
+ * - `unable` — `nfc.error.unable` (19975:107734): a WARNING mark over "We're
+ *   sorry, you're unable to continue the process" + "Only passports and phones
+ *   with NFC are allowed."
+ * - `general` — `nfc.error.generalerror` (19975:108644): a NEGATIVE mark over
+ *   "Unable to authenticate document chip", no supporting line.
+ *
+ * The two are one screen because they differ only in mark and copy; the amber
+ * vs red distinction is real and deliberate (a device that CANNOT do NFC is not
+ * a failed read), so it rides Core's own status axis rather than a colour
+ * literal.
+ *
+ * Chrome: both sections draw the verdict alone — no logo row, no tag. Both are
+ * kept, which is the standing ruling for the error family (#PI-8, restated by
+ * the owner 2026-08-19 and applied to four modules' connectivity screens), so
+ * nothing shifts between the module's states (#F-29).
+ */
+export const NfcErrorScreen = forwardRef<HTMLDivElement, NfcErrorScreenProps>(
+  (
+    {
+      strings,
+      variant = 'unable',
+      screenId = `nfc-error-${variant}`,
+      overrides,
+      onAction,
+      ...shell
+    },
+    ref,
+  ) => (
+    <PrizmaResultScreen
+      ref={ref}
+      status={variant === 'unable' ? 'warning' : 'error'}
+      title={strings.error[variant].title}
+      subtitle={variant === 'unable' ? strings.error.unable.subtitle : undefined}
+      ctaLabel={strings.error[variant].ctaLabel}
+      verifiedLabel={strings.verifiedLabel}
+      navLabel={strings.navLabel}
+      screenId={screenId}
+      overrides={overrides}
+      onAction={onAction}
+      {...shell}
+    />
+  ),
+);
+NfcErrorScreen.displayName = 'NfcErrorScreen';
+
+export default NfcErrorScreen;

package/src/NfcLayout.css

@@ -0,0 +1,36 @@
+/* NFC — module-owned layer.
+ *
+ * Only ONE thing lives here, and it is presentation, not archetype spacing: the
+ * scrim + centring frame that presents Core's `PrizmaModalContent` on the
+ * `nfc.error.nfcsettings` section. No offset, size or type value in this file
+ * duplicates anything the archetypes own — every screen offset in this module
+ * comes from `ScreenLayout.css`.
+ *
+ * Why the screen owns the presentation: Core's safe presenter (`PrizmaModal`)
+ * `createPortal`s to `document.body`, which escapes the 390 × 844 screen frame
+ * and the host's `transform: scale()` (DEVIATIONS #17), and a screen is one
+ * static spec state with no open/close clock. This is the same division of
+ * labour Document Capture's bottom sheet already uses (#DC-30) — Core owns the
+ * card, the surface owns the scrim.
+ */
+
+.nfc-modal-scrim {
+  position: absolute;
+  inset: 0;
+  z-index: 1;
+  background: var(--prizma-surface-overlay);
+}
+
+/* Centres the dialog in the frame. `PrizmaModalContent` is `width: 100%` up to
+ * its own `Modal/Size/Max-width`, so the only thing added here is the gutter
+ * Figma draws (12 each side of the 390 frame) — a Spacing token, not a literal. */
+.nfc-modal-panel {
+  position: absolute;
+  inset: 0;
+  z-index: 2;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding-inline: var(--prizma-spacing-12);
+  box-sizing: border-box;
+}

package/src/NfcProcessingScreen.tsx

@@ -0,0 +1,57 @@
+import React, { forwardRef } from 'react';
+import {
+  PrizmaProcessingScreen,
+  type PrizmaProcessingScreenProps,
+} from './ProcessingScreen';
+import type { PrizmaScreenActionHandler, PrizmaScreenOverrides } from './types';
+import type { NfcStrings } from './NfcStrings';
+import './ScreenLayout.css';
+
+export interface NfcProcessingScreenProps
+  extends Omit<
+    PrizmaProcessingScreenProps,
+    'status' | 'title' | 'subtitle' | 'verifiedLabel' | 'navLabel'
+  > {
+  /** Module copy — this screen reads the `loading` slice. */
+  strings: NfcStrings;
+  screenId?: string;
+  overrides?: PrizmaScreenOverrides;
+  onAction?: PrizmaScreenActionHandler;
+}
+
+/**
+ * NFC — "Hold on a sec.. / We're verifying your identity": the chip has been
+ * read and the data is being checked. Purple section `nfc.loading.default`
+ * (19974:82917), on the Processing archetype (GUIDELINES.md §6-C).
+ *
+ * A pure spinner + title screen with no button, which is the case §6-F reserves
+ * for C rather than the Result archetype — the same split Email Input's success
+ * screen sits on (#EI-4).
+ *
+ * Chrome: the section draws neither the logo nor the tag (its CONTENT frame
+ * holds only the `Loading spinner` instance). Both are kept, per the owner rule
+ * that non-capture screens show header AND footer and that fixed chrome never
+ * moves between states (#F-30, #F-29, and the #PI-8 restatement).
+ */
+export const NfcProcessingScreen = forwardRef<HTMLDivElement, NfcProcessingScreenProps>(
+  (
+    { strings, screenId = 'nfc-loading', overrides, onAction, ...shell },
+    ref,
+  ) => (
+    <PrizmaProcessingScreen
+      ref={ref}
+      status="loading"
+      title={strings.loading.title}
+      subtitle={strings.loading.subtitle}
+      verifiedLabel={strings.verifiedLabel}
+      navLabel={strings.navLabel}
+      screenId={screenId}
+      overrides={overrides}
+      onAction={onAction}
+      {...shell}
+    />
+  ),
+);
+NfcProcessingScreen.displayName = 'NfcProcessingScreen';
+
+export default NfcProcessingScreen;