@alfadocs/ui-kit 1.31.0 → 1.33.0

package/dist/patterns/signature-request/required-documents.d.ts

@@ -0,0 +1,127 @@
+import { type SelectOption } from '../../components/select';
+import { type OperatorChannel, type SignatureChannel } from './channel-meta';
+/** Select value for "Assign later" in every operator picker. */
+export declare const ASSIGN_LATER = "__assign-later__";
+/** What a required item is. Anamnesis interviews never carry a second signee. */
+export type RequiredSignatureItemKind = 'document' | 'anamnesis';
+/** One outstanding document or anamnesis interview in the batch. */
+export interface RequiredSignatureItem {
+    /** Host id, the key of `operatorAssignments` in the submission. */
+    id: string;
+    kind: RequiredSignatureItemKind;
+    /** Display name, e.g. the document template name. */
+    name: string;
+    /** Whether an operator must sign this item. Shows its operator picker. */
+    requiresOperator: boolean;
+    /**
+     * Whether this document has a field for the second signee. The second
+     * signee is offered only when every listed item can carry it. Ignored for
+     * `kind: 'anamnesis'`, which never can. Default `false`.
+     */
+    canCarrySecondary?: boolean;
+    /**
+     * Preselected operator for this item; `null` preselects "Assign later".
+     * Omit to use the modal's `initialOperatorId`.
+     */
+    initialOperatorId?: string | null;
+    /**
+     * Whether the item is already signed (platform `signed` on a document,
+     * `isSigned` on an interview). Signed items are left out. Default `false`.
+     * There is no per-party standing: platform's documents API has none.
+     */
+    signed?: boolean;
+}
+/** The items that still need a signature: those not signed. */
+export declare function itemsStillToSign(items: readonly RequiredSignatureItem[]): RequiredSignatureItem[];
+/**
+ * The second signee signs the whole batch in one round, so it is offered
+ * only when every item can carry that signature. `[].every()` is true, so an
+ * empty batch cannot.
+ */
+export declare function batchCanCarrySecondary(items: readonly RequiredSignatureItem[]): boolean;
+/** Whether an item gets an operator picker: an operator must sign it. */
+export declare function needsOperatorPick(item: RequiredSignatureItem): boolean;
+/**
+ * One option in an operator picker. "Assign later" comes first, as on
+ * platform (OperatorSignee.js). A `disabled` operator shows greyed out with
+ * its `description` (the host's reason); a `deleted` one is hidden unless it
+ * is the picker's current value.
+ */
+export interface OperatorPickerOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    description?: string;
+    deleted?: boolean;
+}
+/** The options one picker lists, given its current value. */
+export declare function operatorPickerOptions(options: readonly OperatorPickerOption[], selected: string | undefined): SelectOption[];
+/** Whether a user could pick this value: listed, not greyed out or deleted. */
+export declare function isPickableOperator(options: readonly OperatorPickerOption[], value: string): boolean;
+/**
+ * The greyed-out operators and their reasons, for the picker trigger: a
+ * disabled option cannot take focus, so its own description is never heard.
+ * `undefined` when none is greyed out.
+ */
+export declare function operatorReasonsHint(options: readonly OperatorPickerOption[], locale: string): string | undefined;
+/**
+ * Why the second signee is withheld from a batch, first reason first; `null`
+ * when it is offered. Mirrors platform (secondarySigneeAvailability.ts and
+ * SecondarySignee.tsx): every item can carry it, the batch is signed on this
+ * device, and the main signer is a registered signee, not the patient.
+ */
+export type SecondSigneeBlock = 'anamnesis' | 'documents' | 'patient' | 'channel';
+export declare function secondSigneeBlock({ items, channel, primaryIsPatient, }: {
+    items: readonly RequiredSignatureItem[];
+    channel: SignatureChannel;
+    primaryIsPatient: boolean;
+}): SecondSigneeBlock | null;
+/** What is wrong with the chosen second signee (platform secondarySigneeValidation.ts). */
+export type SecondSigneeIssue = 'sameAsPrimary' | 'unknownSignee' | 'missingPhone' | 'missingEmail';
+/** The parts of a `SignerOption` the second signee checks read. */
+export interface SecondSigneeCandidate {
+    value: string;
+    isPatient?: boolean;
+    availableChannels?: readonly SignatureChannel[];
+    unavailableChannels?: ReadonlyArray<{
+        channel: SignatureChannel;
+    }>;
+}
+/**
+ * The first issue with a second signee, or `null`. Phone and e-mail are read
+ * from channel availability, so no contact data reaches the kit: a person who
+ * cannot receive SMS or WhatsApp has no phone, one who cannot receive e-mail
+ * has no e-mail. The patient is never a signee, so picking them is unknown.
+ */
+export declare function secondSigneeIssue({ primaryId, secondId, channel, options, }: {
+    primaryId: string | undefined;
+    secondId: string;
+    channel: SignatureChannel;
+    options: readonly SecondSigneeCandidate[];
+}): SecondSigneeIssue | null;
+export interface RequiredDocumentsProps {
+    /** The items to list, already narrowed to those still to sign. */
+    items: readonly RequiredSignatureItem[];
+    loading?: boolean;
+    /**
+     * Operator options, "Assign later" first when allowed. Deleted operators
+     * show only in a picker whose value they are.
+     */
+    operatorOptions: readonly OperatorPickerOption[];
+    /** The picker value per item id, for items that require an operator. */
+    assignments: Readonly<Record<string, string>>;
+    onAssign: (itemId: string, operatorValue: string) => void;
+    /** Shows "Assign all to me" when passed. */
+    onAssignAllToMe?: () => void;
+    busy?: boolean;
+    /**
+     * Adds each picked operator's channel beside their picker, in place of
+     * the note that their settings decide. Default `false`.
+     */
+    showOperatorChannels?: boolean;
+    /** The channel per item id, for items with an assigned operator. */
+    operatorChannels?: Readonly<Record<string, OperatorChannel>>;
+    onOperatorChannel?: (itemId: string, channel: OperatorChannel) => void;
+}
+export declare function RequiredDocuments({ items, loading, operatorOptions, assignments, onAssign, onAssignAllToMe, busy, showOperatorChannels, operatorChannels, onOperatorChannel, }: RequiredDocumentsProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=required-documents.d.ts.map

package/dist/patterns/signature-request/signature-history.d.ts

@@ -0,0 +1,57 @@
+import { type SignatureParty, type SignatureSignerNames } from '../../components/signature-status-chip';
+import { type SignatureChannel } from './channel-meta';
+/** Legal weight of a signature. Advanced needs an OTP-verified signer. */
+export type SignatureLegalLevel = 'simple' | 'advanced';
+/** Which file a download asks for. */
+export type SignatureDownloadVersion = 'full' | 'anonymised';
+/** How a signed document is shared. */
+export type SignatureShareTarget = 'link' | 'email' | 'whatsapp';
+/** One past signature request on the document. */
+export interface SignatureRecord {
+    /** Host id, handed back to every row callback. */
+    id: string;
+    /**
+     * When the request was made: a `Date` or an ISO 8601 string, shown as
+     * weekday, date and time in the active locale and the browser's time zone
+     * (Italian: "Mar. il 25/08/2026 ore 12:45"). An unparseable string is
+     * shown as it is.
+     */
+    createdAt: Date | string;
+    /** How the request reached the signer. */
+    channel: SignatureChannel;
+    /** Omit to show no legal level on this row. */
+    legalLevel?: SignatureLegalLevel;
+    /** The operator's standing, as on SignatureStatusChip. */
+    operator: SignatureParty;
+    /** The patient's standing, as on SignatureStatusChip. */
+    patient: SignatureParty;
+    /** The second signee's standing. Defaults to `notRequired`. */
+    secondary?: SignatureParty;
+    /**
+     * Signer names for the chip's tooltip, including who signed on a
+     * party's behalf (a parent for a minor). Same shape as the chip's `names`.
+     */
+    names?: SignatureSignerNames;
+    /** Offer the anonymised file beside the full one on download. */
+    hasAnonymisedVersion?: boolean;
+    /**
+     * Where this document can be shared, e.g. no `'whatsapp'` for a patient
+     * with no mobile number. Wins over the list's `shareTargets`. The menu
+     * keeps its own order (link, e-mail, WhatsApp); an empty list hides Share
+     * on this row.
+     */
+    shareTargets?: readonly SignatureShareTarget[];
+}
+export interface SignatureHistoryProps {
+    signatures?: readonly SignatureRecord[];
+    loading?: boolean;
+    showLegalLevel?: boolean;
+    onView?: (id: string) => void;
+    onDownload?: (id: string, version: SignatureDownloadVersion) => void;
+    onShare?: (id: string, via: SignatureShareTarget) => void;
+    /** Share targets for rows without their own. Default: all three. */
+    shareTargets?: readonly SignatureShareTarget[];
+    onDelete?: (id: string) => void;
+}
+export declare function SignatureHistory({ signatures, loading, showLegalLevel, onView, onDownload, onShare, shareTargets, onDelete, }: SignatureHistoryProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=signature-history.d.ts.map

package/dist/patterns/signature-request/signature-outcome.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Outcome states of SignatureRequestModal: a final screen in the same dialog
+ * once there is nothing left to fill in. The modal puts the title and the
+ * description in its header and its own actions in the footer; this file
+ * holds the copy and the decorative body.
+ */
+import type { TFunction } from 'i18next';
+/**
+ * - `linkSent`: the request went out by link (SMS, e-mail, WhatsApp).
+ * - `allSigned`: nothing is left to sign.
+ * - `creditsExhausted`: the practice has no electronic signature documents
+ *   left, so the request cannot be sent.
+ */
+export type SignatureRequestOutcome = 'linkSent' | 'allSigned' | 'creditsExhausted';
+/**
+ * Title and description for an outcome, in the active locale. `required`
+ * (required documents mode) uses platform's batch copy for `linkSent`.
+ */
+export declare function outcomeCopy(outcome: SignatureRequestOutcome, t: TFunction, { required }?: {
+    required?: boolean;
+}): {
+    title: string;
+    description: string;
+};
+/** The outcome's body: a decorative status icon. The header carries the words. */
+export declare function SignatureOutcome({ outcome, }: {
+    outcome: SignatureRequestOutcome;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=signature-outcome.d.ts.map