@evaro/consultation-sdk 0.0.0-stage → 0.2.0-next.0

package/dist/types/Consultation.d.ts

@@ -0,0 +1,39 @@
+import { type VendorTheme } from './api';
+import type { ConsultationEvent, ConsultationType, Environment, GetToken, SavedAnswers, Target } from './types';
+export interface ConsultationProps {
+    /** The hash of the consultation to show. */
+    consultation: string;
+    /** The vendor hash. It selects the theme and goes to the API, as in Connect. */
+    vendor: string;
+    environment: Environment;
+    /** Where the answers are saved. With no target the package runs as a preview and saves nothing. */
+    target?: Target;
+    /** Returns the signed-in user's token for the target's calls. */
+    getToken?: GetToken;
+    /** Sends the target's calls to this NodeAPI URL in place of the environment's host, for example a local stub server. */
+    nodeApiUrl?: string;
+    /** Shows the target's saved answers. They cannot be changed or submitted. */
+    readOnly?: boolean;
+    /** Loads the unpublished version of the consultation. */
+    preview?: boolean;
+    /** `steps` shows one question per screen. `form` shows every question on one page, grouped by section. */
+    layout?: ConsultationLayout;
+    /** The label of the form layout's submit button. Defaults to "Submit". */
+    submitLabel?: string;
+    /** Reported as `consultation_type` on the events. Defaults to the consultation's own type. */
+    consultationType?: ConsultationType;
+    /** Called when the flow ends: after submit, or when the user closes the knockout screen. */
+    onDone?: () => void;
+    /** Receives the analytics signals, with the names and fields Connect uses. */
+    onEvent?: (event: ConsultationEvent) => void;
+}
+export type ConsultationLayout = 'steps' | 'form';
+export { DRAFT_DELAY_MS } from './useTargetSave';
+export type Loaded = {
+    key: string;
+    attempt: number;
+    consultation: iConsultation;
+    theme: VendorTheme | null;
+    saved: SavedAnswers;
+};
+export declare function Consultation(props: ConsultationProps): import("react").JSX.Element;

package/dist/types/api.d.ts

@@ -0,0 +1,20 @@
+import type { Environment } from './types';
+export declare const apiHost: (environment: Environment) => string;
+export declare const nodeApiHost: (environment: Environment) => string;
+/** The NodeAPI base for target calls: `nodeApiUrl` when the host sets one, otherwise the environment's host. */
+export declare function nodeApiBase(environment: Environment, nodeApiUrl?: string): string;
+export declare class RequestError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+/** The server refused a write because the answers changed in another place. */
+export declare const isConflict: (error: unknown) => boolean;
+export declare const REQUEST_TIMEOUT_MS = 30000;
+export declare function requestJson<T>(url: string, init?: RequestInit): Promise<T>;
+export interface VendorTheme {
+    colours?: Partial<Record<'100' | '300' | '500' | '700' | '900', string>>;
+}
+/** The consultation as Connect loads it. `preview` reads the unpublished version, which needs no token. */
+export declare function fetchVendorConsultation(environment: Environment, hash: string, vendor: string, preview: boolean): Promise<iConsultation>;
+/** The vendor's colours, loaded once for each vendor. A missing theme leaves Connect's default palette. */
+export declare function fetchVendorTheme(environment: Environment, vendor: string): Promise<VendorTheme | null>;

package/dist/types/draftQueue.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Runs one target's drafts and submits one after another, so an older write never lands after a newer one, and
+ * a reload can wait for the writes that are still open.
+ */
+export declare class DraftQueue {
+    private readonly onIdle;
+    private tail;
+    private open;
+    constructor(onIdle?: () => void);
+    /** Runs the task after the open ones. A failed task does not stop the queue. */
+    run<T>(task: () => Promise<T>): Promise<T>;
+    /** Settles when every task queued so far has settled. */
+    idle(): Promise<unknown>;
+}
+/** Runs a write on the target's queue. Only a write creates a queue, and the queue goes once it is idle. */
+export declare function runOnDraftQueue<T>(key: string, task: () => Promise<T>): Promise<T>;
+/** Settles when the target's open writes have settled. A target with no open writes settles at once. */
+export declare function draftQueueIdle(key: string): Promise<unknown>;
+/** How many targets have open writes. For tests. */
+export declare const openDraftQueues: () => number;
+/** Forgets every queue, so one test's open writes cannot hold up the next test. For tests. */
+export declare const resetDraftQueues: () => void;

package/dist/types/events.d.ts

@@ -0,0 +1,15 @@
+import type { ConsultationEvent, ConsultationType } from './types';
+export interface EventContext {
+    consultationHash: string;
+    experimentOf: string | undefined;
+    consultationType: ConsultationType;
+}
+/** Builds the signals with the same names and fields as Connect's `utils/analytics.ts`. */
+export declare const consultationEvents: (context: EventContext) => {
+    started: () => ConsultationEvent;
+    completed: () => ConsultationEvent;
+    exited: () => ConsultationEvent;
+    viewed: (number: number, all: number) => ConsultationEvent;
+    questionViewed: (hash: string, skipped?: boolean) => ConsultationEvent;
+    questionAnswered: (hash: string, skipped?: boolean) => ConsultationEvent;
+};

package/dist/types/flow/answer.d.ts

@@ -0,0 +1,46 @@
+export type AnswerValue = string | string[];
+export type AnswerMap = Record<string, AnswerValue>;
+type OptionLogic = iQuestion['options'][number]['logic'];
+/** Types that wait for Continue: free text, multi-select and types with their own input. */
+export declare const NON_AUTO_PROGRESS_TYPES: string[];
+export interface AnswerState {
+    answers: AnswerMap;
+    optionHashes: AnswerMap;
+}
+export type Navigation = {
+    kind: 'none';
+} | {
+    kind: 'next';
+} | {
+    kind: 'goto';
+    hash: string;
+};
+export interface AnswerResult extends AnswerState {
+    /** The jump to hold until Continue. `undefined` leaves the current one. */
+    nextOverride: string | null | undefined;
+    navigation: Navigation;
+}
+interface AnswerInput {
+    question: iQuestion;
+    state: AnswerState;
+    value: AnswerValue;
+    logic?: OptionLogic;
+    /** False for a follow-up that is not the last of its group, or while one above it is blank. */
+    ownsProgression: boolean;
+}
+/**
+ * Where a checkbox answer jumps: the first ticked option that has a go-to. The shared next-question rule takes
+ * the first ticked option and then reads its go-to, which misses a jump on a later option.
+ */
+export declare function checkboxJump(question: iQuestion | undefined, answer: AnswerValue | null | undefined, optionHash?: AnswerValue | null): string | null;
+/**
+ * The jump the live flow holds for Continue on a question: one set in an open follow-up, then a checkbox jump
+ * on the main question. A main radio's own go-to is left to the shared next-question rule.
+ *
+ * The live flow keeps the jump of the last click, and click order is not saved, so a later follow-up in the
+ * group wins here. The two differ only when two open follow-ups both hold a jump, or one clears another's.
+ */
+export declare function heldJump(question: iQuestion, allQuestions: iQuestion[], answers: AnswerMap, optionHashes?: AnswerMap): string | null;
+/** Applies one answer. Returns null when the click changes nothing, such as the same radio option again. */
+export declare function applyAnswer({ question, state, value, logic, ownsProgression }: AnswerInput): AnswerResult | null;
+export {};

package/dist/types/flow/form.d.ts

@@ -0,0 +1,67 @@
+/** Rules of the one-page form layout: which questions show, how they group, and what a submit checks and sends. */
+import type { AnswerMap } from './answer';
+import { type Walk } from './path';
+type Section = NonNullable<iConsultation['sections']>[number];
+export interface FormTable {
+    /** Headings, the first one for the row labels. */
+    columns: string[];
+    /** One list of question hashes for each row, in column order. The first question's title is the row label. */
+    rows: string[][];
+}
+export interface FormSection {
+    id: string;
+    name: string;
+    description: string;
+    /** Set when the section draws as a table; otherwise its questions show as a list. */
+    table: FormTable | null;
+    /** The section's main questions, in flow order. */
+    questions: string[];
+}
+/** What the page shows, in flow order. */
+export type FormBlock = {
+    kind: 'questions';
+    questions: string[];
+} | {
+    kind: 'section';
+    section: FormSection;
+} | {
+    kind: 'tabs';
+    name: string;
+    sections: FormSection[];
+};
+export interface FormExit {
+    questionHash: string;
+    title: string | null;
+    content: string | null;
+}
+export interface Form {
+    /** The main questions on the page, in flow order. */
+    path: string[];
+    /** Every question on the page: the main ones and their open follow-ups, in the order the page draws them. */
+    shown: string[];
+    blocks: FormBlock[];
+    /** Questions that may stay empty: a table section's questions that are not Yes / No, and one-tick checkboxes. */
+    optional: Set<string>;
+    /** An answer with an exit. The questions after it are hidden. */
+    exit: FormExit | null;
+}
+/** A radio question whose only options are Yes and No. The form draws it as a Yes / No pair. */
+export declare function isYesNo(question: iQuestion | undefined): boolean;
+/**
+ * A table section reads its main questions row by row, in consultation order: one question for each heading
+ * after the first. A row a jump or an exit hides as a whole is left out. When the questions do not fill whole
+ * rows, or an answer hides part of a row, the section shows as a list, so a cell can never move under the wrong
+ * row label.
+ */
+export declare function sectionTable(section: Section, questions: string[], shown: Set<string>): FormTable | null;
+/**
+ * What the page shows: the flow from the first question. A section's questions show together, where its first
+ * question comes in the flow, and questions with no section show where they come. Sections next to each other
+ * with the same group show as tabs. Follow-ups show under their parent, so only main questions are grouped.
+ */
+export declare function buildForm(walk: Walk, consultation: Pick<iConsultation, 'hash' | 'sections'>): Form;
+/** Questions on the page that still need an answer, in page order. Optional questions are never missing. */
+export declare function missingAnswers(form: Form, walk: Walk): string[];
+/** The answers on the page: what a draft saves and a submit sends. Answers of a branch a jump leaves are dropped. */
+export declare function formAnswers(form: Form, walk: Walk): AnswerMap;
+export {};

package/dist/types/flow/path.d.ts

@@ -0,0 +1,34 @@
+import { type AnswerMap } from './answer';
+/** A question and its open follow-ups, walking nested ones. */
+export declare function withFollowUps(hash: string, allQuestions: iQuestion[], answers: AnswerMap, optionHashes: AnswerMap, into: Set<string>): void;
+/**
+ * Only the answers on the path the user took. Going Back and choosing another option leaves the answers of the
+ * old branch in state; they must not be saved as if they were given on this path.
+ */
+export declare function answersOnPath(history: string[], allQuestions: iQuestion[], answers: AnswerMap, optionHashes: AnswerMap): AnswerMap;
+/** The consultation and the answers that a walk through the flow follows. */
+export interface Walk {
+    allQuestions: iQuestion[];
+    visibleQuestions: iQuestion[];
+    consultationHash: string;
+    answers: AnswerMap;
+    optionHashes: AnswerMap;
+}
+/**
+ * Where a saved draft opens: walks the flow from the first question while each one holds a complete answer.
+ * Returns the questions passed on the way, with the one to show last.
+ */
+export declare function resumeHistory(walk: Walk): string[];
+/**
+ * The one-page form's main questions: the flow from the first question, where only an answer takes a jump, so an
+ * unanswered question goes on to its default next one. It stops at an answer with an exit.
+ */
+export declare function formPath(walk: Walk): string[];
+/**
+ * The answers a draft keeps: the path behind the user, and ahead of them the questions the current answers
+ * still lead to. After Back, answers further on survive while the user edits, even when an edit leaves the
+ * current question unfinished. Answers of a branch the user left are dropped.
+ */
+export declare function draftAnswers(history: string[], walk: Walk): AnswerMap;
+/** Whether every question on the path has a complete answer, so the answers can be submitted. */
+export declare function isPathComplete(history: string[], allQuestions: iQuestion[], answers: AnswerMap, optionHashes: AnswerMap): boolean;

package/dist/types/flow/questionnaire.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Pure logic functions for the questionnaire consultation flow.
+ * Used by QuestionnaireManager and Question so the behaviour lives in one place.
+ */
+/**
+ * Returns only the questions that should be visible to the patient:
+ * - excludes follow-up questions (shown inline)
+ * - excludes questions whose hash is in the hidden-answers map
+ * - excludes questions that don't apply to the patient's age or gender
+ */
+export declare function filterVisibleQuestions(questions: iQuestion[], hiddenAnswers: Record<string, unknown>, demographics?: PatientDemographics | null): iQuestion[];
+/** Age and gender known before the consultation starts, when the patient is picked or described up front. */
+export interface PatientDemographics {
+    age: number | null;
+    gender: 'male' | 'female' | null;
+}
+/**
+ * Whether a question doesn't apply to the patient. Questions carry no age or gender conditions yet, so
+ * nothing is hidden; the rules go here once the API sends them.
+ */
+export declare function isHiddenForPatient(_question: iQuestion, _demographics: PatientDemographics | null): boolean;
+/**
+ * Clears every jump naming a question the list no longer holds, so the flow falls through in order rather
+ * than opening one that cannot render. Follow-ups too: a pending one that renders nothing holds Continue shut.
+ */
+export declare function withReachableJumps(questions: iQuestion[]): iQuestion[];
+/**
+ * A `dosage` question is an unanswerable template until the API expands it under the same hash, as a radio.
+ * One that never expanded is dropped — nothing renders the type — and jumps aimed at it are cleared with it.
+ */
+export declare function withExpandedDosage(questions: iQuestion[], expanded?: iQuestion | null): iQuestion[];
+/**
+ * Whether the flow can open this question — for the `q` in the URL, the one hash nothing upstream vets.
+ * Plain membership, so hand it the visible set: a follow-up is asked inline and a carried answer is hidden,
+ * and neither has a screen of its own.
+ */
+export declare function isRenderableQuestion(hash: string | null | undefined, questions: iQuestion[]): hash is string;
+/**
+ * The BMI range a reading falls in. Ranges may share a bound (24-27 then 27-28), and the later one
+ * takes the shared value, so the patient's feedback and their routing agree on which range applies.
+ */
+export declare function findBmiRange(options: iQuestion['options'] | undefined, bmi: number): iQuestion['options'][number] | undefined;
+/** The BMI a stored answer carries (`height=…cm weight=…kg bmi=…`), or null when it has none. */
+export declare function bmiFromAnswer(answer: string | string[] | null | undefined): number | null;
+/**
+ * Determines which question to navigate to next. Throws when questionIndex is negative.
+ * Priority order:
+ *   1. nextQuestionHashOverride (set by inline follow-up logic)
+ *   2. the go-to on the answered option, or on the range a BMI answer falls in
+ *   3. consultation-level logic.next on the current question
+ *   4. the standard next question in sequence
+ *
+ * The final branch reads `.hash` off the next question directly (no optional
+ * chaining) so an out-of-bounds index throws here, at the source, rather than
+ * silently returning undefined and crashing a component further down.
+ */
+export declare function resolveNextQuestionHash(questions: iQuestion[], questionIndex: number, nextQuestionHashOverride: string | null, currentQuestion: iQuestion | undefined, consultationHash: string, answer?: string | string[] | null): string;
+/**
+ * Where a navigation target lands once hidden questions are taken into account:
+ * the target itself when visible, else the first visible question after both the
+ * target and the current question in consultation order, else null. A follow-up
+ * or unknown target continues after the current question.
+ */
+export declare function resolveVisibleTarget(allQuestions: iQuestion[], visibleQuestions: iQuestion[], targetHash: string, currentHash?: string | null): string | null;
+type Option = iQuestion['options'][0];
+type OptionLogic = Option['logic'];
+/**
+ * Whether an option is the current answer — matched by option hash (primary)
+ * or by label (backward-compatibility fallback).
+ */
+export declare function isOptionSelected(option: Option, answer: string | string[] | null | undefined, answerOptionHash: string | string[] | null | undefined): boolean;
+/**
+ * Returns the logic entries for whichever options match the current answer.
+ * Handles both single-value (radio) and multi-value (checkbox) answers.
+ */
+export declare function getMatchedOptionLogics(answer: string | string[] | null | undefined, answerOptionHash: string | string[] | null | undefined, options: iQuestion['options']): OptionLogic[];
+/**
+ * Collects all inline follow-up question hashes from the active logics,
+ * de-duplicating so each follow-up appears once.
+ */
+export declare function getFollowUpHashes(logics: OptionLogic[]): string[];
+/** Whether an option logic carries an exit condition. */
+export declare function hasExitLogic(logic: OptionLogic | undefined): boolean;
+export declare const FREE_TEXT_TYPES: string[];
+/** Free text needs enough to be worth reading, so a stray character does not unlock Continue. */
+export declare function isFreeTextTooShort(type: string, answer: string | string[] | null | undefined): boolean;
+type AnswerMap = Record<string, string | string[]>;
+/** Whether every follow-up in the group is answered, walking nested ones. `seen` guards a chain that loops back. */
+export declare function areFollowUpsAnswered(followUpHashes: string[], questions: iQuestion[], answers: AnswerMap, optionHashes: AnswerMap, seen?: Set<string>): boolean;
+/**
+ * Every top-level question, plus the follow-ups the selected options open, walking nested ones.
+ * Jumps (`logic.next`) are not followed, so a top-level question the run skipped still counts as reached.
+ */
+export declare function reachableQuestionHashes(questions: iQuestion[], answers: AnswerMap, optionHashes: AnswerMap): Set<string>;
+/**
+ * Decides whether the Continue button should be rendered:
+ *   - there is an answer
+ *   - no exit condition is triggered
+ *   - no inline follow-up questions are pending
+ *   - the question type doesn't auto-navigate (radio) or has its own submit (uploader)
+ *   - date fields must be fully filled (length === 10 for DD-MM-YYYY)
+ *   - the answer passes validation
+ */
+export declare function shouldShowButton(type: string, answer: string | string[] | null | undefined, exitQuestion: OptionLogic | undefined, followUpHashes: string[], hasValidationError: boolean | null | undefined): boolean;
+/**
+ * Computes the new checkbox answer when a value is toggled.
+ * - If the value is already in the array it is removed.
+ * - If it is not, it is appended.
+ * - Returns null when the resulting array is empty (clears the answer).
+ */
+export declare function applyCheckboxToggle(currentAnswer: string | string[] | null | undefined, value: string): string[] | null;
+/**
+ * The microcopy shown above the answer options, telling the patient how the answer
+ * behaves. Set by the answer type rather than authored per question, so every
+ * consultation reads the same way. Types not listed have no hint.
+ */
+export declare function inputHintFor(type: string): string | null;
+/**
+ * CMS HTML with its non-breaking spaces made ordinary. Copy pasted into the editor can arrive
+ * with every space non-breaking, which leaves a line nowhere to wrap but mid-word.
+ */
+export declare function withBreakableSpaces(html: string | null | undefined): string;
+/**
+ * The flags an answer raises, derived from the answer itself: those on the options the
+ * patient has picked, plus the `flags_unselected` of the options they left alone. A
+ * clinical flag sometimes turns on an absent answer, and an option can only flag itself
+ * when chosen. Deriving both sides from the selection means the stored flags always match
+ * the stored answer, rather than only the option that was clicked last.
+ */
+export declare function collectFlags(selectedLabels: string[], options: iQuestion['options'] | undefined): string[] | null;
+/** Where "Review answer" returns to. Same-origin paths only, since the value arrives in the URL; null leaves the caller on its own path. */
+export declare function resolveExitReturnUrl(returnTo: string | undefined | null, mainQuestionHash: string | undefined | null): string | null;
+export {};

package/dist/types/flow/useConsultationFlow.d.ts

@@ -0,0 +1,36 @@
+import type { ConsultationEvent, ConsultationType } from '../types';
+import { type AnswerMap, type AnswerValue } from './answer';
+type OptionLogic = iQuestion['options'][number]['logic'];
+export interface ExitState {
+    questionHash: string;
+    title: string | null;
+    content: string | null;
+}
+export type Phase = 'question' | 'exit' | 'complete';
+interface Options {
+    consultation: iConsultation;
+    consultationType: ConsultationType;
+    initialAnswers: AnswerMap;
+    /** False when a saved draft is reopened, so the start is not counted twice. */
+    isNewStart: boolean;
+    emit: (event: ConsultationEvent) => void;
+}
+export declare function useConsultationFlow({ consultation, consultationType, initialAnswers, isNewStart, emit }: Options): {
+    allQuestions: iQuestion[];
+    questions: iQuestion[];
+    current: string;
+    questionIndex: number;
+    history: string[];
+    answers: AnswerMap;
+    optionHashes: AnswerMap;
+    phase: Phase;
+    exit: ExitState;
+    revision: number;
+    canGoBack: boolean;
+    answer: (question: iQuestion, value: AnswerValue, logic: OptionLogic | undefined, ownsProgression: boolean) => void;
+    nextQuestion: () => void;
+    back: () => void;
+    reviewExitAnswer: () => void;
+    restart: () => void;
+};
+export {};

package/dist/types/flow/validations.d.ts

@@ -0,0 +1,6 @@
+export declare const questionValidations: Record<string, {
+    validate: (value: string) => boolean;
+    errorMessage: string;
+    placeholder: string;
+    label: string;
+}>;

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export { Consultation, type ConsultationLayout, type ConsultationProps } from './Consultation';
+export type { Answer, Answers, ConsultationEvent, ConsultationEventName, ConsultationType, Environment, GetToken, SavedAnswers, Target, TargetAdapter } from './types';

package/dist/types/sanitize.d.ts

@@ -0,0 +1,2 @@
+/** Question and option text is HTML written in CB, so it is cleaned before it renders. Never use it for answers. */
+export declare const sanitize: (html: string | null | undefined) => string;

package/dist/types/targets/diagnosisRequest.d.ts

@@ -0,0 +1,3 @@
+import type { Environment, GetToken, TargetAdapter } from '../types';
+/** Assessment answers stored on a diagnosis request, through NodeAPI with the Prescriber App user's token. */
+export declare function diagnosisRequestTarget(environment: Environment, id: string, getToken: GetToken, nodeApiUrl?: string): TargetAdapter;

package/dist/types/targets/index.d.ts

@@ -0,0 +1,3 @@
+import type { Environment, GetToken, Target, TargetAdapter } from '../types';
+/** One adapter for each target type. To save answers in a new place, add a type here, not code in the host. */
+export declare function createTargetAdapter(target: Target, environment: Environment, getToken: GetToken, nodeApiUrl?: string): TargetAdapter;

package/dist/types/types.d.ts

@@ -0,0 +1,71 @@
+export type Environment = 'development' | 'staging' | 'production';
+/** An answer in Connect's format: option labels for choice types, text for the rest, `DD-MM-YYYY` for a date. */
+export type Answer = string | string[];
+export type Answers = Record<string, Answer>;
+/** Where the answers are saved. With no target the package runs as a preview and saves nothing. */
+export type Target = {
+    type: 'diagnosis-request';
+    id: string;
+};
+export type GetToken = () => Promise<string | null> | string | null;
+export type ConsultationType = 'treatment' | 'renew' | 'reorder' | 'review' | 'care' | (string & {});
+/** Saved answers as a target returns them. */
+export interface SavedAnswers {
+    answers: Answers;
+    status: 'empty' | 'draft' | 'submitted';
+    /** The consultation version the answers were given against, when the target knows it. */
+    consultationVersion: string | null;
+    submittedAt: string | null;
+    /** The server's version of the saved answers. A draft must start from it, or the server refuses the draft. */
+    version: number | null;
+}
+/** The calls the package makes for one target type. The adapter is the only code that knows the endpoints. */
+export interface TargetAdapter {
+    /** The version of the last load or saved draft. Each draft sends it. */
+    readonly version: number | null;
+    load: () => Promise<SavedAnswers>;
+    saveDraft: (answers: Answers) => Promise<void>;
+    submit: (answers: Answers) => Promise<void>;
+}
+interface ConsultationFields {
+    questionnaire_hash: string;
+    experiment_of: string | undefined;
+    consultation_type: ConsultationType;
+}
+interface QuestionFields {
+    question_hash: string;
+    consultation_hash: string;
+    is_skipped: boolean;
+    experiment_of: string | undefined;
+    consultation_type: ConsultationType;
+}
+/**
+ * An analytics signal. The names and fields are the ones Connect sends, so a host can forward them as they are.
+ * The package does not send them anywhere itself.
+ */
+export type ConsultationEvent = {
+    name: 'consultation_started';
+    data: ConsultationFields;
+} | {
+    name: 'consultation_viewed';
+    data: {
+        question_number: string;
+        question_number_of_total: string;
+    };
+} | {
+    name: 'question_viewed';
+    data: QuestionFields;
+} | {
+    name: 'question_answered';
+    data: QuestionFields;
+} | {
+    name: 'consultation_completed';
+    data: ConsultationFields;
+} | {
+    name: 'consultation_exited';
+    data: {
+        questionnaire_hash: string;
+    };
+};
+export type ConsultationEventName = ConsultationEvent['name'];
+export {};

package/dist/types/ui/ErrorNotice.d.ts

@@ -0,0 +1,4 @@
+export declare const ErrorNotice: ({ message, onRetry }: {
+    message: string;
+    onRetry: () => void;
+}) => import("react").JSX.Element;

package/dist/types/ui/FormFlow.d.ts

@@ -0,0 +1,9 @@
+import type { ConsultationProps, Loaded } from '../Consultation';
+import type { TargetAdapter } from '../types';
+export declare const FormFlow: ({ loaded, adapter, consultationType, submitLabel, onDone, onEvent, queueKey, onConflict, onSaved }: ConsultationProps & {
+    loaded: Loaded;
+    adapter: TargetAdapter | null;
+    queueKey: string;
+    onConflict: () => void;
+    onSaved: () => void;
+}) => import("react").JSX.Element;

package/dist/types/ui/Knockout.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    title: string | null;
+    content: string | null;
+    onReview: () => void;
+    onClose?: () => void;
+}
+export declare const Knockout: ({ title, content, onReview, onClose }: Props) => import("react").JSX.Element;
+export {};

package/dist/types/ui/Question.d.ts

@@ -0,0 +1,21 @@
+import type { AnswerMap, AnswerValue } from '../flow/answer';
+type OptionLogic = iQuestion['options'][number]['logic'];
+/** The types this version can fill in. The rest show a notice. */
+export declare const FILL_TYPES: string[];
+interface Props {
+    hash: string;
+    consultationHash: string;
+    questions: iQuestion[];
+    answers: AnswerMap;
+    optionHashes: AnswerMap;
+    onAnswer: (question: iQuestion, value: AnswerValue, logic: OptionLogic | undefined, ownsProgression: boolean) => void;
+    onContinue: () => void;
+    isMainQuestion?: boolean;
+    isLastFollowUp?: boolean;
+    precedingFollowUpsAnswered?: boolean;
+    disabled?: boolean;
+    /** In a preview a type this version cannot fill in can be skipped, so the rest of the flow stays reachable. */
+    allowSkipUnsupported?: boolean;
+}
+export declare const Question: ({ hash, consultationHash, questions, answers, optionHashes, onAnswer, onContinue, isMainQuestion, isLastFollowUp, precedingFollowUpsAnswered, disabled, allowSkipUnsupported }: Props) => import("react").JSX.Element;
+export {};

package/dist/types/ui/ReadOnlyAnswers.d.ts

@@ -0,0 +1,9 @@
+/** Saved answers, one question after another. Every type shows its answer, including the ones that cannot be filled in here. */
+import type { AnswerMap } from '../flow/answer';
+interface Props {
+    questions: iQuestion[];
+    answers: AnswerMap;
+    submittedAt: string | null;
+}
+export declare const ReadOnlyAnswers: ({ questions, answers, submittedAt }: Props) => import("react").JSX.Element;
+export {};

package/dist/types/ui/ShadowRoot.d.ts

@@ -0,0 +1,6 @@
+import { type CSSProperties, type ReactNode } from 'react';
+/** Renders the children in a shadow root with the package CSS, so the host CSS and the package CSS do not touch. */
+export declare const ShadowRoot: ({ children, style }: {
+    children: ReactNode;
+    style?: CSSProperties;
+}) => import("react").JSX.Element;

package/dist/types/ui/form/Blocks.d.ts

@@ -0,0 +1,6 @@
+import { type FormBlock } from '../../flow/form';
+import { type FieldContext } from './FormField';
+export declare const Block: ({ block, context }: {
+    block: FormBlock;
+    context: FieldContext;
+}) => import("react").JSX.Element;

package/dist/types/ui/form/FormField.d.ts

@@ -0,0 +1,38 @@
+import type { AnswerMap } from '../../flow/answer';
+import { type Answer } from './inputs';
+export interface FieldContext {
+    consultationHash: string;
+    questions: iQuestion[];
+    answers: AnswerMap;
+    optionHashes: AnswerMap;
+    onAnswer: Answer;
+    disabled?: boolean;
+    /** Questions to mark as needing an answer, after a submit that failed the check. */
+    missing: Set<string>;
+    /** The question a failed submit points at. A new tick asks again, so tabs open the one that holds it. */
+    focus: {
+        hash: string;
+        tick: number;
+    } | null;
+}
+export declare const MissingNote: ({ show }: {
+    show: boolean;
+}) => import("react").JSX.Element;
+export declare const getOpenFollowUps: (hash: string, context: FieldContext) => string[];
+/** The open follow-ups of a question, indented under it. */
+export declare const FollowUps: ({ hash, context }: {
+    hash: string;
+    context: FieldContext;
+}) => import("react").JSX.Element;
+/** `spaced` adds the gap a field needs inside a section, where Yes / No rows sit with no gap. */
+export declare const FormField: ({ hash, context, spaced }: {
+    hash: string;
+    context: FieldContext;
+    spaced?: boolean;
+}) => import("react").JSX.Element;
+/** A question as a table cell, with no label of its own. */
+export declare const Cell: ({ hash, column, context }: {
+    hash: string;
+    column: string;
+    context: FieldContext;
+}) => import("react").JSX.Element;