@incodetech/prizma-core-screens 0.1.0

package/src/QualifiedSignatureProcessingScreen.tsx

@@ -0,0 +1,112 @@
+import React, { forwardRef } from 'react';
+import {
+  PrizmaProcessingScreen,
+  type PrizmaProcessingScreenProps,
+} from './ProcessingScreen';
+import { PrizmaResultScreen } from './ResultScreen';
+import type { PrizmaScreenActionHandler, PrizmaScreenOverrides } from './types';
+import type {
+  QualifiedSignatureProcessingVariant,
+  QualifiedSignatureStrings,
+} from './QualifiedSignatureStrings';
+import './ScreenLayout.css';
+
+export interface QualifiedSignatureProcessingScreenProps
+  extends Omit<
+    PrizmaProcessingScreenProps,
+    'status' | 'title' | 'subtitle' | 'verifiedLabel' | 'navLabel'
+  > {
+  /** Module copy — this screen reads the `processing` slice its `variant` names. */
+  strings: QualifiedSignatureStrings;
+  /** Which reading of the in-flight frame to render. Default `processing`. */
+  variant?: QualifiedSignatureProcessingVariant;
+  screenId?: string;
+  overrides?: PrizmaScreenOverrides;
+  onAction?: PrizmaScreenActionHandler;
+}
+
+/**
+ * Qualified Signature — the in-flight screens.
+ *
+ * The two purple parents do NOT draw the same wait, so this is two frames, not
+ * one:
+ *
+ * - `processing` — `QSign.AcceptSign.processing` (10196:67395). The pure
+ *   spinner + H2 case with nothing else on the frame, which is exactly what
+ *   GUIDELINES §6-C reserves for the Processing archetype: the spinner block is
+ *   centred in the middle container, so the archetype's fully-centred column is
+ *   the right template.
+ * - `signing`    — the partner's own 6086:39544. "Creating your signature…"
+ *   under the spinner PLUS a second attribution row, "Signing as …", anchored
+ *   at the BOTTOM of the frame immediately above the verified tag — NOT under
+ *   the title, where a `subtitle` would land it.
+ *
+ * WHY `signing` MOVES TO ARCHETYPE F. Archetype C has no slot between its
+ * centred column and the footer tag, so there is no way to place a
+ * bottom-anchored row without declaring spacing locally — forbidden by §6.
+ * Archetype F is "C with a CTA band", and its `disclaimer` slot is precisely
+ * that row: Core's own `PrizmaDisclaimer`, centred secondary text, sitting in
+ * the band directly above the tag. With no CTA label the band carries only that
+ * row, so the frame keeps C's silhouette and gains the anchored line. The
+ * archetype gap (C has no footer/disclaimer slot) is reported, not patched
+ * here — this screen still declares no layout of its own.
+ *
+ * Both are distinct from the accept screen's `loading` state, which keeps the
+ * signer on the form with the spinner in the CTA — these are the flow's own
+ * waits.
+ */
+export const QualifiedSignatureProcessingScreen = forwardRef<
+  HTMLDivElement,
+  QualifiedSignatureProcessingScreenProps
+>(
+  (
+    {
+      strings,
+      variant = 'processing',
+      screenId = `qualified-signature-processing-${variant}`,
+      overrides,
+      onAction,
+      ...shell
+    },
+    ref,
+  ) => {
+    if (variant === 'signing') {
+      const copy = strings.processing.signing;
+      return (
+        <PrizmaResultScreen
+          ref={ref}
+          status="loading"
+          title={copy.title}
+          subtitle={copy.subtitle}
+          /* The bottom-anchored "Signing as …" row. */
+          disclaimer={copy.signingAsLabel}
+          verifiedLabel={strings.verifiedLabel}
+          navLabel={strings.navLabel}
+          screenId={screenId}
+          overrides={overrides}
+          onAction={onAction}
+          {...shell}
+        />
+      );
+    }
+
+    const copy = strings.processing.processing;
+    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}
+      />
+    );
+  },
+);
+QualifiedSignatureProcessingScreen.displayName = 'QualifiedSignatureProcessingScreen';
+
+export default QualifiedSignatureProcessingScreen;

package/src/QualifiedSignatureResultScreen.tsx

@@ -0,0 +1,146 @@
+import React, { forwardRef } from 'react';
+import { PrizmaButton } from '@incodetech/prizma-core-web/button';
+import { PrizmaResultScreen, type PrizmaResultScreenProps } from './ResultScreen';
+import type { PrizmaScreenActionHandler, PrizmaScreenOverrides } from './types';
+import type {
+  QualifiedSignatureResultVariant,
+  QualifiedSignatureStrings,
+} from './QualifiedSignatureStrings';
+import './ScreenLayout.css';
+
+export interface QualifiedSignatureResultScreenProps
+  extends Omit<
+    PrizmaResultScreenProps,
+    | 'status'
+    | 'title'
+    | 'subtitle'
+    | 'glyph'
+    | 'bandContent'
+    | 'disclaimer'
+    | 'ctaLabel'
+    | 'secondaryCtaLabel'
+    | 'verifiedLabel'
+    | 'navLabel'
+  > {
+  /** Module copy — this screen reads the `result` slice its `variant` names. */
+  strings: QualifiedSignatureStrings;
+  /** Which verdict section to render. Default `signed`. */
+  variant?: QualifiedSignatureResultVariant;
+  screenId?: string;
+  overrides?: PrizmaScreenOverrides;
+  onAction?: PrizmaScreenActionHandler;
+}
+
+/**
+ * Qualified Signature — the five verdicts, built on the Result archetype
+ * (GUIDELINES.md §6-F, `PrizmaResultScreen`).
+ *
+ * ONE screen for five purple frames that share the archetype's skeleton —
+ * nav → centred status mark + title block → CTA band → anchored tag — and differ
+ * in status, copy and which actions exist:
+ * - `signed`        — `QSign.success` (10196:67485): the positive mark over a
+ *   `Button group` 124 tall = the "Continue" primary plus the "Download PDF"
+ *   underlined link.
+ * - `signedPlain`   — `QSign.success` (10196:67494): the SAME mark and line
+ *   with no actions at all, so the band never renders and the screen reads as
+ *   the pure §6-C verdict.
+ * - `signedPartner` — the `x Namirial` parent's own success frame (6086:40135).
+ *   NOT a copy of either generic one: it adds the "Signed by …" attribution row
+ *   and a STACKED pair — "Done" primary above a "Download document" OUTLINED
+ *   secondary. Both ride the archetype's `ctaLabel` + `secondaryCtaLabel`, which
+ *   already fix primary-above-secondary (#GEO-1); the attribution row rides
+ *   `disclaimer`, the band's own centred text row above the buttons.
+ * - `error`         — `QSign.AcceptSign.error` (10196:67436 / 6089:37399): the
+ *   warning mark and "Something went wrong". This frame really does draw no
+ *   button.
+ * - `errorRetry`    — the SECOND error frame both parents draw (10196:67445 and
+ *   the partner's 8363:21429): the same warning mark over "Signature failed"
+ *   plus a full-width "Try again" primary. It is the flow's only recovery
+ *   affordance, so it is a state in its own right rather than an upstream
+ *   concern (QA finding, 2026-08-19).
+ *
+ * Core's outline status marks are used, not Figma's two-tone filled discs — the
+ * icon-outline sweep of 2026-07-28 settled that for every module (DEVIATIONS
+ * #15, #DC-34) and these frames are one sweep behind. Both error frames get the
+ * WARNING mark, not the negative one: Figma draws the amber "!" disc, and the
+ * signature attempt is recoverable rather than refused.
+ *
+ * The generic error frames drop the verified tag; the partner's keeps it.
+ * The owner rule settles the split in favour of keeping it (#PI-8, #F-30) so
+ * nothing shifts between states.
+ *
+ * ONE reported delta: on `signed`, Figma puts "Download PDF" BELOW the primary,
+ * at Core's `PrizmaButtonGroup` Spacing/12. Archetype F has no tertiary-link
+ * slot — its only band opening above the buttons is `bandContent` — so Core's
+ * own `tertiary-link` Button is composed there and lands ABOVE the primary at
+ * the band's Spacing/32 (16 + 16). Ink, semantics and the distinct `secondary`
+ * action are all correct (#PI-10); only the position moves. #GEO-1 fixes the
+ * tertiary link's position PER ARCHETYPE and F has never declared one — the
+ * archetype request is logged instead of a local override. `signedPartner` is
+ * unaffected: its download control is a real outlined secondary Button, which
+ * the archetype already places correctly.
+ */
+export const QualifiedSignatureResultScreen = forwardRef<
+  HTMLDivElement,
+  QualifiedSignatureResultScreenProps
+>(
+  (
+    {
+      strings,
+      variant = 'signed',
+      screenId = `qualified-signature-result-${variant}`,
+      overrides,
+      onAction,
+      ...shell
+    },
+    ref,
+  ) => {
+    // One slice per frame — nothing is shared between variants, so the frames
+    // can never collapse into each other visually.
+    const signedCopy = variant === 'signed' ? strings.result.signed : undefined;
+    const partnerCopy = variant === 'signedPartner' ? strings.result.signedPartner : undefined;
+    const retryCopy = variant === 'errorRetry' ? strings.result.errorRetry : undefined;
+
+    const copy =
+      signedCopy ??
+      partnerCopy ??
+      retryCopy ??
+      (variant === 'error' ? strings.result.error : strings.result.signedPlain);
+
+    return (
+      <PrizmaResultScreen
+        ref={ref}
+        status={variant === 'error' || variant === 'errorRetry' ? 'warning' : 'success'}
+        title={copy.title}
+        subtitle={copy.subtitle}
+        /* "Continue" · "Done" · "Try again" — the archetype's own primary. */
+        ctaLabel={signedCopy?.ctaLabel ?? partnerCopy?.ctaLabel ?? retryCopy?.ctaLabel}
+        /* The partner's outlined "Download document", below the primary. */
+        secondaryCtaLabel={partnerCopy?.secondaryCtaLabel}
+        /* The partner's "Signed by …" row — the band's centred text slot, which
+           puts it above the button pair exactly as Figma draws it. */
+        disclaimer={partnerCopy?.signedByLabel}
+        bandContent={
+          signedCopy?.downloadLabel ? (
+            <PrizmaButton
+              variant="tertiary-link"
+              size="L"
+              onClick={() => onAction?.({ type: 'secondary', screenId })}
+            >
+              {signedCopy.downloadLabel}
+            </PrizmaButton>
+          ) : undefined
+        }
+        verifiedLabel={strings.verifiedLabel}
+        navLabel={strings.navLabel}
+        screenId={screenId}
+        overrides={overrides}
+        onAction={onAction}
+        {...shell}
+      />
+    );
+  },
+);
+QualifiedSignatureResultScreen.displayName = 'QualifiedSignatureResultScreen';
+
+export default QualifiedSignatureResultScreen;

package/src/QualifiedSignatureReviewScreen.tsx

@@ -0,0 +1,113 @@
+import React, { forwardRef, type ReactNode } from 'react';
+import { IconLock } from '@incodetech/prizma-core-icons';
+import { PrizmaReviewScreen, type PrizmaReviewScreenProps } from './ReviewScreen';
+import type { PrizmaScreenActionHandler, PrizmaScreenOverrides } from './types';
+import type { QualifiedSignatureStrings } from './QualifiedSignatureStrings';
+import './ScreenLayout.css';
+import './QualifiedSignatureLayout.css';
+
+export interface QualifiedSignatureReviewScreenProps
+  extends Omit<
+    PrizmaReviewScreenProps,
+    | 'stage'
+    | 'title'
+    | 'subtitle'
+    | 'successTitle'
+    | 'analyzingLabel'
+    | 'analyzingState'
+    | 'primaryLabel'
+    | 'secondaryLabel'
+    | 'verifiedLabel'
+    | 'children'
+    | 'stageClassName'
+  > {
+  /** Module copy — this screen reads the `review` slice. */
+  strings: QualifiedSignatureStrings;
+  /** The uploaded file's name. Not copy — runtime data from the picker. */
+  filename?: string;
+  /** Page-preview thumbnail (an `<img>`) rendered inside the card. */
+  thumbnail?: ReactNode;
+  screenId?: string;
+  overrides?: PrizmaScreenOverrides;
+  onAction?: PrizmaScreenActionHandler;
+}
+
+/**
+ * Qualified Signature — the uploaded document confirmed before signing, built on
+ * the Review archetype (GUIDELINES.md §6-H, `PrizmaReviewScreen`).
+ *
+ * Figma: purple section `QSign.reviewDoc.default` (10196:67138). It is archetype
+ * H and not F for exactly the reason §6-H draws the line: the header is
+ * TOP-aligned (`top container` starts at CONTENT y=24 with the Title, no logo
+ * row) over a media `Container` that fills the middle (109→450 of a 654 frame),
+ * with the actions anchored at the bottom — F would centre the title and the
+ * card together as one block. Measured against the archetype: Title → stage 32
+ * (Figma 109 − 77 = 32), stage → actions 24 (482 − 450 − 8 rounding). Every one
+ * of those offsets is the archetype's; this file declares none.
+ *
+ * TWO deltas from the frame, both reported rather than worked around:
+ * 1. Figma stacks `Continue` over `Replace` (a `Button group` 124 tall = 56 + 12
+ *    + 56). Archetype H hardcodes Core's `PrizmaButtonGroup
+ *    orientation="horizontal-v1"`, so they pair side by side. A screen never
+ *    picks its own button order (#GEO-1), and H has no orientation slot — the
+ *    archetype request is logged instead of overridden here.
+ * 2. The frame draws no verified tag. The owner rule wins over Figma for
+ *    attribution chrome — every non-capture screen keeps header and footer
+ *    (#PI-8, #F-30, #F-34) — so `showFooter` keeps its default.
+ *
+ * What stays module-side is the MEDIA, which Core has no primitive for: the
+ * vertical file-preview card (`PrizmaCardDocumentContainer` is the horizontal
+ * filename + action row this module uses on the accept screen instead) and the
+ * standalone encrypted notice (Core owns it only inside `PrizmaIdCapture`).
+ * Both are rebuilt from Core's own tokens in `QualifiedSignatureLayout.css`,
+ * with the Core requests recorded there — DEVIATIONS #DC-26, #DC-27.
+ */
+export const QualifiedSignatureReviewScreen = forwardRef<
+  HTMLDivElement,
+  QualifiedSignatureReviewScreenProps
+>(
+  (
+    {
+      strings,
+      filename,
+      thumbnail,
+      screenId = 'qualified-signature-review',
+      overrides,
+      onAction,
+      ...shell
+    },
+    ref,
+  ) => (
+    <PrizmaReviewScreen
+      ref={ref}
+      stage="review"
+      title={strings.review.title}
+      subtitle={strings.review.subtitle}
+      stageClassName="qualified-signature-review-file"
+      primaryLabel={strings.review.ctaLabel}
+      secondaryLabel={strings.review.replaceLabel}
+      verifiedLabel={strings.verifiedLabel}
+      navLabel={strings.navLabel}
+      screenId={screenId}
+      overrides={overrides}
+      onAction={onAction}
+      {...shell}
+    >
+      <div className="qualified-signature-file-card">
+        <span className="qualified-signature-file-card__thumb">{thumbnail}</span>
+        {filename ? (
+          <p className="qualified-signature-file-card__name">{filename}</p>
+        ) : null}
+      </div>
+      {strings.review.encryptedLabel ? (
+        <p className="qualified-signature-encrypted">
+          <IconLock size="m" />
+          <span>{strings.review.encryptedLabel}</span>
+        </p>
+      ) : null}
+    </PrizmaReviewScreen>
+  ),
+);
+QualifiedSignatureReviewScreen.displayName = 'QualifiedSignatureReviewScreen';
+
+export default QualifiedSignatureReviewScreen;

package/src/QualifiedSignatureStrings.ts

@@ -0,0 +1,256 @@
+// Qualified Signature — copy contract.
+//
+// Figma: `✍️ Signature (Qualified)` (XO9YGKlEsGUyag8CGbSUsi, canvas 6086:28669).
+// TWO purple parent sections, which are the SAME flow drawn twice:
+//
+//   `✍️ Signature (Qualified) - Screens specs + Localization` (10196:67086)
+//       1.QSign.uploadDocument → QSign.upload.default · QSign.reviewDoc.default
+//                                (+ QSign.upload.select — the iOS Files app)
+//       QSign.AcceptSign       → default · selectedCheckox · loadingsign ·
+//                                processing · viewdoc
+//       Qsign.error            → QSign.AcceptSign.error
+//       Qsign.success          → QSign.success ×2 (with and without actions)
+//
+//   `✍️ Signature (Qualified) x Namirial …` (6074:64811) — the partner reading of
+//       the SAME AcceptSign / error / success frames, plus `QSign.T&C`, the
+//       certificate-application text the partner variant links to.
+//
+// This is the regulated sibling of Electronic Signature: the extra steps are the
+// eIDAS/QTSP consent clauses the signer must tick before a Qualified Electronic
+// Signature can be created, and the certificate-application form behind them.
+//
+// No hardcoded English anywhere in a screen: every visible string arrives here,
+// so the host's locale pack drives the module (the Figma file ships ES + PT
+// columns beside the EN one).
+
+import type { PrizmaConsentSegment } from '@incodetech/prizma-core-web/checkbox';
+
+/**
+ * The two readings of the accept-and-sign screen. They are the same skeleton —
+ * title block → document row → consent stack → CTA — with a different clause
+ * set, a different CTA verb and, on `certificate`, a link to the application
+ * form:
+ * - `accept`      — `QSign.AcceptSign.*` in the generic parent: "Accept and
+ *   sign", five QTSP/eIDAS clauses, "Finish signing", no link.
+ * - `certificate` — the same sections in the `x Namirial` parent: "Review and
+ *   sign", two clauses, "Sign", plus the "Certificate application form" link
+ *   that opens the `terms` document screen.
+ */
+export type QualifiedSignatureAcceptVariant = 'accept' | 'certificate';
+
+/**
+ * The three purple states each accept section is drawn in:
+ * - `default`  — every box unticked, the CTA in Core's disabled surface
+ *   (`QSign.AcceptSign.default`)
+ * - `selected` — every box ticked, the CTA live (`…selectedCheckox`)
+ * - `loading`  — the clauses and the document action greyed while the signature
+ *   is created, spinner in the CTA (`…loadingsign`). The spinner rides the
+ *   BUTTON, never a field — the standing module rule (DEVIATIONS #PI-5).
+ */
+export type QualifiedSignatureAcceptState = 'default' | 'selected' | 'loading';
+
+/**
+ * The two full-surface document screens:
+ * - `document` — `QSign.AcceptSign.viewdoc`, the contract itself behind the
+ *   document row's "View" action
+ * - `terms`    — `QSign.T&C`, the certificate application form behind the
+ *   partner variant's link
+ */
+export type QualifiedSignatureDocumentVariant = 'document' | 'terms';
+
+/**
+ * The FIVE verdict frames. Both purple parents draw success twice and error
+ * twice, and each pair differs in what the signer can do next:
+ * - `signed`        — `QSign.success` (10196:67485): the positive mark with
+ *   "Continue" and a "Download PDF" underlined link
+ * - `signedPlain`   — `QSign.success` (10196:67494): the same mark and line
+ *   with NO actions at all
+ * - `signedPartner` — the `x Namirial` parent's own success frame (6086:40135),
+ *   a THIRD reading rather than a copy of either: the mark and line, a signer
+ *   attribution row, then a STACKED pair — "Done" primary above a "Download
+ *   document" OUTLINED secondary. The outlined button is a different control
+ *   from `signed`'s underlined link, so it gets its own slice
+ * - `error`         — `QSign.AcceptSign.error` (10196:67436): the warning mark
+ *   over "Something went wrong", no actions
+ * - `errorRetry`    — the SECOND error frame both parents draw (10196:67445 /
+ *   the partner's 8363:21429): the same warning mark over "Signature failed"
+ *   plus a full-width "Try again" primary. This is the only recovery
+ *   affordance anywhere in the signing flow
+ */
+export type QualifiedSignatureResultVariant =
+  | 'signed'
+  | 'signedPlain'
+  | 'signedPartner'
+  | 'error'
+  | 'errorRetry';
+
+/**
+ * The two readings of the in-flight screen:
+ * - `processing` — `QSign.AcceptSign.processing` (10196:67395): spinner + H2,
+ *   nothing else on the frame
+ * - `signing`    — the partner's own 6086:39544: "Creating your signature…"
+ *   under the spinner PLUS a bottom-anchored attribution row ("Signing as …")
+ *   sitting immediately above the verified tag, not under the title
+ */
+export type QualifiedSignatureProcessingVariant = 'processing' | 'signing';
+
+/**
+ * One consent clause of the accept screen. Runtime DATA, not module copy — the
+ * clause set is written by the Qualified Trust Service Provider and changes with
+ * it (five Incode-QTSP clauses in one purple parent, two Namirial clauses in the
+ * other), exactly as Phone Input takes its dial codes and CURP its state
+ * catalogue as data rather than strings.
+ *
+ * `segments` is Core's OWN `PrizmaConsentSegment[]`: plain strings render as
+ * copy, objects render as inline links inside the clause — which is how the
+ * fourth Incode clause carries both "Terms of Use" and "Privacy Policy" without
+ * either being hand-rolled.
+ */
+export interface QualifiedSignatureTerm {
+  /** Stable key for the row (also the value reported back by a host). */
+  id: string;
+  /** The clause body, as Core's consent segments. */
+  segments: PrizmaConsentSegment[];
+}
+
+/** Copy for one reading of the accept-and-sign screen. */
+export interface QualifiedSignatureAcceptCopy {
+  /** H2 ("Accept and sign" / "Review and sign"). */
+  title: string;
+  /** H5 below the title. */
+  subtitle?: string;
+  /** Primary CTA ("Finish signing" / "Sign"). */
+  ctaLabel: string;
+  /** Accessible busy label while the signature is created (`loading`). */
+  ctaLoadingLabel?: string;
+  /**
+   * Underlined tertiary link below the primary — the partner variant's
+   * "Certificate application form", which opens the `terms` document screen.
+   * Emits `secondary` so a host can tell it from the primary (DEVIATIONS #PI-10).
+   */
+  linkLabel?: string;
+}
+
+export interface QualifiedSignatureStrings {
+  /** "verified by" attribution in the footer tag. */
+  verifiedLabel: string;
+  /** Accessible name for the logo nav row. */
+  navLabel?: string;
+
+  /** QSign.upload.default — the intro that asks for the file. */
+  upload: {
+    /** H2 ("Upload a document to sign"). */
+    title: string;
+    /** H5 ("Supports PDF files"). */
+    subtitle?: string;
+    /** Hint above the CTA. The purple section draws none. */
+    disclaimer?: string;
+    /** Primary CTA ("Upload document"). */
+    ctaLabel: string;
+  };
+
+  /** QSign.reviewDoc.default — the uploaded file confirmed before signing. */
+  review: {
+    /** H2 ("Review your document"). */
+    title: string;
+    /** H5 ("Make sure you've selected the correct file…"). */
+    subtitle?: string;
+    /** Primary CTA ("Continue"). */
+    ctaLabel: string;
+    /** Secondary CTA ("Replace"). */
+    replaceLabel: string;
+    /** The reassurance row under the card ("All data is encrypted"). */
+    encryptedLabel?: string;
+  };
+
+  /** QSign.AcceptSign.{default,selectedCheckox,loadingsign} — both readings. */
+  accept: {
+    /** Action on the document row — Core's tertiary link ("View"). */
+    viewLabel: string;
+    /** Accessible name for the consent stack. */
+    termsLabel?: string;
+    /** The generic five-clause reading. */
+    accept: QualifiedSignatureAcceptCopy;
+    /** The partner two-clause reading. */
+    certificate: QualifiedSignatureAcceptCopy;
+  };
+
+  /** The two full-surface document screens. */
+  document: {
+    /**
+     * QSign.AcceptSign.viewdoc. **The purple section draws no heading at all**
+     * — GUIDELINES §4 ("every screen has exactly one H2") is the side that wins,
+     * so the screen carries one and the Figma frame is the side to change
+     * (module deviation row). Keep it short: it sits above the page.
+     */
+    document: { title: string };
+    /** QSign.T&C ("Certificate Application Form"), left-aligned in Figma. */
+    terms: { title: string };
+  };
+
+  /** The two in-flight screens. */
+  processing: {
+    /** QSign.AcceptSign.processing — the pure spinner screen. */
+    processing: {
+      /** H2 ("Processing…"). */
+      title: string;
+      subtitle?: string;
+    };
+    /** The partner's own in-flight frame. */
+    signing: {
+      /** H2 under the spinner ("Creating your signature…"). */
+      title: string;
+      subtitle?: string;
+      /**
+       * The attribution row anchored at the BOTTOM of the frame, immediately
+       * above the verified tag ("Signing as Maria Andersson").
+       *
+       * ONE composed line, not a prefix the screen concatenates a name onto:
+       * the host's locale pack interpolates the signer, exactly as Phone
+       * Input's OTP subtitle carries the masked destination number.
+       */
+      signingAsLabel: string;
+    };
+  };
+
+  /** The five verdict screens. */
+  result: {
+    /** QSign.success with actions ("Signed successfully!" + "Download PDF"). */
+    signed: {
+      title: string;
+      subtitle?: string;
+      /** Primary CTA ("Continue"). */
+      ctaLabel: string;
+      /** Underlined tertiary link ("Download PDF"). Emits `secondary`. */
+      downloadLabel?: string;
+    };
+    /** QSign.success drawn with no actions. */
+    signedPlain: { title: string; subtitle?: string };
+    /** The partner's success frame — attribution row over a STACKED pair. */
+    signedPartner: {
+      title: string;
+      subtitle?: string;
+      /**
+       * The attribution row above the buttons ("Signed by Maria Andersson ·
+       * 17 Jun 2026"). ONE composed line for the same reason as
+       * `processing.signing.signingAsLabel` — the locale pack owns the order of
+       * signer and date.
+       */
+      signedByLabel: string;
+      /** Primary CTA ("Done"). Emits `cta`. */
+      ctaLabel: string;
+      /** OUTLINED secondary below the primary ("Download document"). Emits
+       *  `secondary`. A real Button, not `signed`'s underlined link. */
+      secondaryCtaLabel: string;
+    };
+    /** QSign.AcceptSign.error ("Something went wrong"). Figma draws no button. */
+    error: { title: string; subtitle?: string };
+    /** The retry frame ("Signature failed" + "Try again"). */
+    errorRetry: {
+      title: string;
+      subtitle?: string;
+      /** Full-width primary CTA ("Try again"). Emits `cta`. */
+      ctaLabel: string;
+    };
+  };
+}