@asteby/storefront-react 0.15.0 → 0.16.1

package/dist/fiscal.css

@@ -0,0 +1,343 @@
+/*
+ * Default sheet for the fiscal components (`@asteby/storefront-react/fiscal.css`): <InvoiceToggle>, <IdentityDocumentReader>,
+ * <FiscalIdentityFields> and <InvoiceStatusCard>. Optional and neutral; it works next to `checkout.css` (the fields).
+ * Colors come from `currentColor` and these variables (set them in light and dark):
+ *   --sf-fiscal-border   hairlines and the drop zone          (default currentColor at 30%)
+ *   --sf-fiscal-muted    secondary text                       (default currentColor at 72%)
+ *   --sf-fiscal-accent   focus ring, primary button           (default #1d4ed8)
+ *   --sf-fiscal-accent-contrast  text on the accent           (default #fff)
+ *   --sf-fiscal-warn     warning text                         (default #8a4b00)
+ *   --sf-fiscal-ok       issued                               (default #166534)
+ * Targets are at least 44px; states carry an icon and a word, never color alone; motion stops with prefers-reduced-motion.
+ */
+[data-sf-invoice-toggle],
+[data-sf-document-reader],
+[data-sf-invoice-card] {
+  --_border: var(--sf-fiscal-border, color-mix(in srgb, currentColor 30%, transparent));
+  --_muted: var(--sf-fiscal-muted, color-mix(in srgb, currentColor 72%, transparent));
+  --_accent: var(--sf-fiscal-accent, #1d4ed8);
+}
+[data-sf-invoice-toggle] {
+  display: grid;
+  gap: 1rem;
+}
+[data-sf-invoice-label],
+[data-sf-reader-save],
+[data-sf-invoice-save],
+[data-sf-fiscal-radio] {
+  display: flex;
+  align-items: flex-start;
+  gap: 0.75rem;
+  min-height: 44px;
+  padding-block: 0.5rem;
+  cursor: pointer;
+}
+[data-sf-invoice-label] {
+  font-weight: 600;
+}
+[data-sf-invoice-label] input,
+[data-sf-reader-save] input,
+[data-sf-invoice-save] input,
+[data-sf-fiscal-radio] input {
+  flex: none;
+  width: 1.5rem;
+  height: 1.5rem;
+  margin: 0;
+  accent-color: var(--_accent);
+}
+[data-sf-invoice-body] {
+  display: grid;
+  gap: 1rem;
+}
+[data-sf-fiscal-fields] {
+  display: grid;
+  gap: 1rem;
+}
+[data-sf-from-document] {
+  font-weight: 600;
+  color: var(--sf-fiscal-ok, #166534);
+}
+[data-sf-fiscal-regimes] {
+  display: grid;
+  gap: 0.25rem;
+}
+[data-sf-fiscal-code] {
+  color: var(--_muted);
+}
+
+/* Reader */
+[data-sf-reader] {
+  display: grid;
+  gap: 0.75rem;
+}
+[data-sf-reader-title] {
+  margin: 0;
+  font-size: 1.0625rem;
+}
+[data-sf-reader-title]:focus {
+  outline: none;
+}
+[data-sf-reader-help],
+[data-sf-reader-privacy] {
+  margin: 0;
+  color: var(--_muted);
+  font-size: 0.875rem;
+}
+[data-sf-reader-zone] {
+  position: relative;
+  display: grid;
+  justify-items: center;
+  gap: 0.25rem;
+  padding: 1.5rem 1rem;
+  min-height: 8rem;
+  border: 2px dashed var(--_border);
+  border-radius: 0.75rem;
+  text-align: center;
+  cursor: pointer;
+  transition: background-color 0.15s, border-color 0.15s;
+}
+[data-sf-reader-zone][data-dragging],
+[data-sf-reader-zone]:hover {
+  border-color: var(--_accent);
+  background: color-mix(in srgb, var(--_accent) 6%, transparent);
+}
+[data-sf-reader-zone]:focus-within {
+  outline: 3px solid var(--_accent);
+  outline-offset: 2px;
+  border-style: solid;
+}
+[data-sf-reader-icon] {
+  font-size: 1.5rem;
+  line-height: 1;
+}
+[data-sf-reader-choose] {
+  min-height: 44px;
+  display: inline-grid;
+  align-items: center;
+  padding-inline: 1rem;
+  border-radius: 0.5rem;
+  border: 1px solid currentColor;
+  font-weight: 600;
+}
+/* The real input stays focusable and clickable, but invisible: the zone is its visible face. */
+[data-sf-reader-input] {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  opacity: 0;
+  cursor: pointer;
+}
+[data-sf-reader-links] {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.25rem 1.25rem;
+  margin: 0;
+}
+[data-sf-reader-links] a,
+[data-sf-reader-links] button,
+[data-sf-invoice-back],
+[data-sf-invoice-other] {
+  min-height: 44px;
+  display: inline-flex;
+  align-items: center;
+  padding: 0;
+  border: 0;
+  background: none;
+  color: inherit;
+  font: inherit;
+  text-decoration: underline;
+  cursor: pointer;
+}
+[data-sf-reader-reading] {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  margin: 0;
+}
+[data-sf-reader-spinner] {
+  flex: none;
+  width: 1.25rem;
+  height: 1.25rem;
+  border: 3px solid var(--_border);
+  border-top-color: var(--_accent);
+  border-radius: 50%;
+  animation: sf-fiscal-spin 0.9s linear infinite;
+}
+[data-sf-reader-error] {
+  padding: 0.75rem 1rem;
+  border: 2px solid var(--sf-field-error, #b42318);
+  border-radius: 0.5rem;
+  font-weight: 600;
+}
+[data-sf-reader-error]::before {
+  content: '! ';
+}
+[data-sf-reader-error]:focus {
+  outline: 3px solid var(--_accent);
+  outline-offset: 2px;
+}
+[data-sf-reader-warnings] {
+  margin: 0;
+  padding: 0.75rem 1rem;
+  list-style: none;
+  display: grid;
+  gap: 0.5rem;
+  border: 1px solid var(--sf-fiscal-warn, #8a4b00);
+  border-radius: 0.5rem;
+  color: var(--sf-fiscal-warn, #8a4b00);
+}
+[data-sf-invoice-actions],
+[data-sf-reader-actions] {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem 1rem;
+}
+[data-sf-reader-confirm],
+[data-sf-reader-cancel],
+[data-sf-reader-retry],
+[data-sf-reader-upload],
+[data-sf-invoice-change],
+[data-sf-invoice-request],
+[data-sf-invoice-correct],
+[data-sf-invoice-refresh],
+[data-sf-invoice-pdf],
+[data-sf-invoice-xml],
+[data-sf-invoice-contact] {
+  min-height: 44px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding-inline: 1.25rem;
+  border-radius: 0.5rem;
+  border: 1px solid currentColor;
+  background: none;
+  color: inherit;
+  font: inherit;
+  font-weight: 600;
+  text-decoration: none;
+  cursor: pointer;
+}
+[data-sf-reader-confirm],
+[data-sf-invoice-request],
+[data-sf-invoice-correct],
+[data-sf-invoice-pdf] {
+  background: var(--_accent);
+  border-color: var(--_accent);
+  color: var(--sf-fiscal-accent-contrast, #fff);
+}
+:is([data-sf-reader-confirm], [data-sf-invoice-request], [data-sf-invoice-correct], [data-sf-invoice-pdf], [data-sf-invoice-change], [data-sf-invoice-refresh]):focus-visible,
+[data-sf-reader-links] :focus-visible,
+[data-sf-invoice-back]:focus-visible,
+[data-sf-invoice-other]:focus-visible {
+  outline: 3px solid var(--_accent);
+  outline-offset: 2px;
+}
+
+/* Saved profile card */
+[data-sf-invoice-profile],
+[data-sf-invoice-card] {
+  display: grid;
+  gap: 0.75rem;
+  padding: 1rem;
+  border: 1px solid var(--_border);
+  border-radius: 0.75rem;
+}
+[data-sf-invoice-profile] dl {
+  display: grid;
+  gap: 0.25rem;
+  margin: 0;
+}
+[data-sf-invoice-row] {
+  display: grid;
+  grid-template-columns: minmax(7rem, 35%) 1fr;
+  gap: 0.5rem;
+}
+[data-sf-invoice-row] dt {
+  color: var(--_muted);
+}
+[data-sf-invoice-row] dd {
+  margin: 0;
+  overflow-wrap: anywhere;
+}
+[data-sf-invoice-profile-title] {
+  margin: 0;
+  font-weight: 600;
+}
+[data-sf-invoice-privacy] {
+  margin: 0;
+  color: var(--_muted);
+  font-size: 0.875rem;
+}
+
+/* Status card */
+[data-sf-invoice-title] {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  margin: 0;
+  font-size: 1.0625rem;
+}
+[data-sf-invoice-icon] {
+  display: inline-grid;
+  place-items: center;
+  flex: none;
+  width: 1.75rem;
+  height: 1.75rem;
+  border: 2px solid currentColor;
+  border-radius: 50%;
+  font-size: 0.9rem;
+  font-weight: 700;
+}
+[data-sf-invoice-card][data-state='issued'] [data-sf-invoice-icon] {
+  color: var(--sf-fiscal-ok, #166534);
+}
+[data-sf-invoice-card][data-state='needs_data'] [data-sf-invoice-icon] {
+  color: var(--sf-field-error, #b42318);
+}
+[data-sf-invoice-card][data-state='processing'] [data-sf-invoice-icon] {
+  animation: sf-fiscal-spin 1.6s linear infinite;
+}
+[data-sf-invoice-card] p {
+  margin: 0;
+}
+[data-sf-invoice-card] [data-sf-invoice-live] {
+  display: grid;
+  gap: 0.5rem;
+}
+[data-sf-invoice-folio] code {
+  overflow-wrap: anywhere;
+}
+
+@keyframes sf-fiscal-spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+@media (prefers-reduced-motion: reduce) {
+  [data-sf-reader-spinner],
+  [data-sf-invoice-card][data-state='processing'] [data-sf-invoice-icon] {
+    animation: none;
+  }
+  [data-sf-reader-zone] {
+    transition: none;
+  }
+}
+@media (max-width: 30rem) {
+  [data-sf-invoice-row] {
+    grid-template-columns: 1fr;
+    gap: 0;
+  }
+  [data-sf-invoice-actions] > *,
+  [data-sf-reader-confirm] {
+    flex: 1 1 100%;
+  }
+}
+
+[data-sf-fiscal-regimes] legend {
+  padding: 0;
+  font-weight: 600;
+}
+[data-sf-invoice-actions] {
+  align-items: center;
+}

package/dist/fiscal.d.cts

@@ -0,0 +1,313 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { F as FieldErrors, a as CheckoutFieldClassNames } from './fields-vnMUi2HB.cjs';
+import { Region, RegionFiscalId, RegionFiscalEntry, InvoiceRequest, FiscalDocumentEvidence, IdentityDocumentSpec, InvoicingCapabilities, FiscalIdentity, InvoiceSummary } from '@asteby/storefront';
+import { d as FiscalFieldValues, c as FiscalFieldName, f as FiscalReadError, F as FiscalActionData, b as FiscalExtractionSummary } from './types-BnvSbV6t.cjs';
+export { a as FiscalErrorCode, e as FiscalIntent } from './types-BnvSbV6t.cjs';
+import { IdentityExtraction } from '@asteby/storefront/fiscal-document';
+
+/**
+ * Pure helpers over the region's fiscal catalog (`Region.fiscal_id`). They know no country: the tax id format, the
+ * regimes, the invoice uses and the postal code format are all data.
+ */
+
+type FiscalRegion = Pick<Region, 'address'> & {
+    fiscal_id?: RegionFiscalId;
+};
+/** Uppercase, no spaces, hyphens or dots: how a tax id is compared and sent. */
+declare function normalizeTaxId(raw: string): string;
+/** Masks a tax id for display and logs: first 2 and last 3 characters stay (`PE********ABC`). */
+declare function maskTaxId(taxId: string): string;
+/** `null` when the tax id is valid for the region (its pattern or one of its generic ids); otherwise why not. */
+declare function taxIdProblem(fid: RegionFiscalId | undefined, raw: string): 'required' | 'format' | null;
+declare function postalCodeProblem(region: FiscalRegion, raw: string): 'required' | 'format' | null;
+/**
+ * Builds the function that tells a person type from a tax id when the region does not publish one. Pass the length
+ * of the tax id per type, e.g. `personTypeByLength({ individual: 13, company: 12 })`. Without a function the regimes
+ * are not narrowed by person type (the server still checks the combination).
+ */
+declare function personTypeByLength(lengths: Record<string, number>): (taxId: string) => string | null;
+/** Regimes that fit a person type (all when the type is unknown). */
+declare function regimesFor(fid: RegionFiscalId | undefined, personType: string | null): RegionFiscalEntry[];
+/** Invoice uses a regime admits (all when no regime is chosen yet). */
+declare function usesFor(fid: RegionFiscalId | undefined, regime: string | null | undefined): RegionFiscalEntry[];
+type FiscalProblem = 'required' | 'format' | 'unknown' | 'person_type' | 'use_not_allowed';
+/** Client-side check of the whole form against the region; the server stays the authority. */
+declare function validateFiscalValues(region: FiscalRegion, v: Partial<FiscalFieldValues>, personTypeOf?: (taxId: string) => string | null): Partial<Record<FiscalFieldName, FiscalProblem>>;
+/** Form values -> the API's `InvoiceRequest` (without `document`). */
+declare function toInvoiceRequest(v: Partial<FiscalFieldValues>, countryCode?: string): InvoiceRequest;
+/** `label_en` for English locales when the region has it. */
+declare function entryLabel(e: RegionFiscalEntry, locale?: string | null): string;
+
+/** Texts of the fiscal components. Spanish (es-MX) by default, English with `en*`, any locale with `messages`. */
+
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends Record<string, unknown> ? DeepPartial<T[K]> : T[K];
+};
+type FiscalMessages = {
+    fields: {
+        legend: string;
+        taxId: string;
+        taxIdHint: string;
+        legalName: string;
+        /** Used when the region publishes no help for the legal name. */
+        legalNameHint: string;
+        postalCode: string;
+        postalCodeHint: string;
+        regime: string;
+        regimeHint: string;
+        regimeChoose: string;
+        regimeFromDocument: string;
+        use: string;
+        useHint: string;
+        useChoose: string;
+        /** `{document}` = the document's name. */
+        fromDocument: string;
+        errors: {
+            required: string;
+            taxIdFormat: string;
+            postalFormat: string;
+            unknown: string;
+            personType: string;
+            useNotAllowed: string;
+        };
+    };
+    reader: {
+        /** `{document}`. */
+        title: string;
+        dropHint: string;
+        dropActive: string;
+        choose: string;
+        obtain: string;
+        privacyBrowser: string;
+        privacyServer: string;
+        uploadServer: string;
+        manual: string;
+        reading: string;
+        cancel: string;
+        done: string;
+        reviewTitle: string;
+        reviewHint: string;
+        confirm: string;
+        changeFile: string;
+        saveToAccount: string;
+        saveConsent: string;
+        warnings: {
+            qrMismatch: string;
+            stale: string;
+            regimeMissing: string;
+            fieldsMissing: string;
+        };
+        errors: Record<FiscalReadError, string>;
+        summaryTitleOne: string;
+        summaryTitleMany: string;
+    };
+    toggle: {
+        label: string;
+        payDefault: string;
+        payAndInvoice: string;
+        profileTitle: string;
+        change: string;
+        useOther: string;
+        useSaved: string;
+        manualTitle: string;
+        unavailable: string;
+        privacy: string;
+        fieldsOf: {
+            taxId: string;
+            legalName: string;
+            postalCode: string;
+            regime: string;
+            use: string;
+        };
+    };
+    status: {
+        title: string;
+        request: string;
+        requestHelp: string;
+        awaitingTitle: string;
+        awaitingBody: string;
+        processingTitle: string;
+        processingBody: string;
+        processingSlow: string;
+        refresh: string;
+        issuedTitle: string;
+        issuedBody: string;
+        folio: string;
+        pdf: string;
+        xml: string;
+        needsDataTitle: string;
+        needsDataBody: string;
+        correct: string;
+        reviewTitle: string;
+        reviewBody: string;
+        contact: string;
+        contactBy: string;
+        windowTitle: string;
+        windowBody: string;
+        unavailableTitle: string;
+        unavailableBody: string;
+        cancelledTitle: string;
+        cancelledBody: string;
+        /** `reason_code` -> cause for the buyer. `default` when unknown. */
+        reasons: Record<string, string>;
+    };
+    server: {
+        errors: Record<string, string>;
+    };
+};
+/** Messages for a locale (`es*` default, `en*`), with optional overrides (merged level by level). */
+declare function fiscalMessages(locale?: string | null, overrides?: DeepPartial<FiscalMessages> | null): FiscalMessages;
+
+type FiscalIdentityFieldsClassNames = CheckoutFieldClassNames & Partial<Record<'fieldset' | 'legend' | 'mark' | 'radios' | 'radio', string>>;
+type FiscalIdentityFieldsProps = {
+    region: FiscalRegion;
+    /** Initial values (and, when they change, the new values: e.g. after a document is read). */
+    values?: Partial<FiscalFieldValues>;
+    onChange?: (values: FiscalFieldValues) => void;
+    /** Fields that were filled from a document: they get the "From your {document}" mark and stay editable. */
+    fromDocument?: readonly FiscalFieldName[];
+    /** Short noun of the document for the mark ("constancia"). Default: nothing specific ("tu documento"). */
+    documentName?: string;
+    /** The document listed these regimes: show only them, as radios. */
+    regimeCandidates?: readonly string[];
+    /** Errors by control name (`invoice.tax_regime`), from the server or `useFieldErrors`. */
+    errors?: FieldErrors;
+    namePrefix?: string;
+    /** Prefix of the control ids (default: generated). */
+    idPrefix?: string;
+    /** Tells a person type from a tax id, to narrow the regimes (`personTypeByLength`). */
+    personTypeOf?: (taxId: string) => string | null;
+    disabled?: boolean;
+    locale?: string;
+    messages?: DeepPartial<FiscalMessages>;
+    classNames?: FiscalIdentityFieldsClassNames;
+    /** Hides the fieldset legend (when the caller already has a heading). */
+    hideLegend?: boolean;
+};
+declare function FiscalIdentityFields({ region, values, onChange, fromDocument, documentName, regimeCandidates, errors, namePrefix, idPrefix, personTypeOf, disabled, locale: localeProp, messages, classNames: cx, hideLegend, }: FiscalIdentityFieldsProps): react.JSX.Element;
+
+type FiscalReaderResult = {
+    values: FiscalFieldValues;
+    /** Where the data came from; `null` when the buyer typed everything. */
+    evidence: FiscalDocumentEvidence | null;
+    /** The buyer asked to save the data to their account (`canSave`). */
+    save: boolean;
+};
+type IdentityDocumentReaderClassNames = FiscalIdentityFieldsClassNames & Partial<Record<'root' | 'zone' | 'zoneActive' | 'button' | 'link' | 'privacy' | 'status' | 'error' | 'warning' | 'notice' | 'actions' | 'primary' | 'secondary' | 'summary', string>>;
+type IdentityDocumentReaderProps = {
+    region: FiscalRegion;
+    /** The document to read. Default: the first of `region.fiscal_id.documents`. */
+    document?: IdentityDocumentSpec;
+    /**
+     * URL of the pdf.js worker (`pdf.worker.mjs` from `pdfjs-dist/legacy/build`) that YOUR site serves. There is no
+     * default and no CDN: without it the browser cannot read the file and the buyer is sent to manual entry.
+     */
+    workerSrc?: string;
+    /** The buyer confirmed the reviewed data. */
+    onConfirm: (result: FiscalReaderResult) => void;
+    /** The buyer chose to type their data. Default: the review form opens empty. */
+    onManual?: () => void;
+    /** Values to start the review with (e.g. a saved profile). */
+    initialValues?: Partial<FiscalFieldValues>;
+    /** Result of the server (no-JS upload): when it carries an `extraction` or an error, it is shown. */
+    data?: FiscalActionData | null;
+    /** The shop has a signed-in buyer: offer "Save to my account". */
+    canSave?: boolean;
+    /** Enables the no-JS upload (a button that posts the file to the action with `intent=extract-document`). */
+    serverUpload?: boolean;
+    /** Short noun of the document for texts ("constancia"). Default: the spec's label in lowercase. */
+    documentName?: string;
+    personTypeOf?: (taxId: string) => string | null;
+    /** Clock for tests. */
+    now?: () => Date;
+    namePrefix?: string;
+    locale?: string;
+    messages?: DeepPartial<FiscalMessages>;
+    classNames?: IdentityDocumentReaderClassNames;
+    /** Label of the confirm button. */
+    confirmLabel?: ReactNode;
+};
+declare function IdentityDocumentReader(props: IdentityDocumentReaderProps): react.JSX.Element | null;
+
+type InvoiceToggleState = {
+    requested: boolean;
+    /** The data to send as `CheckoutInput.invoice` / `carts.setInvoice`; `null` when none is requested or it is not ready. */
+    invoice: InvoiceRequest | null;
+    /** All the data is there and valid for the region (the server still checks it). */
+    ready: boolean;
+    source: 'profile' | 'document' | 'manual' | null;
+    /** "Pay" or "Pay and invoice": the label for the pay button. */
+    payLabel: string;
+};
+type InvoiceToggleClassNames = IdentityDocumentReaderClassNames & Partial<Record<'toggle' | 'body' | 'card' | 'cardRow' | 'cardTitle' | 'unavailable', string>>;
+type InvoiceToggleProps = {
+    region: FiscalRegion & {
+        country_code?: string;
+    };
+    /** `loadFiscalContext(...).invoicing`. `available: false` or `checkout: 'off'` renders nothing. */
+    capabilities?: InvoicingCapabilities | null;
+    /** The buyer's saved fiscal data (`customer.fiscal`). */
+    profile?: FiscalIdentity | null;
+    defaultRequested?: boolean;
+    onChange?: (state: InvoiceToggleState) => void;
+    /** Result of the shop's action (server errors by field, a document read without JS). */
+    data?: FiscalActionData | null;
+    /** The buyer is signed in: they can save the data to their account. */
+    canSave?: boolean;
+    workerSrc?: string;
+    /** Enables the no-JS document upload. */
+    serverUpload?: boolean;
+    /** Link (e.g. `?invoice=1`) that opens the section when JavaScript is not available. */
+    noJsHref?: string;
+    document?: IdentityDocumentSpec;
+    documentName?: string;
+    personTypeOf?: (taxId: string) => string | null;
+    /** Label of the pay button when no invoice is asked. Default from the messages. */
+    payLabel?: string;
+    namePrefix?: string;
+    locale?: string;
+    messages?: DeepPartial<FiscalMessages>;
+    classNames?: InvoiceToggleClassNames;
+    now?: () => Date;
+};
+declare function InvoiceToggle(props: InvoiceToggleProps): react.JSX.Element | null;
+
+type InvoiceCardState = 'not_requested' | 'awaiting_payment' | 'processing' | 'issued' | 'needs_data' | 'needs_review' | 'window_closed' | 'unavailable' | 'cancelled';
+/** Which of the card's states an invoice is in. `available: false` (the store does not invoice) wins over everything. */
+declare function invoiceCardState(invoice: InvoiceSummary | null | undefined, available?: boolean): InvoiceCardState;
+type InvoiceStatusCardClassNames = Partial<Record<'root' | 'title' | 'body' | 'actions' | 'primary' | 'secondary' | 'link' | 'meta', string>>;
+type InvoiceStatusCardProps = {
+    invoice?: InvoiceSummary | null;
+    /** `capabilities.invoicing.available`. `false`: "Invoice not available". */
+    available?: boolean;
+    /** The buyer taps "Request invoice". Shown when `invoice.can_request !== false`. Without it, `requestHref` is a link. */
+    onRequest?: () => void;
+    requestHref?: string;
+    /** "Fix and retry". Without it, `correctHref` is a link. */
+    onCorrect?: () => void;
+    correctHref?: string;
+    /** Called while the invoice is processing (every `refreshMs`, for at most `refreshForMs`). Reload the order there. */
+    onRefresh?: () => void;
+    refreshMs?: number;
+    refreshForMs?: number;
+    /** How to reach the store when it must review: an email, a phone or a URL. */
+    contact?: {
+        email?: string;
+        phone?: string;
+        url?: string;
+    };
+    locale?: string;
+    messages?: DeepPartial<FiscalMessages>;
+    classNames?: InvoiceStatusCardClassNames;
+    /** Heading level of the title (default 3). */
+    headingLevel?: 2 | 3 | 4;
+};
+declare function InvoiceStatusCard(props: InvoiceStatusCardProps): react.JSX.Element;
+
+/** Turns what the engine read into what the UI shows. Shared by the browser reader and the server upload. */
+
+/** `evidence` comes from `buildDocumentEvidence`. Only the conventional fields are kept: nothing else can leak. */
+declare function summarizeExtraction(x: IdentityExtraction, evidence: FiscalDocumentEvidence, validRegimes?: Iterable<string>): FiscalExtractionSummary;
+
+export { type DeepPartial, FiscalActionData, FiscalExtractionSummary, FiscalFieldName, FiscalFieldValues, FiscalIdentityFields, type FiscalIdentityFieldsClassNames, type FiscalIdentityFieldsProps, type FiscalMessages, type FiscalProblem, FiscalReadError, type FiscalReaderResult, type FiscalRegion, IdentityDocumentReader, type IdentityDocumentReaderClassNames, type IdentityDocumentReaderProps, type InvoiceCardState, InvoiceStatusCard, type InvoiceStatusCardClassNames, type InvoiceStatusCardProps, InvoiceToggle, type InvoiceToggleClassNames, type InvoiceToggleProps, type InvoiceToggleState, entryLabel, fiscalMessages, invoiceCardState, maskTaxId, normalizeTaxId, personTypeByLength, postalCodeProblem, regimesFor, summarizeExtraction, taxIdProblem, toInvoiceRequest, usesFor, validateFiscalValues };