@cosyte/synth 0.0.1

package/dist/hl7/index.d.ts

@@ -0,0 +1,548 @@
+import { Hl7Message, RawField } from '@cosyte/hl7';
+import { S as SyntheticName, a as SyntheticIdentifier, b as SyntheticAddress, R as Rng, C as Corpus } from '../providers-OLz3zAc-.js';
+import { Q as QuirkDescriptor, S as SynthProfile, a as QuirkArtifact, b as QuirkRoundTripResult } from '../quirk-JLyO1Ncj.js';
+
+/**
+ * Spec-clean HL7 v2 `ADT` generation, built **through `@cosyte/hl7`'s `buildMessage`** so MSH
+ * delimiters, segment layout, and escaping are the parser's own conservative emit — spec-clean *by
+ * construction*. Every PHI-bearing field (name, DOB, SSN, MRN,
+ * address, phone) is drawn from the synthetic-safety providers (`../safe`), so no value can be real.
+ *
+ * `ADT^A01/A04/A08` all require the `PID` (patient) + `PV1` (visit) groups the parser's structure net
+ * checks for — so a generated message round-trips through `@cosyte/hl7` with **zero warnings**.
+ *
+ * @module
+ */
+
+/** The ADT trigger events this generator produces (all require the PID + PV1 groups). */
+type AdtTrigger = "A01" | "A04" | "A08";
+/** Options for {@link generateAdt}. */
+interface GenerateAdtOptions {
+    /** The seed — the same seed yields a byte-identical message. Defaults to `0`. */
+    readonly seed?: number;
+    /** The ADT trigger event. Defaults to `"A01"`. */
+    readonly trigger?: AdtTrigger;
+}
+/**
+ * Generate a spec-clean `ADT` {@link Hl7Message} through `@cosyte/hl7`. Deterministic in `seed`.
+ *
+ * The message carries a complete MSH (seeded control id + timestamp, so the bytes are reproducible),
+ * `EVN`, a fully-populated `PID` (identity from the synthetic providers), and `PV1` (the visit group),
+ * so it parses back through `@cosyte/hl7` with **zero warnings** (proven by {@link ./round-trip}).
+ *
+ * @param options - Seed + trigger. See {@link GenerateAdtOptions}.
+ * @returns A spec-clean `ADT` `Hl7Message`.
+ * @example
+ * ```ts
+ * import { generateAdt } from "@cosyte/synth/hl7";
+ * const msg = generateAdt({ seed: 12345, trigger: "A01" });
+ * console.log(msg.toString());
+ * ```
+ */
+declare function generateAdt(options?: GenerateAdtOptions): Hl7Message;
+
+/**
+ * Spec-clean HL7 v2 `ORU^R01` (unsolicited observation result) generation, built **through
+ * `@cosyte/hl7`'s `buildMessage`**. The parser's structure net requires the
+ * result group (`OBR`/`OBX`) for `ORU^R01`; this generator always emits both, plus a fully-populated
+ * `PID`, so the message round-trips with **zero warnings**. Patient identity comes from `../safe`;
+ * observation codes come from the license-clean example pool (`./example-codes`), never bundled
+ * terminology. A `synth` `ORU` is *structurally* valid, not clinically coherent.
+ *
+ * @module
+ */
+
+/** Options for {@link generateOru}. */
+interface GenerateOruOptions {
+    /** The seed — the same seed yields a byte-identical message. Defaults to `0`. */
+    readonly seed?: number;
+}
+/**
+ * Generate a spec-clean `ORU^R01` {@link Hl7Message} through `@cosyte/hl7`. Deterministic in `seed`.
+ *
+ * Layout: MSH, `PID` (synthetic identity), `OBR` (order/observation request), and 1–3 `OBX` result
+ * rows. The `OBR`/`OBX` result group satisfies the parser's `ORU^R01` structure net, so the message
+ * re-parses with **zero warnings** (proven by {@link ./round-trip}).
+ *
+ * @param options - Seed. See {@link GenerateOruOptions}.
+ * @returns A spec-clean `ORU^R01` `Hl7Message`.
+ * @example
+ * ```ts
+ * import { generateOru } from "@cosyte/synth/hl7";
+ * const msg = generateOru({ seed: 12345 });
+ * console.log(msg.toString());
+ * ```
+ */
+declare function generateOru(options?: GenerateOruOptions): Hl7Message;
+
+/**
+ * Spec-clean HL7 v2 `ORM^O01` (general order) generation, built **through `@cosyte/hl7`'s
+ * `buildMessage`**. The parser's structure net requires the common-order segment
+ * (`ORC`) for `ORM^O01`; this generator emits `ORC` + a matching `OBR`, plus a fully-populated `PID`,
+ * so the message round-trips with **zero warnings**. Identity comes from `../safe`; the ordered service
+ * comes from the license-clean example pool, never bundled terminology.
+ *
+ * @module
+ */
+
+/** Options for {@link generateOrm}. */
+interface GenerateOrmOptions {
+    /** The seed — the same seed yields a byte-identical message. Defaults to `0`. */
+    readonly seed?: number;
+}
+/**
+ * Generate a spec-clean `ORM^O01` {@link Hl7Message} through `@cosyte/hl7`. Deterministic in `seed`.
+ *
+ * Layout: MSH, `PID` (synthetic identity), `ORC` (common order — control `NW`, new order), and a
+ * matching `OBR` (order detail). The `ORC` satisfies the parser's `ORM^O01` structure net, so the
+ * message re-parses with **zero warnings** (proven by {@link ./round-trip}).
+ *
+ * @param options - Seed. See {@link GenerateOrmOptions}.
+ * @returns A spec-clean `ORM^O01` `Hl7Message`.
+ * @example
+ * ```ts
+ * import { generateOrm } from "@cosyte/synth/hl7";
+ * const msg = generateOrm({ seed: 12345 });
+ * console.log(msg.toString());
+ * ```
+ */
+declare function generateOrm(options?: GenerateOrmOptions): Hl7Message;
+
+/**
+ * Spec-clean HL7 v2 `SIU^S12` (notification of new appointment booking) generation, built **through
+ * `@cosyte/hl7`'s `buildMessage`**. The parser's structure net requires the schedule
+ * activity segment (`SCH`) for `SIU^S12`; this generator emits `SCH` + `PID` + a resource group
+ * (`RGS`/`AIL`), so the message round-trips with **zero warnings**. Identity comes from `../safe`.
+ *
+ * @module
+ */
+
+/** Options for {@link generateSiu}. */
+interface GenerateSiuOptions {
+    /** The seed — the same seed yields a byte-identical message. Defaults to `0`. */
+    readonly seed?: number;
+}
+/**
+ * Generate a spec-clean `SIU^S12` {@link Hl7Message} through `@cosyte/hl7`. Deterministic in `seed`.
+ *
+ * Layout: MSH, `SCH` (schedule activity — the required group), `PID` (synthetic identity), `RGS`
+ * (resource group), `AIL` (location resource). The `SCH` satisfies the parser's `SIU^S12` structure
+ * net, so the message re-parses with **zero warnings** (proven by {@link ./round-trip}).
+ *
+ * @param options - Seed. See {@link GenerateSiuOptions}.
+ * @returns A spec-clean `SIU^S12` `Hl7Message`.
+ * @example
+ * ```ts
+ * import { generateSiu } from "@cosyte/synth/hl7";
+ * const msg = generateSiu({ seed: 12345 });
+ * console.log(msg.toString());
+ * ```
+ */
+declare function generateSiu(options?: GenerateSiuOptions): Hl7Message;
+
+/**
+ * Spec-clean HL7 v2 `VXU^V04` (unsolicited vaccination record update) generation, built **through
+ * `@cosyte/hl7`'s `buildMessage`**. The parser's structure net requires the patient
+ * group (`PID`) for `VXU^V04` (per the CDC IG, `RXA` lives in the optional order group); this generator
+ * emits `PID` + `ORC` + `RXA` + `RXR`, so the message round-trips with **zero warnings**. Identity comes
+ * from `../safe`; the vaccine code comes from the license-clean example pool, never bundled terminology.
+ *
+ * @module
+ */
+
+/** Options for {@link generateVxu}. */
+interface GenerateVxuOptions {
+    /** The seed — the same seed yields a byte-identical message. Defaults to `0`. */
+    readonly seed?: number;
+}
+/**
+ * Generate a spec-clean `VXU^V04` {@link Hl7Message} through `@cosyte/hl7`. Deterministic in `seed`.
+ *
+ * Layout: MSH, `PID` (synthetic identity — the required group), `ORC` (common order), `RXA` (vaccine
+ * administration, CVX example code), `RXR` (route). The `PID` satisfies the parser's `VXU^V04`
+ * structure net, so the message re-parses with **zero warnings** (proven by {@link ./round-trip}).
+ *
+ * @param options - Seed. See {@link GenerateVxuOptions}.
+ * @returns A spec-clean `VXU^V04` `Hl7Message`.
+ * @example
+ * ```ts
+ * import { generateVxu } from "@cosyte/synth/hl7";
+ * const msg = generateVxu({ seed: 12345 });
+ * console.log(msg.toString());
+ * ```
+ */
+declare function generateVxu(options?: GenerateVxuOptions): Hl7Message;
+
+/**
+ * The **round-trip-through-the-parser harness** — the headline gate for the synthetic-fixture
+ * generator. A generated artifact is "spec-clean" only if `@cosyte/hl7` — not
+ * `@cosyte/synth`'s own opinion — reads it back cleanly. This harness feeds a generated message
+ * straight back into the parser and reports what the parser found, so a false "spec-clean" claim
+ * cannot hide.
+ *
+ * @module
+ */
+
+/** The verdict of one round-trip through `@cosyte/hl7`. */
+interface RoundTripResult {
+    /** The serialized wire text (the parser's own conservative emit). */
+    readonly content: string;
+    /** The warning codes the parser emitted on re-parse. Empty ⇒ spec-clean. */
+    readonly warnings: readonly string[];
+    /** Whether re-serializing the re-parsed message is byte-identical to `content`. */
+    readonly byteStable: boolean;
+    /** `true` iff the artifact is spec-clean: zero warnings **and** byte-stable. */
+    readonly specClean: boolean;
+}
+/**
+ * Round-trip an `@cosyte/hl7` `Hl7Message` through serialize → parse → serialize and report the
+ * verdict. A spec-clean artifact re-parses with **zero warnings** and re-serializes byte-identically.
+ *
+ * @param message - The message to check (typically from `generateAdt`).
+ * @returns The {@link RoundTripResult}.
+ * @example
+ * ```ts
+ * import { generateAdt, roundTrip } from "@cosyte/synth/hl7";
+ * const { specClean, warnings } = roundTrip(generateAdt({ seed: 1 }));
+ * // specClean === true, warnings.length === 0
+ * ```
+ */
+declare function roundTrip(message: Hl7Message): RoundTripResult;
+
+/**
+ * Thin helpers that build `@cosyte/hl7` `RawField` objects with **components** for `addSegment`.
+ *
+ * Why this exists: `Hl7Message.addSegment` accepts a field as either a plain string or a structured
+ * `RawField`. A plain string is emitted **verbatim** — a literal `^` in it is escaped to `\S\`, not
+ * treated as a component separator (the parser re-escapes on serialize, by design). To place true
+ * components (a name's family/given, a CX's id/authority/type) we must hand `addSegment` a `RawField`
+ * with explicit `components`, so the parser's own conservative serializer lays out the separators.
+ * That is the whole point of building *through* the parser.
+ *
+ * @module
+ */
+
+/**
+ * Build a `RawField` from a flat list of component strings (single repetition, single subcomponent
+ * per component). Empty strings become empty components (absent at the wire level).
+ *
+ * @param components - The component values, in HL7 component order.
+ * @returns A `RawField` the hl7 serializer lays out with `^` separators.
+ * @example
+ * ```ts
+ * import { componentsField } from "@cosyte/synth/hl7";
+ * componentsField(["Testerson", "Quilliam"]); // family^given
+ * ```
+ */
+declare function componentsField(components: readonly string[]): RawField;
+
+/**
+ * Shared HL7 v2 building blocks for every message family `@cosyte/synth` generates — the MSH scaffold,
+ * the seeded timestamp, and the patient-identity bundle + its `PID` segment. Factored out so `ADT`,
+ * `ORU`, `ORM`, `SIU`, and `VXU` all mint identity from the **same** synthetic-safety providers in the
+ * **same** draw order, and all emit through `@cosyte/hl7`'s conservative serializer. Nothing here draws a
+ * value that is not sourced from `../safe` — the synthetic-by-construction
+ * invariant holds by construction for every family.
+ *
+ * @module
+ */
+
+/**
+ * A seeded HL7 `YYYYMMDDHHMMSS` timestamp (message/event time; recent-year range). Strict HL7 DTM, so
+ * `@cosyte/hl7` parses it back with no `TIMESTAMP_FALLBACK_FORMAT` warning.
+ *
+ * @param rng - The seeded generator.
+ * @returns A 14-digit `YYYYMMDDHHMMSS` timestamp string.
+ * @example
+ * ```ts
+ * import { createRng } from "@cosyte/synth";
+ * // "20230714…"
+ * ```
+ */
+declare function seededTimestamp(rng: Rng): string;
+/** The MSH scaffold shared by every generated message: the built message plus its seeded MSH values. */
+interface MessageScaffold {
+    /** The `Hl7Message` with a complete MSH — chain `.addSegment(...)` to append the payload. */
+    readonly message: Hl7Message;
+    /** The seeded `YYYYMMDDHHMMSS` message timestamp (MSH-7), reused for event/observation times. */
+    readonly timestamp: string;
+    /** The seeded message control id (MSH-10). */
+    readonly controlId: string;
+}
+/**
+ * Build the MSH scaffold for a message of the given `MSH-9` type through `@cosyte/hl7`'s `buildMessage`,
+ * so the delimiters, control id, and header layout are the parser's own conservative emit. Draws the
+ * timestamp then the control id from `rng` (a fixed order — the reproducibility contract).
+ *
+ * @param rng - The seeded generator.
+ * @param type - The `MSH-9` message type, e.g. `"ORU^R01"`.
+ * @returns The {@link MessageScaffold}.
+ * @example
+ * ```ts
+ * import { createRng } from "@cosyte/synth";
+ * // mshScaffold(createRng(1), "ORU^R01").message.addSegment("PID", […]);
+ * ```
+ */
+declare function mshScaffold(rng: Rng, type: string): MessageScaffold;
+/** A complete synthetic patient identity — every field drawn from `../safe`. */
+interface PatientIdentity {
+    /** Name from the shipped fake-name pool. */
+    readonly person: SyntheticName;
+    /** Medical-record identifier scoped to the synthetic assigning authority. */
+    readonly mrn: SyntheticIdentifier;
+    /** Date of birth (`YYYYMMDD`) from the seeded generator. */
+    readonly dob: string;
+    /** Administrative sex. */
+    readonly sex: "M" | "F";
+    /** Synthetic postal address (reserved non-real ZIP). */
+    readonly address: SyntheticAddress;
+    /** Reserved `555-01xx` phone number. */
+    readonly phone: string;
+    /** Never-issued SSN as 9 digits (no dashes), for `PID-19`. */
+    readonly ssnDigits: string;
+}
+/**
+ * Mint a complete synthetic {@link PatientIdentity}. Every value comes from a synthetic-safety provider
+ * — no code path here can return a real or plausibly-real identifier. The draw order is
+ * fixed (name → MRN → DOB → sex → address → phone → SSN) so the same seed yields the same identity.
+ *
+ * @param rng - The seeded generator.
+ * @returns A synthetic {@link PatientIdentity}.
+ * @example
+ * ```ts
+ * import { createRng } from "@cosyte/synth";
+ * // const id = patientIdentity(createRng(1)); // id.person, id.mrn, …
+ * ```
+ */
+declare function patientIdentity(rng: Rng): PatientIdentity;
+/**
+ * Lay out a fully-populated `PID` segment from a {@link PatientIdentity} as `addSegment` fields — the
+ * PHI-dense segment shared by every family. Components go through {@link componentsField} so the parser
+ * lays out the `^` separators (building *through* the parser).
+ *
+ * @param id - The synthetic identity to render.
+ * @returns The `PID` field list for `Hl7Message.addSegment("PID", …)`.
+ * @example
+ * ```ts
+ * // msg.addSegment("PID", pidSegment(patientIdentity(createRng(1))));
+ * ```
+ */
+declare function pidSegment(id: PatientIdentity): readonly (string | RawField)[];
+
+/**
+ * A tiny, curated, **license-clean** pool of example codes used to fill coded fields in generated HL7
+ * messages (`OBR`/`OBX` observations, `ORC`/`OBR` orders, `RXA` vaccines). These are **public code
+ * facts** — the spec examples' own values — not copyrighted terminology tables: `@cosyte/synth` bundles
+ * **no** SNOMED/CPT/LOINC/RxNorm content. The pool exists only so a generated message is *structurally*
+ * realistic; a consumer who
+ * needs their own codes supplies them.
+ *
+ * Nothing here is PHI — codes and their display text are not identifiers. The synthetic-safety
+ * invariant governs identity fields (name/DOB/SSN/MRN/phone/address), which come from `../safe`.
+ *
+ * @module
+ */
+/** A coded concept: an identifier code, human-readable text, and its code system (HL7 `CE`/`CWE`). */
+interface ExampleCode {
+    /** The code value (component 1). */
+    readonly code: string;
+    /** The human-readable display text (component 2). */
+    readonly text: string;
+    /** The coding-system id (component 3), e.g. `"LN"` (LOINC) or `"CVX"`. */
+    readonly system: string;
+    /** Reporting units (UCUM), where the concept is a measured quantity. */
+    readonly units?: string;
+}
+/**
+ * A handful of common LOINC laboratory-observation example codes (for `OBX`). Public LOINC identifiers
+ * used purely as illustrative structural fillers.
+ */
+declare const EXAMPLE_LAB_OBSERVATIONS: readonly ExampleCode[];
+/**
+ * A handful of LOINC panel/service example codes (for the `OBR`/`ORC` universal service id). Public
+ * identifiers used as structural fillers.
+ */
+declare const EXAMPLE_ORDER_SERVICES: readonly ExampleCode[];
+/**
+ * A handful of CDC CVX vaccine example codes (for `RXA-5`). Public CVX identifiers used as structural
+ * fillers; `@cosyte/synth` bundles no vaccine terminology.
+ */
+declare const EXAMPLE_VACCINES: readonly ExampleCode[];
+
+/**
+ * HL7 v2 **vendor-quirk generation**. A quirk deviates the
+ * *structure* of an otherwise spec-clean message so it round-trips through `@cosyte/hl7` to **exactly**
+ * one intended, stable warning code — the tolerance a `defineProfile` profile encodes. The deviation is
+ * applied **post-serialize**.
+ *
+ * Two publicly-groundable quirks ship (cited-public, never a private vendor corpus):
+ *
+ * - **`unknown-zsegment`** → `UNKNOWN_SEGMENT`. HL7 v2.x §2.5 permits site-defined `Z`-segments; a
+ *   receiver with no profile flags them. `@cosyte/hl7`'s public imaging/PACS profiles (`visage`,
+ *   `philips`, `va` — each grounded in a downloadable vendor/federal interface spec) declare `ZDS`, so a
+ *   `defineProfile` that claims the segment **suppresses** the warning.
+ * - **`unknown-escape`** → `UNKNOWN_ESCAPE_SEQUENCE`. HL7 v2.x §2.7 escaping — a locally-defined
+ *   `\Z..\` escape is preserved verbatim and flagged. HL7 v2 has no re-badge mechanism, so this is a
+ *   `"bare"` quirk (no built-in profile downgrades it).
+ *
+ * A quirk **never** introduces a real-looking value — it changes the message *shape*, never the
+ * *provenance* of the data, so the synthetic-safety gate still runs and stays zero.
+ *
+ * @module
+ */
+
+/** Every HL7 v2 quirk this package ships. */
+type Hl7QuirkName = "unknown-zsegment" | "unknown-escape";
+/** The HL7 v2 message families a quirk can be injected into (the spec-clean base). */
+type Hl7QuirkKind = "ADT^A01" | "ADT^A04" | "ADT^A08" | "ORU^R01" | "ORM^O01" | "SIU^S12" | "VXU^V04";
+/**
+ * The HL7 v2 quirk registry — each recipe bound to the exact `@cosyte/hl7` warning code it targets and
+ * its public grounding.
+ */
+declare const HL7_QUIRKS: Readonly<Record<Hl7QuirkName, QuirkDescriptor>>;
+/** Options for {@link generateHl7Quirk}. */
+interface GenerateHl7QuirkOptions {
+    /** The seed — the same seed + quirk yields a byte-identical message. Defaults to `0`. */
+    readonly seed?: number;
+    /** The quirk to inject. Required. */
+    readonly quirk: Hl7QuirkName;
+    /** The spec-clean base message family. Defaults to `"ORU^R01"`. */
+    readonly kind?: Hl7QuirkKind;
+}
+/**
+ * Generate one HL7 v2 **quirk** artifact: a spec-clean message (built through `@cosyte/hl7`) with the
+ * requested vendor deviation injected post-serialize. Deterministic in `seed` + `quirk` + `kind`.
+ *
+ * @param options - Seed, quirk, and base kind. See {@link GenerateHl7QuirkOptions}.
+ * @returns The {@link QuirkArtifact} — its `content` round-trips to `intendedWarnings` exactly.
+ * @throws SynthError `SYNTH_UNSUPPORTED_QUIRK` if `quirk` is not a supported HL7 quirk.
+ * @example
+ * ```ts
+ * import { generateHl7Quirk, hl7QuirkRoundTrip } from "@cosyte/synth/hl7";
+ * const artifact = generateHl7Quirk({ seed: 1, quirk: "unknown-zsegment" });
+ * hl7QuirkRoundTrip(artifact).intendedWarningHeld; // true — exactly UNKNOWN_SEGMENT
+ * ```
+ */
+declare function generateHl7Quirk(options: GenerateHl7QuirkOptions): QuirkArtifact;
+/**
+ * Round-trip an HL7 v2 quirk artifact through `@cosyte/hl7` and report the intended-warning verdict: a bare
+ * parse must produce **exactly** the intended code(s), and — when a built-in public
+ * profile tolerates the quirk — the profiled parse must suppress it.
+ *
+ * @param artifact - The quirk artifact (from {@link generateHl7Quirk}).
+ * @returns The {@link QuirkRoundTripResult}.
+ * @example
+ * ```ts
+ * import { generateHl7Quirk, hl7QuirkRoundTrip } from "@cosyte/synth/hl7";
+ * const rt = hl7QuirkRoundTrip(generateHl7Quirk({ seed: 1, quirk: "unknown-zsegment" }));
+ * rt.withProfile?.tolerated; // true — the `visage` profile suppresses UNKNOWN_SEGMENT
+ * ```
+ */
+declare function hl7QuirkRoundTrip(artifact: QuirkArtifact): QuirkRoundTripResult;
+/** Options for {@link hl7QuirkCorpus}. */
+interface Hl7QuirkCorpusOptions {
+    /** The seed for the whole corpus (deterministic). */
+    readonly seed: number;
+    /** How many quirk artifacts to generate. Defaults to the number of quirks. */
+    readonly count?: number;
+    /** The quirk names to cycle through. Defaults to every HL7 quirk. Validated; unsupported ⇒ fatal. */
+    readonly quirks?: readonly Hl7QuirkName[];
+    /** A {@link SynthProfile} whose `quirks` drive the corpus (validated). Takes precedence over `quirks`. */
+    readonly profile?: SynthProfile;
+    /** The base message family each quirk is injected into. Defaults to `"ORU^R01"`. */
+    readonly kind?: Hl7QuirkKind;
+}
+/**
+ * Build a reproducible {@link Corpus} of HL7 v2 quirk artifacts. Each artifact's `warnings` record the
+ * parser's verdict — the intended code(s) for its quirk (not empty: a quirk corpus is deliberately
+ * off-spec) — and the manifest lists the applied quirk names.
+ *
+ * @param options - Seed, count, and the quirk selection. See {@link Hl7QuirkCorpusOptions}.
+ * @returns A deep-frozen {@link Corpus}.
+ * @example
+ * ```ts
+ * import { hl7QuirkCorpus } from "@cosyte/synth/hl7";
+ * const corpus = hl7QuirkCorpus({ seed: 42 });
+ * corpus.manifest.quirks; // ["unknown-zsegment", "unknown-escape"]
+ * ```
+ */
+declare function hl7QuirkCorpus(options: Hl7QuirkCorpusOptions): Corpus;
+/**
+ * A ready-made {@link SynthProfile} that requests every built-in HL7 quirk — a convenience for wiring
+ * `defineSynthProfile`'s quirk list to the parser's real tolerance.
+ *
+ * @example
+ * ```ts
+ * import { hl7QuirkProfile, hl7QuirkCorpus } from "@cosyte/synth/hl7";
+ * hl7QuirkCorpus({ seed: 1, profile: hl7QuirkProfile });
+ * ```
+ */
+declare const hl7QuirkProfile: SynthProfile;
+
+/**
+ * `@cosyte/synth/hl7` — the HL7 v2 generation surface, exposed as its own subpath so importing the
+ * package root does **not** pull `@cosyte/hl7`. This is the **lazy, per-format** boundary: a consumer
+ * who only needs HL7 fixtures imports `@cosyte/synth/hl7`; one who needs only the core primitives
+ * never loads a parser.
+ * `@cosyte/hl7` is an **optional peer dependency** — present only for this subpath.
+ *
+ * The HL7 v2 message set is complete: `ADT` (A01/A04/A08), `ORU^R01`, `ORM^O01`, `SIU^S12`, and
+ * `VXU^V04` — each built through `@cosyte/hl7`'s `buildMessage` and round-tripping with zero warnings.
+ *
+ * @module
+ */
+
+/**
+ * Every HL7 v2 message kind this subpath generates — the `MSH-9` label used as the corpus `kind`. `ADT`
+ * carries its trigger; the other families have a single generated trigger each.
+ */
+type Hl7MessageKind = "ADT^A01" | "ADT^A04" | "ADT^A08" | "ORU^R01" | "ORM^O01" | "SIU^S12" | "VXU^V04";
+/**
+ * Generate one message of the given {@link Hl7MessageKind} from a seed, dispatching to the right
+ * family generator. Every kind builds through `@cosyte/hl7` and is deterministic in `seed`.
+ *
+ * @param kind - The message kind to generate.
+ * @param seed - The seed.
+ * @returns The generated `Hl7Message`.
+ * @example
+ * ```ts
+ * import { generateHl7 } from "@cosyte/synth/hl7";
+ * generateHl7("ORU^R01", 42).toString();
+ * ```
+ */
+declare function generateHl7(kind: Hl7MessageKind, seed: number): Hl7Message;
+/** Options for {@link hl7Corpus}. */
+interface Hl7CorpusOptions {
+    /** The seed for the whole corpus (deterministic). */
+    readonly seed: number;
+    /** How many messages to generate. Defaults to `1`. */
+    readonly count?: number;
+    /**
+     * The message kinds to cycle through. Defaults to one of every family
+     * (`ADT^A01/A04/A08`, `ORU^R01`, `ORM^O01`, `SIU^S12`, `VXU^V04`).
+     */
+    readonly mix?: readonly Hl7MessageKind[];
+    /**
+     * ADT-only convenience: the triggers to cycle through, kept for back-compat. When
+     * supplied it takes precedence over `mix` and restricts the corpus to `ADT` messages.
+     */
+    readonly triggers?: readonly AdtTrigger[];
+}
+/**
+ * Build a reproducible {@link Corpus} of spec-clean HL7 messages across the families. Each
+ * message is generated from a distinct sub-seed derived from the corpus seed (so the set is
+ * deterministic) and round-tripped through `@cosyte/hl7`; the per-artifact `warnings` record the
+ * parser's verdict (empty ⇒ spec-clean).
+ *
+ * @param options - Seed, count, and the message mix. See {@link Hl7CorpusOptions}.
+ * @returns A deep-frozen {@link Corpus}.
+ * @example
+ * ```ts
+ * import { hl7Corpus } from "@cosyte/synth/hl7";
+ * const corpus = hl7Corpus({ seed: 42, count: 7 });
+ * corpus.artifacts.every((a) => a.warnings.length === 0); // true — spec-clean
+ * ```
+ */
+declare function hl7Corpus(options: Hl7CorpusOptions): Corpus;
+
+export { type AdtTrigger, EXAMPLE_LAB_OBSERVATIONS, EXAMPLE_ORDER_SERVICES, EXAMPLE_VACCINES, type ExampleCode, type GenerateAdtOptions, type GenerateHl7QuirkOptions, type GenerateOrmOptions, type GenerateOruOptions, type GenerateSiuOptions, type GenerateVxuOptions, HL7_QUIRKS, type Hl7CorpusOptions, type Hl7MessageKind, type Hl7QuirkCorpusOptions, type Hl7QuirkKind, type Hl7QuirkName, type MessageScaffold, type PatientIdentity, type RoundTripResult, componentsField, generateAdt, generateHl7, generateHl7Quirk, generateOrm, generateOru, generateSiu, generateVxu, hl7Corpus, hl7QuirkCorpus, hl7QuirkProfile, hl7QuirkRoundTrip, mshScaffold, patientIdentity, pidSegment, roundTrip, seededTimestamp };