@alfadocs/ui-kit 1.2.0 → 1.3.0

package/dist/patterns/anamnesis/anamnesis-events.d.ts

@@ -0,0 +1,60 @@
+import type { TFunction } from 'i18next';
+import type { MarkerShape } from '../../components/annotation-marker';
+import type { SparklineAnnotation, SparklineAnnotationTone } from '../../components/sparkline';
+import type { ClinicalEvent, ClinicalEventCategory, Visit } from './anamnesis-types';
+/**
+ * ONE shape per category, and that is the whole vocabulary — five distinct
+ * glyphs, no per-category hue.
+ *
+ * Five saturated semantic tones (error / success / accent / warning / info)
+ * used to ride these shapes. Three or four events picked at once put four
+ * competing hues across a 32px-tall sparkline, nineteen rows deep, and the
+ * annotations then out-shouted the trend line they exist to annotate. Shape
+ * is already the accessible channel here (WCAG 1.4.1, and the kit's rule in
+ * `src/components/annotation-marker/`), so the hue was reinforcement the
+ * reader was paying for in noise.
+ */
+export declare const EVENT_SHAPE: Record<ClinicalEventCategory, MarkerShape>;
+/**
+ * The single restrained tone every annotation wears, chip and line alike.
+ *
+ * `neutral` resolves to `--muted-foreground`, the only hueless token that
+ * clears WCAG 1.4.11's 3:1 for a non-text graphic in all four themes
+ * (measured 6.9:1 light, 7.5:1 dark, 18.4:1 / 13.9:1 accessible, against
+ * `--card`). Hueless is the point: the trend line is tinted by VALENCE —
+ * green improving, red worsening — and an annotation with a hue of its own
+ * competes with that read.
+ */
+export declare const EVENT_TONE: SparklineAnnotationTone;
+/** An event that HAS a place on the plot, with the fraction it sits at. */
+export interface EventMark {
+    event: ClinicalEvent;
+    /** Fraction of the shared x domain: 0 = first visit, 1 = latest. */
+    position: number;
+}
+/**
+ * Where an event sits on the domain every row shares, or `null` when it has
+ * no place on the plot.
+ *
+ * `null` — rather than a clamp to 0 or 1 — for an event outside the visit
+ * span: the plot covers first visit → latest, and pinning an event that
+ * predates the record to the left edge would invent a correlation with a
+ * measurement taken before it happened. Also `null` below two visits (no
+ * extent to sit on) and on any unreadable date.
+ *
+ * `visits` is read in ARRAY ORDER, and chronological order is an UNCHECKED
+ * precondition: an out-of-order array can bracket the event on a span that
+ * runs backwards and place the marker accordingly.
+ */
+export declare function eventPosition(event: ClinicalEvent, visits: readonly Visit[]): number | null;
+/** The events that can be drawn, in the order they happened. */
+export declare function eventMarks(events: readonly ClinicalEvent[] | undefined, visits: readonly Visit[]): EventMark[];
+/** "Chemotherapy started · 2 Sep 2024" — what the chip says. */
+export declare function eventLabel(event: ClinicalEvent, t: TFunction): string;
+/** Rides the chip as its accessible description: what kind of thing this was,
+ * and — when it was not this practice's own decision — who recorded it. */
+export declare function eventDetail(event: ClinicalEvent, t: TFunction): string;
+/** The picked events as sparkline annotations. Every row of the grid is given
+ * this SAME array, which is what pins one event to one x down the column. */
+export declare function eventAnnotations(marks: readonly EventMark[], activeIds: ReadonlySet<string>, t: TFunction): SparklineAnnotation[];
+//# sourceMappingURL=anamnesis-events.d.ts.map

package/dist/patterns/anamnesis/anamnesis-evolution-grid.d.ts

@@ -0,0 +1,48 @@
+import type { TFunction } from 'i18next';
+import type { SparklineAnnotation } from '../../components/sparkline';
+import { type VisitColumn } from './anamnesis-window';
+import type { AnamnesisRecord, NumericParameterDef, OpenAnamnesisNote, Visit } from './anamnesis-types';
+export interface AnamnesisEvolutionGridProps {
+    record: AnamnesisRecord;
+    defs: NumericParameterDef[];
+    t: TFunction;
+    /** Make the newest visit column editable (compile mode). */
+    editable?: boolean;
+    onCellChange?: (visit: Visit, def: NumericParameterDef, value: number | null) => void;
+    /** Compare mode: the visit ids under comparison (two or more) + the CELLS
+     * that differ from the compared column before them, keyed
+     * `<visitId>:<parameterKey>`. Per cell, never per parameter: at three or
+     * more compared visits a column equal to its predecessor did not change. */
+    compare?: {
+        visitIds: ReadonlySet<string>;
+        changedCells: ReadonlySet<string>;
+    } | null;
+    /** Draw the outer border + surface (standalone use). Set `false` when the
+     * grid already sits inside a card, to avoid a box-in-a-box. */
+    framed?: boolean;
+    /** Mount this visit's note popover already open. Demo/story hook only —
+     * Chromatic skips play functions, so a click-opened popover is never
+     * snapshotted. Ignored once `onOpenNote` is wired. */
+    defaultOpenNoteVisitId?: string;
+    /** Route a visit's note to the host's side panel instead of opening it in
+     * place. Omitted = read in place, which is all a standalone grid can do. */
+    onOpenNote?: OpenAnamnesisNote;
+    /** Which columns render, from the visit window. Omitted = every visit.
+     * Column order and `index` always follow `record.visits`; the window
+     * changes what is SHOWN, never what was computed. */
+    visitColumns?: readonly VisitColumn[];
+    /** Keys the practice still captures. A key outside this set renders its
+     * history read-only: archiving stops capture, it never erases the record.
+     * Omitted = every def is capturable. */
+    capturableKeys?: ReadonlySet<string>;
+    /** Event reference lines, positioned as a fraction of the record's visit
+     * span. Every row gets this SAME array, which is what makes one event one
+     * vertical line down the whole grid rather than one line per row. */
+    annotations?: readonly SparklineAnnotation[];
+    /** Make those lines pointer-selectable — pressing one is pressing the
+     * event's chip in the bar above. Omitted = the lines stay decorative, which
+     * is all a grid with no event bar above it can honestly offer. */
+    onSelectAnnotation?: (eventId: string) => void;
+}
+export declare function AnamnesisEvolutionGrid({ record, defs, t, editable, onCellChange, compare, framed, defaultOpenNoteVisitId, onOpenNote, visitColumns, capturableKeys, annotations, onSelectAnnotation, }: AnamnesisEvolutionGridProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=anamnesis-evolution-grid.d.ts.map

package/dist/patterns/anamnesis/anamnesis-evolution.d.ts

@@ -0,0 +1,37 @@
+import type { TFunction } from 'i18next';
+import { type PracticeAnamnesisConfig } from './anamnesis-config';
+import type { AnamnesisRecord, NumericParameterDef, OpenAnamnesisNote, Visit } from './anamnesis-types';
+export interface AnamnesisEvolutionProps {
+    record: AnamnesisRecord;
+    t: TFunction;
+    editable?: boolean;
+    onCellChange?: (visit: Visit, def: NumericParameterDef, value: number | null) => void;
+    /** Draw the grid's own border/surface. `false` when this sits inside a card. */
+    framed?: boolean;
+    /** The practice's configured vocabulary. Omitted = the kit-seeded default. */
+    config?: PracticeAnamnesisConfig;
+    /** Mount with the compare panel already open. Demo/story hook only —
+     * Chromatic skips play functions, so a click-opened panel is never
+     * snapshotted. */
+    defaultCompareOpen?: boolean;
+    /** Mount with this visit selection instead of first + latest. Demo/story
+     * hook only, for the same Chromatic reason. */
+    defaultVisitIds?: readonly string[];
+    /** Mount the compare panel on this set of visits instead of first + latest.
+     * Demo/story hook only, for the same Chromatic reason. */
+    defaultCompareVisitIds?: readonly string[];
+    /** Mount with these events already drawn. Demo/story hook only — the
+     * arrival state picks none, and Chromatic skips play functions. */
+    defaultEventIds?: readonly string[];
+    /** The picker's live selection, whenever it changes (and once on mount).
+     * The Diagnosis surface's one export control needs to know which visit
+     * columns are on screen — the file must be the view that was asked for. */
+    onVisitSelectionChange?: (visitIds: readonly string[]) => void;
+    /** The host's side panel. Wired ⇒ a visit's note trigger routes there
+     * instead of opening a popover, and turning an event chip on navigates the
+     * panel to that event. Omitted ⇒ the note opens in place and the chip only
+     * draws its line, which is all a standalone surface can do. */
+    onOpenNote?: OpenAnamnesisNote;
+}
+export declare function AnamnesisEvolution({ record, t, editable, onCellChange, framed, config, defaultCompareOpen, defaultVisitIds, defaultCompareVisitIds, defaultEventIds, onVisitSelectionChange, onOpenNote, }: AnamnesisEvolutionProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=anamnesis-evolution.d.ts.map

package/dist/patterns/anamnesis/anamnesis-export-download.d.ts

@@ -0,0 +1,10 @@
+import { type CsvDialect, type ExportDocument } from './anamnesis-export';
+/** Hand a Blob to the browser as a download. Returns `false` where there is no
+ * DOM to hand it to (SSR, a node test), so callers can fall back rather than
+ * throw. */
+export declare function downloadBlob(blob: Blob, filename: string): boolean;
+/** Download the document as a `.csv` in the dialect its locale calls for. */
+export declare function downloadCsv(doc: ExportDocument, dialect?: CsvDialect): boolean;
+/** Download the document as an `.xlsx`. Async: exceljs is dynamic-imported. */
+export declare function downloadXlsx(doc: ExportDocument): Promise<boolean>;
+//# sourceMappingURL=anamnesis-export-download.d.ts.map

package/dist/patterns/anamnesis/anamnesis-export-menu.d.ts

@@ -0,0 +1,23 @@
+import type { TFunction } from 'i18next';
+import type { PracticeAnamnesisConfig } from './anamnesis-config';
+import type { DisclosureAudience } from './anamnesis-disclosure';
+import { type AnamnesisExportTab } from './anamnesis-export';
+import type { AnamnesisRecord } from './anamnesis-types';
+export interface AnamnesisExportMenuProps {
+    /** The tab the surface is showing. The control acts on THIS view. */
+    tab: AnamnesisExportTab;
+    record: AnamnesisRecord;
+    t: TFunction;
+    config?: PracticeAnamnesisConfig;
+    /** Evolution only: the visit columns the grid is currently showing. */
+    shownVisitIds?: readonly string[];
+    /** Mount with the menu open. Demo/story hook only — Chromatic skips play
+     * functions, so a click-opened menu is never snapshotted. */
+    defaultOpen?: boolean;
+    /** Mount with the share preview open. Demo/story hook, same reason. */
+    defaultShareOpen?: boolean;
+    /** Mount on this audience instead of the practice copy. Demo/story hook. */
+    defaultAudience?: DisclosureAudience;
+}
+export declare function AnamnesisExportMenu({ tab, record, t, config, shownVisitIds, defaultOpen, defaultShareOpen, defaultAudience, }: AnamnesisExportMenuProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=anamnesis-export-menu.d.ts.map

package/dist/patterns/anamnesis/anamnesis-export-pdf.d.ts

@@ -0,0 +1,36 @@
+import { type ExportDocument } from './anamnesis-export';
+export declare const PDF_MIME = "application/pdf";
+export type PdfRgb = [number, number, number];
+export interface PdfPalette {
+    headerFill: PdfRgb;
+    headerText: PdfRgb;
+    bodyText: PdfRgb;
+    mutedText: PdfRgb;
+    zebraFill: PdfRgb;
+    sectionFill: PdfRgb;
+}
+/** The document palette for the theme `scope` is rendered in. Pass the pattern
+ * root; omit it and the fallback greys are used. */
+export declare function pdfPalette(scope?: Element | null): PdfPalette;
+/** True when jsPDF can draw `text` with a built-in face — i.e. it will not be
+ * silently re-encoded as UTF-16. */
+export declare function isWinAnsiSafe(text: string): boolean;
+/** Respell the symbols a standard-14 face cannot draw. Applied at the writer
+ * boundary, so the arrow survives on screen and in the spreadsheet. */
+export declare function pdfSafeText(text: string): string;
+export interface PdfOptions {
+    palette?: PdfPalette;
+    /** Set the PDF's own open action so the viewer raises the print dialog.
+     * This is what the Print item uses; a downloaded PDF leaves it off. */
+    autoPrint?: boolean;
+}
+/** The document as a paged PDF. jspdf + jspdf-autotable are dynamic-imported,
+ * so neither ships to a consumer who never exports. */
+export declare function toPdfBlob(document: ExportDocument, options?: PdfOptions): Promise<Blob>;
+/** Download the document as a `.pdf`. */
+export declare function downloadPdf(document: ExportDocument, options?: PdfOptions): Promise<boolean>;
+/** Point an off-screen frame at the document with the print action armed, and
+ * hand the object URL back so the caller can revoke it. `null` means there was
+ * no frame or no `URL.createObjectURL` to build one with. */
+export declare function printPdf(document: ExportDocument, frame: HTMLIFrameElement | null, options?: PdfOptions): Promise<string | null>;
+//# sourceMappingURL=anamnesis-export-pdf.d.ts.map

package/dist/patterns/anamnesis/anamnesis-export.d.ts

@@ -0,0 +1,143 @@
+import type { TFunction } from 'i18next';
+import { type PracticeAnamnesisConfig } from './anamnesis-config';
+import { type DisclosureAudience } from './anamnesis-disclosure';
+import type { AnamnesisRecord, NumericParameterDef } from './anamnesis-types';
+/** A cell. `null` is ABSENT and every writer renders it as an empty cell —
+ * never the em dash the screen uses, which a spreadsheet cannot compute on. */
+export type ExportValue = string | number | null;
+export interface ExportColumn {
+    /** Stable key — the Excel column key, never rendered. */
+    key: string;
+    /** Translated header text. */
+    header: string;
+    /** Numbers land in this column: right-aligned and number-formatted. */
+    numeric?: boolean;
+    /** Decimal places for numeric cells, when the whole column shares one. */
+    precision?: number;
+}
+export interface ExportRow {
+    /** `section` is a group banner: cell 0 carries the label, the rest is blank. */
+    kind?: 'data' | 'section';
+    /** Aligned to `columns` by index; short rows are padded by the writer. */
+    cells: ExportValue[];
+    /** Decimal places for THIS row's numeric cells — a parameter row carries its
+     * own precision, and the column cannot know it. Wins over the column. */
+    precision?: number;
+}
+export interface ExportTable {
+    /** Stable id — the worksheet key and the PDF anchor. */
+    id: string;
+    title: string;
+    columns: ExportColumn[];
+    rows: ExportRow[];
+    /** Rendered in place of the rows when there are none. */
+    emptyText?: string;
+}
+export interface ExportMetaEntry {
+    label: string;
+    value: string;
+}
+/** Which tab was exported. */
+export type AnamnesisExportTab = 'summary' | 'compile' | 'evolution';
+export interface ExportDocument {
+    tab: AnamnesisExportTab;
+    audience: DisclosureAudience;
+    /** Filename without an extension — see `exportFileName`. */
+    fileStem: string;
+    title: string;
+    /** Who the copy names, or `null` when identity is not disclosed to this
+     * audience. Lifted out of `meta` so a writer can stamp every page with it. */
+    patientName: string | null;
+    /** The audience, translated — the "Copy for" value, in one place. */
+    audienceLabel: string;
+    meta: ExportMetaEntry[];
+    tables: ExportTable[];
+    /** Translated notes rendered under the tables. */
+    footnotes: string[];
+    /** Disclosure concept IDS held back from this document. Metadata for the UI
+     * and the tests — writers never print it, because an id is not a value. */
+    withheld: string[];
+    /** App locale, resolved from `t`. Drives the CSV dialect. */
+    locale?: string;
+}
+export interface AnamnesisExportOptions {
+    record: AnamnesisRecord;
+    /** Who the file is for. Filters every table through `disclosedTo`. */
+    audience: DisclosureAudience;
+    t: TFunction;
+    config?: PracticeAnamnesisConfig;
+    /** Generation instant. Defaults to now — pass one to keep a test stable. */
+    generatedAtIso?: string;
+}
+/** `selected` exports the columns the picker is showing; `all` exports every
+ * visit. Defaults to `selected`: exporting thirteen visits from a screen
+ * showing three is a different document from the one that was asked for. */
+export type EvolutionExportScope = 'selected' | 'all';
+export interface EvolutionExportOptions extends AnamnesisExportOptions {
+    /** The picker's current selection. Omitted = the picker's own default
+     * (first visit + latest), never "everything". */
+    selectedVisitIds?: Iterable<string>;
+    scope?: EvolutionExportScope;
+}
+/** A parameter's disclosure concept, from its DISPLAY group — not from
+ * `parameterStorage`, which routes a practice-added anthropometric through the
+ * `labs` array and would classify it as a lab value. */
+export declare function parameterConcept(def: NumericParameterDef): string;
+/** The Summary tab: the patient's own questionnaire, one row per answered
+ * question, grouped by section, with who authored each answer. */
+export declare function buildSummaryExport(options: AnamnesisExportOptions): ExportDocument;
+/** The Compile tab: the visit being recorded, block by block, in the order the
+ * form presents them. Each block is gated on its own disclosure concept. */
+export declare function buildCompileExport(options: AnamnesisExportOptions): ExportDocument;
+/** The Evolution tab: parameters as rows, the SHOWN visits as columns, plus
+ * target, window change and which visits fell out of range. */
+export declare function buildEvolutionExport(options: EvolutionExportOptions): ExportDocument;
+/** One entry point for a tab id — the UI stage switches on the active tab. */
+export declare function buildAnamnesisExport(tab: AnamnesisExportTab, options: EvolutionExportOptions): ExportDocument;
+/** A withheld concept's translated name. The id carries dots and i18next reads
+ * a dot as a level, so the key flattens them — `lab.values` reads
+ * `anamnesis.export.concept.lab_values`. An id with no key falls back to the
+ * id rather than to a blank, so a rule nobody has named still shows up. */
+export declare function conceptLabel(conceptId: string, t: TFunction): string;
+export interface DocumentDisclosure {
+    /** Table titles the document actually carries, in document order. */
+    included: string[];
+    /** Translated names of the concepts held back, alphabetical. */
+    excluded: string[];
+}
+/** What this document gives the audience and what it holds back — the share
+ * dialog's whole content, and the menu's exclusion line. Reads the built
+ * document rather than re-deriving the rules, so the preview cannot disagree
+ * with the file. */
+export declare function documentDisclosure(document: ExportDocument, t: TFunction): DocumentDisclosure;
+export declare const CSV_MIME = "text/csv;charset=utf-8";
+export declare const XLSX_MIME = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+export interface CsvDialect {
+    /** Field separator. `;` wherever the decimal mark is a comma. */
+    delimiter: ',' | ';';
+    decimal: '.' | ',';
+    eol: string;
+    /** Emit a UTF-8 BOM so Excel detects the encoding instead of guessing. */
+    bom: boolean;
+}
+/** The CSV convention Excel expects for a locale. Italian (and every other
+ * decimal-comma locale) gets `;` + `,`; English gets `,` + `.`. A locale whose
+ * decimal mark is neither — Arabic's `٫` — takes the point convention, because
+ * the numbers written here are Latin digits either way. */
+export declare function csvDialectFor(locale?: string): CsvDialect;
+/** One cell, escaped. Exported for the tests that pin the escaping rules. */
+export declare function csvCell(value: ExportValue, dialect: CsvDialect, precision?: number): string;
+/** The document as one CSV. Tables run in order, each behind its own title
+ * row and separated by a blank line — the report shape every spreadsheet
+ * reader already understands. */
+export declare function toCsv(document: ExportDocument, dialect?: CsvDialect): string;
+export declare function toCsvBlob(document: ExportDocument, dialect?: CsvDialect): Blob;
+/** The document as an `.xlsx` — the info block on its own sheet, then one
+ * sheet per table. No colour: the kit's tokens are CSS custom properties that
+ * only resolve against a live DOM, and this module has none. Weight and
+ * freeze-panes carry the hierarchy instead. */
+export declare function toXlsxBlob(document: ExportDocument): Promise<Blob>;
+export type ExportFormat = 'csv' | 'xlsx' | 'pdf';
+/** Deterministic, meaningful, and free of anything a filesystem rejects. */
+export declare function exportFileName(document: ExportDocument, format: ExportFormat): string;
+//# sourceMappingURL=anamnesis-export.d.ts.map

package/dist/patterns/anamnesis/anamnesis-field.d.ts

@@ -0,0 +1,14 @@
+import type { TFunction } from 'i18next';
+import type { AnswerOrigin, IntakeAnswer, IntakeFieldDef } from './anamnesis-types';
+export interface AnamnesisFieldProps {
+    def: IntakeFieldDef;
+    answer?: IntakeAnswer;
+    onChange: (answer: IntakeAnswer) => void;
+    /** Show the "from patient" marker when the value still carries patient origin
+     * (compile mode). Intake mode leaves this off — the patient owns the form. */
+    showOrigin?: boolean;
+    origin?: AnswerOrigin;
+    t: TFunction;
+}
+export declare function AnamnesisField({ def, answer, onChange, showOrigin, origin, t, }: AnamnesisFieldProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=anamnesis-field.d.ts.map

package/dist/patterns/anamnesis/anamnesis-format.d.ts

@@ -0,0 +1,67 @@
+import type { TFunction } from 'i18next';
+import type { AnamnesisRecord, IntakeAnswer, IntakeFieldDef, IntakeSectionDef, NumericParameterDef, PathologyCode, PatientSex, Visit } from './anamnesis-types';
+/** Only show a field when it is relevant to the patient's recorded sex.
+ * Single definition — this previously existed three times (intake, compile,
+ * read-only) and drifting copies are a correctness risk, not just noise. */
+export declare function fieldVisible(def: IntakeFieldDef, sex: PatientSex): boolean;
+/** The locale a `t` is fixed to. Both `useTranslation()` and a locale-pinned
+ * `getFixedT(lng, ns)` set it, so this is the app language on every surface. */
+export declare function localeOf(t: TFunction): string | undefined;
+/** Every stored date rendered outside a JSX `<Timestamp>`. Pins UTC AND the
+ * app locale, so one visit cannot render two ways on one screen. */
+export declare function visitDateLabel(iso: string, t: TFunction): string;
+/** A stored `YYYY-MM-DD` as a LOCAL calendar date. `new Date(iso)` would parse
+ * it as UTC midnight and render the previous day west of Greenwich — the
+ * off-by-one this pattern has already had to fix once. */
+export declare function parseCalendarDate(iso: string): Date | undefined;
+/** A local calendar date back to `YYYY-MM-DD`. `toISOString()` would convert to
+ * UTC first and can land on the wrong day; these are the local components. */
+export declare function toCalendarIso(date: Date): string;
+/** One visit as an option label. The ordinal disambiguates two visits recorded
+ * on the same calendar day, which would otherwise read identically.
+ *
+ * `hasNote` marks a visit whose note is only readable once that visit is a
+ * column — without it the picker gives the reader no reason to pick it, and
+ * the note is unreachable in practice rather than one tick away. */
+export declare function visitOptionLabel(visit: Visit, index: number, t: TFunction, hasNote?: boolean): string;
+/** Age at an EXPLICIT reference instant. An unreadable date of birth or
+ * reference date renders the em dash — the same absence marker every other
+ * unknown uses, and never the "NaN years" the raw subtraction used to print.
+ * Surfaces call `patientAgeLabel`; this stays for a caller that genuinely has
+ * its own reference date. */
+export declare function ageLabel(dateOfBirthIso: string, referenceIso: string, t: TFunction): string;
+/** The patient header's age line, on every surface. Takes the RECORD rather
+ * than a date, so no call site can pick its own reference visit — picking one
+ * per surface is exactly how intake and compile came to print two different
+ * ages for the same patient. A record with no visit has no age to state. */
+export declare function patientAgeLabel(record: AnamnesisRecord, t: TFunction): string;
+/** Numeric parameter label — practice wording, else `anamnesis.param.<key>`. */
+export declare function parameterLabel(def: NumericParameterDef, t: TFunction): string;
+/** Parameter label with its unit appended, as the form fields render it. Unit
+ * symbols (kg, mg/dL) are locale-invariant scientific notation. */
+export declare function parameterLabelWithUnit(def: NumericParameterDef, t: TFunction): string;
+/** Intake field label — practice wording, else `anamnesis.field.<key>.label`. */
+export declare function intakeFieldLabel(def: IntakeFieldDef, t: TFunction): string;
+/** Optional help text under an intake field. Practice help text wins; the kit
+ * key is optional and resolves to `undefined` when unset. */
+export declare function intakeFieldHelp(def: IntakeFieldDef, t: TFunction): string | undefined;
+/** Section heading — practice wording, else `anamnesis.section.<key>`. */
+export declare function sectionLabel(section: IntakeSectionDef, t: TFunction): string;
+/** Pathology description. The code itself is never translated; the entry may
+ * be absent from the taxonomy entirely, in which case the code stands alone.
+ * `pathologyLabelKey` sanitises the dot — i18next reads `.` as a separator, so
+ * `E66.0` must never be concatenated into a key by hand. */
+export declare function pathologyLabel(code: string, t: TFunction, entry?: PathologyCode): string;
+/** `E66.0 — Obesity due to excess calories`, the form the pickers and badges
+ * render. Falls back to the bare code when nothing describes it. */
+export declare function pathologyCodeWithLabel(code: string, t: TFunction, entry?: PathologyCode): string;
+/** Whether an answer carries a real response. Shared by the progress meter,
+ * the digest and the mandatory-answer check, so all three agree. "Not sure"
+ * counts as UNANSWERED — provisional, pending the customer's own rule. Zero is
+ * a value: every numeric branch is `!= null`, never a truthiness test. */
+export declare function isIntakeAnswered(answer: IntakeAnswer | undefined): boolean;
+/** One intake answer as a read-only string. Absent values render an em dash —
+ * never "undefined", never a bare hyphen. Zero is a value: every check here is
+ * `!= null`, never a truthiness test on a number. */
+export declare function formatIntakeAnswer(answer: IntakeAnswer, def: IntakeFieldDef, t: TFunction): string;
+//# sourceMappingURL=anamnesis-format.d.ts.map

package/dist/patterns/anamnesis/anamnesis-i18n.d.ts

@@ -0,0 +1,6 @@
+import type { i18n as I18nInstance } from 'i18next';
+export declare const PATTERN_NS = "patterns";
+/** Register the story-local bundles onto the shared singleton (deep-merge,
+ * never overwrite; never init). Idempotent across HMR reloads. */
+export declare function registerAnamnesisBundles(i18n: I18nInstance): void;
+//# sourceMappingURL=anamnesis-i18n.d.ts.map

package/dist/patterns/anamnesis/anamnesis-indicators.d.ts

@@ -0,0 +1,53 @@
+import type { TFunction } from 'i18next';
+import { type SparklineAnnotation } from '../../components/sparkline';
+import { type DeltaInfo, type RangeFlag } from './anamnesis-derive';
+import type { NumericParameterDef } from './anamnesis-types';
+export interface DeltaIndicatorProps {
+    /** The derived change vs the previous visit; `null` renders nothing (first
+     * visit has no delta — never render a broken arrow). */
+    delta: DeltaInfo | null;
+    def: NumericParameterDef;
+    t: TFunction;
+}
+/** Arrow + signed change vs the previous visit, coloured by whether the change
+ * is an improvement for THIS parameter. */
+export declare function DeltaIndicator({ delta, def, t }: DeltaIndicatorProps): import("react/jsx-runtime").JSX.Element | null;
+export interface OriginMarkerProps {
+    t: TFunction;
+}
+/** "From patient" badge shown against a value the patient submitted and the
+ * clinician has not yet confirmed or edited. Uses the info family (calm,
+ * informational — distinct from the clinical status colours). */
+export declare function OriginMarker({ t }: OriginMarkerProps): import("react/jsx-runtime").JSX.Element;
+export interface OutOfRangeBadgeProps {
+    flag: RangeFlag;
+    t: TFunction;
+    /** Icon-only chip for dense grid cells; otherwise shows a short label. */
+    compact?: boolean;
+}
+/** H/L flag for a lab value outside its reference range. Warning tone +
+ * direction glyph + colour-blind dot; the accessible name says above/below. */
+export declare function OutOfRangeBadge({ flag, t, compact, }: OutOfRangeBadgeProps): import("react/jsx-runtime").JSX.Element | null;
+export interface TrendSparklineProps {
+    /** ONE ENTRY PER RECORD VISIT, in visit order. `null` is a visit where this
+     * parameter was not measured, and it HOLDS its place on the x extent —
+     * that is what keeps a lab drawn four times over a thirteen-visit history
+     * on the same x scale as a weight drawn thirteen times, so an event
+     * annotation lands on the same date in both. */
+    series: (number | null)[];
+    def: NumericParameterDef;
+    t: TFunction;
+    /** Event reference lines. The SAME array is handed to every row, so one
+     * event is one vertical line down the whole grid. */
+    annotations?: readonly SparklineAnnotation[];
+    /** Make those lines pointer-selectable. Supplied ⇒ pressing one does what
+     * pressing its chip in the bar above does. The chip bar is the keyboard
+     * route and stays the only one — the lines live inside a `role="img"`. */
+    onSelectAnnotation?: (eventId: string) => void;
+}
+/** Compact inline trend across all visits, tinted by the overall valence
+ * (first → last measurement) for the parameter. Reduced motion is honoured by
+ * Sparkline internally. Renders nothing below two measurements (no trend to
+ * draw) — the gaps do not count towards that. */
+export declare function TrendSparkline({ series, def, t, annotations, onSelectAnnotation, }: TrendSparklineProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=anamnesis-indicators.d.ts.map

package/dist/patterns/anamnesis/anamnesis-intake.d.ts

@@ -0,0 +1,16 @@
+import type { TFunction } from 'i18next';
+import { type PracticeAnamnesisConfig } from './anamnesis-config';
+import type { AnamnesisRecord } from './anamnesis-types';
+export interface AnamnesisIntakeProps {
+    record: AnamnesisRecord;
+    t: TFunction;
+    /** Mount flush inside a host section tab (drops the full-page chrome + own
+     * page title). */
+    embedded?: boolean;
+    /** The practice's configured questionnaire. Omitted = the kit-seeded form. */
+    config?: PracticeAnamnesisConfig;
+    /** Demo/story hook: which section is open on mount. Defaults to the first. */
+    defaultOpenSection?: string;
+}
+export declare function AnamnesisIntake({ record, t, embedded, config, defaultOpenSection, }: AnamnesisIntakeProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=anamnesis-intake.d.ts.map

package/dist/patterns/anamnesis/anamnesis-matrix.d.ts

@@ -0,0 +1,91 @@
+import type { ReactNode } from 'react';
+import type { TFunction } from 'i18next';
+import type { OpenAnamnesisNote } from './anamnesis-types';
+import type { VisitColumn } from './anamnesis-window';
+/** Static class literals — Tailwind has to see every arbitrary value at build
+ * time, and a class built by interpolation emits no CSS at all. */
+/** Floored at the longest parameter label + its unit and reference range on
+ * ONE line — measured across en / ar / ja under `.theme-accessible`, whose
+ * larger type is the widest case (ja "HDLコレステロール", 147px + 16px of cell
+ * padding). Below that the label wraps and the cell goes to three lines. */
+export declare const MATRIX_IDENTITY_CLASS = "ds:min-w-[11rem]";
+/** Floored by the editable cell, not by the number it shows: `NumberInput`
+ * spends 56px on its two spinners and 16px on input padding before a digit is
+ * drawn, so 128px of column is 40px of readable value. It cannot go lower. */
+export declare const MATRIX_VISIT_COLUMN_CLASS = "ds:min-w-[8rem]";
+/**
+ * A PERCENTAGE, not a rem cap — that is what redirects the spare pixels.
+ *
+ * Under `table-layout: auto` the spare width of a table narrower than its
+ * container goes to whichever columns declare no width, and `max-width` on a
+ * table cell is only honoured while some other column is left to absorb. The
+ * old `w-[9rem] max-w-[10rem]` therefore pinned the trend at 160px and handed
+ * everything else to the identity and value columns — 325px and 443px of
+ * mostly whitespace at 1440px wide. Claiming a share instead inverts that.
+ * When the table DOES overflow, the percentage stops applying and the
+ * min-width is what the trend gets.
+ */
+export declare const MATRIX_TREND_COLUMN_CLASS = "ds:w-[40%] ds:min-w-[14rem]";
+/** Apply to every `<td>` a surface hands to `trailing`, so the column sticks
+ * as one piece rather than only in its header. */
+export declare const MATRIX_TRAILING_CELL_CLASS = "ds:sticky ds:end-0 ds:z-[1] ds:bg-[color:var(--card)] ds:shadow-[var(--shadow-chrome-start)]";
+/** Every body cell in a value column. Exported so both surfaces open from the
+ * same padding / alignment rather than each picking its own. */
+export declare const MATRIX_CELL_CLASS = "ds:px-[var(--spacing-sm)] ds:py-[var(--spacing-xs)] ds:align-top";
+export interface MatrixVisitHeaderProps {
+    column: VisitColumn;
+    t: TFunction;
+    /** Muted fill — the column is one of the compared pair/set. */
+    emphasised?: boolean;
+    /** Adds the "Editable" chip; compile mode's newest column only. */
+    editable?: boolean;
+    /** Render this visit's note popover already open (demo hook). */
+    defaultOpenNoteVisitId?: string;
+    /** Offer the note affordance. The compare panel sets this `false`: its
+     * columns repeat the grid's, and two note triggers with the same accessible
+     * name on one screen is a control the reader has to disambiguate. */
+    withNote?: boolean;
+    /** Route the note to the host's side panel instead of opening it in place. */
+    onOpenNote?: OpenAnamnesisNote;
+}
+/** One visit's `<th scope="col">`, identical wherever the visit is a column. */
+export declare function MatrixVisitHeader({ column, t, emphasised, editable, defaultOpenNoteVisitId, withNote, onOpenNote, }: MatrixVisitHeaderProps): import("react/jsx-runtime").JSX.Element;
+export interface MatrixRowSpec {
+    key: string;
+    /** Full-width group banner. When set, every other field is ignored. */
+    banner?: string;
+    /** The row's `<th scope="row">` element. */
+    header?: ReactNode;
+    /** One `<td>` per visit column, in column order. */
+    cells?: readonly ReactNode[];
+    /** The `<td>` under the trend column. */
+    trend?: ReactNode;
+    /** The `<td>` under the trailing column, where the table declares one. */
+    trailing?: ReactNode;
+}
+export interface AnamnesisMatrixProps {
+    captionId: string;
+    /** Screen-reader caption naming what the table holds. */
+    caption: string;
+    /** Header of the sticky identity column. */
+    identityLabel: string;
+    /** Header of the trend column. */
+    trendLabel: string;
+    /** Test hook on the trend header. Only one matrix on screen may claim it,
+     * so the grid takes it and the compare panel below goes without. */
+    trendTestId?: string;
+    /** One `<th scope="col">` per visit column — build them with
+     * `MatrixVisitHeader` so the two surfaces cannot disagree. */
+    visitHeaders: readonly ReactNode[];
+    /** Header of a column rendered after every visit. Omitted = no such column. */
+    trailingLabel?: string;
+    /** Test hook on the trailing header — the surface names it, not the shell. */
+    trailingTestId?: string;
+    rows: readonly MatrixRowSpec[];
+    /** Draw the outer border + surface. `false` inside a card, to avoid a
+     * box-in-a-box. */
+    framed?: boolean;
+    testId?: string;
+}
+export declare function AnamnesisMatrix({ captionId, caption, identityLabel, trendLabel, trendTestId, visitHeaders, trailingLabel, trailingTestId, rows, framed, testId, }: AnamnesisMatrixProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=anamnesis-matrix.d.ts.map

package/dist/patterns/anamnesis/anamnesis-notes.d.ts

@@ -0,0 +1,19 @@
+import type { TFunction } from 'i18next';
+import type { NotesPanelNote } from '../../components/notes-panel';
+import type { AnamnesisNoteTarget, AnamnesisRecord } from './anamnesis-types';
+/**
+ * The note id a target addresses. The host hands this to `NotesPanel`'s
+ * `currentNoteId`; the panel marks, scrolls to and focuses that note. Namespaced
+ * so anamnesis notes can share a timeline with the host's own without a
+ * collision.
+ */
+export declare function anamnesisNoteId(target: AnamnesisNoteTarget): string;
+/**
+ * The record's notes and events as one timeline, newest first — the order
+ * `NotesPanel` documents for `notes` (it re-sorts only to lead with pinned).
+ *
+ * A host with notes of its own concatenates and re-sorts by `dateIso`: this is
+ * a contribution to the patient's timeline, not a replacement for it.
+ */
+export declare function anamnesisNotes(record: AnamnesisRecord, t: TFunction): NotesPanelNote[];
+//# sourceMappingURL=anamnesis-notes.d.ts.map