@cosyte/synth 0.0.1

package/dist/providers-OLz3zAc-.d.ts

@@ -0,0 +1,343 @@
+/**
+ * The `Corpus` abstraction — a seed plus a self-describing manifest of what was generated, so a
+ * fixture set is itself reproducible and regenerable. A downstream repo pins a seed
+ * and gets a stable fixture set that regenerates identically.
+ *
+ * Generated artifacts and the `Corpus` are **deep-frozen** — this is where the archetype's immutability
+ * invariant lives in a generator: a consumer cannot mutate a shared fixture out from under
+ * another test.
+ *
+ * @module
+ */
+/** The format an artifact was generated for. */
+type SynthFormat = "hl7v2" | "fhir" | "ccda" | "x12" | "ncpdp" | "astm";
+/**
+ * One generated artifact — the serialized wire text plus the metadata needed to reproduce and check
+ * it. `warnings` records what the artifact's own parser reported on the round-trip (zero for a
+ * spec-clean artifact).
+ */
+interface Artifact {
+    /** The format this artifact belongs to. */
+    readonly format: SynthFormat;
+    /** A format-specific kind label (e.g. `"ADT^A01"`). */
+    readonly kind: string;
+    /** The serialized wire text, produced by the parser's own conservative serializer. */
+    readonly content: string;
+    /** The warning codes the parser emitted when the artifact was round-tripped (empty = spec-clean). */
+    readonly warnings: readonly string[];
+}
+/** A self-describing manifest of a {@link Corpus}. */
+interface CorpusManifest {
+    /** The formats present in the corpus. */
+    readonly formats: readonly SynthFormat[];
+    /** Per-kind artifact counts (e.g. `{ "ADT^A01": 3 }`). */
+    readonly counts: Readonly<Record<string, number>>;
+    /** The quirk names applied. */
+    readonly quirks: readonly string[];
+}
+/** A reproducible, self-describing set of generated artifacts. */
+interface Corpus {
+    /** The seed the corpus was generated from — regenerating from it yields byte-identical artifacts. */
+    readonly seed: number;
+    /** The manifest describing what was generated. */
+    readonly manifest: CorpusManifest;
+    /** The generated artifacts, in generation order. */
+    readonly artifacts: readonly Artifact[];
+}
+/**
+ * Assemble a deep-frozen {@link Corpus} from a seed and its artifacts, deriving the manifest.
+ *
+ * @param seed - The seed the artifacts were generated from.
+ * @param artifacts - The generated artifacts, in order.
+ * @param quirks - The quirk names applied (default none).
+ * @returns A deep-frozen, self-describing {@link Corpus}.
+ * @example
+ * ```ts
+ * import { makeCorpus } from "@cosyte/synth";
+ * const corpus = makeCorpus(1, [{ format: "hl7v2", kind: "ADT^A01", content, warnings: [] }]);
+ * corpus.manifest.counts["ADT^A01"]; // 1
+ * ```
+ */
+declare function makeCorpus(seed: number, artifacts: readonly Artifact[], quirks?: readonly string[]): Corpus;
+
+/**
+ * `Rng` — the seeded, deterministic random source every `@cosyte/synth` provider draws from.
+ *
+ * **The reproducibility contract.** A seed — and only the seed — determines the output.
+ * `createRng(seed)` expands the integer seed through {@link ./splitmix32.splitmix32} into the four
+ * `sfc32` state words, then every draw advances that state via {@link ./sfc32.sfc32Next}. Two `Rng`s
+ * created from the same seed emit the **identical** sequence on any machine, any run — the property
+ * the parsers', `transform`'s, and `deid`'s regression suites depend on.
+ *
+ * **Explicit, never global.** An `Rng` is a value you thread through a build; there is no ambient
+ * shared generator and **`Math.random` is lint-banned** in `src/` (it is not seedable — its seed is
+ * engine-chosen and cannot be reset, so a corpus built on it is not reproducible). Because each
+ * generation creates a fresh `Rng` from its seed, generations are independent and parallel-safe.
+ *
+ * The `Rng` object is stateful by nature (a PRNG advances). Immutability in this library lives where it
+ * is testable and matters: the generated **artifacts and the `Corpus` are deep-frozen** (see
+ * `../corpus.ts`). Determinism, not object-immutability, is the `Rng`'s guarantee.
+ *
+ * @module
+ */
+/**
+ * A seeded, deterministic random source. Created via {@link createRng}; passed explicitly to every
+ * provider. All draw methods advance the internal state deterministically.
+ */
+interface Rng {
+    /** The integer seed this generator was created from (part of the `Corpus` manifest). */
+    readonly seed: number;
+    /** The next unsigned 32-bit integer. */
+    nextUint32(): number;
+    /** The next float in `[0, 1)`. */
+    float(): number;
+    /**
+     * A uniformly-distributed integer in the inclusive range `[min, max]`.
+     *
+     * @param min - Inclusive lower bound (integer).
+     * @param max - Inclusive upper bound (integer, `>= min`).
+     */
+    int(min: number, max: number): number;
+    /** `true` with probability `p` (default `0.5`). */
+    bool(p?: number): boolean;
+    /**
+     * Pick one element from a non-empty array.
+     *
+     * @param items - A non-empty readonly array.
+     */
+    pick<T>(items: readonly T[]): T;
+    /**
+     * A string of `n` decimal digits (`0`–`9`), each drawn uniformly.
+     *
+     * @param n - The number of digits (`>= 0`).
+     */
+    digits(n: number): string;
+}
+/**
+ * Create a seeded, deterministic {@link Rng}. The same `seed` yields the same sequence everywhere.
+ *
+ * @param seed - The integer seed. Coerced to a 32-bit integer.
+ * @returns A fresh, independent {@link Rng}.
+ * @example
+ * ```ts
+ * import { createRng } from "@cosyte/synth";
+ * const rng = createRng(12345);
+ * rng.int(1, 6); // deterministic for seed 12345
+ * ```
+ */
+declare function createRng(seed: number): Rng;
+
+/**
+ * The synthetic-safety provider layer — every identifier, contact point, name, and date
+ * `@cosyte/synth` emits is minted here, and **only** from a guaranteed-non-colliding source. There is no code
+ * path that returns a value not drawn from a reserved range or the
+ * shipped fake-name pool. This is the inverse of a parser's liberality: the generator is *closed-world*
+ * on its data sources, so no output *can* be real or plausibly-real PHI.
+ *
+ * All providers are pure functions of an explicit {@link ../rng/rng.Rng} — same seed, same values.
+ *
+ * @module
+ */
+
+/** A synthetic person name drawn from the shipped fake-name pool. */
+interface SyntheticName {
+    /** A clearly-fake given name. */
+    readonly given: string;
+    /** A clearly-fake family name. */
+    readonly family: string;
+}
+/** A synthetic postal address — synthetic street + city, a fixed non-real ZIP. */
+interface SyntheticAddress {
+    /** A clearly-fake street line. */
+    readonly street: string;
+    /** A clearly-fake city. */
+    readonly city: string;
+    /** A US state abbreviation (structural only; never combined with a real street + name + DOB). */
+    readonly state: string;
+    /** A reserved non-real ZIP (`00000`). */
+    readonly zip: string;
+}
+/** A synthetic identifier scoped to the synthetic assigning authority. */
+interface SyntheticIdentifier {
+    /** The identifier value (digits) — unique only within the synthetic namespace. */
+    readonly value: string;
+    /** HL7 identifier type code (`MR` = medical record, `AN` = account, `MB` = member). */
+    readonly typeCode: "MR" | "AN" | "MB";
+    /** The synthetic assigning-authority namespace id. */
+    readonly assigningAuthority: string;
+    /** The synthetic assigning-authority OID (HL7 example arc). */
+    readonly assigningAuthorityOid: string;
+}
+/** Which SSN reserved space to draw from. */
+type SsnBlock = "never-issued" | "advertising";
+/**
+ * A **synthetic SSN** — dashed `AAA-GG-SSSS`. Default draws the SSA never-issued area space
+ * (`900–999`); `block: "advertising"` draws SSA's reserved advertising block (`987-65-4320…4329`).
+ * A value from this function can never be a real SSN.
+ *
+ * @param rng - The seeded generator.
+ * @param block - Which reserved space to draw from. Defaults to `"never-issued"`.
+ * @returns A dashed synthetic SSN string.
+ * @example
+ * ```ts
+ * import { createRng, ssn } from "@cosyte/synth";
+ * ssn(createRng(1)); // e.g. a 900-area, never-issued SSN
+ * ```
+ */
+declare function ssn(rng: Rng, block?: SsnBlock): string;
+/**
+ * A **synthetic phone** in the NANP reserved fictional block — `(AAA) 555-01NN`. The reserved
+ * guarantee is the `555-01NN` tail (exchange 555, line 0100–0199); the area code is any NANP-valid
+ * `NXX`. Can never be a working number.
+ *
+ * @param rng - The seeded generator.
+ * @returns A formatted synthetic phone string.
+ * @example
+ * ```ts
+ * import { createRng, phone } from "@cosyte/synth";
+ * phone(createRng(1)); // e.g. "(2XX) 555-01NN"
+ * ```
+ */
+declare function phone(rng: Rng): string;
+/**
+ * A **synthetic name** drawn from the shipped clearly-fake pool.
+ *
+ * @param rng - The seeded generator.
+ * @returns A {@link SyntheticName}.
+ * @example
+ * ```ts
+ * import { createRng, name } from "@cosyte/synth";
+ * const { given, family } = name(createRng(1));
+ * ```
+ */
+declare function name(rng: Rng): SyntheticName;
+/**
+ * A **synthetic email** at an RFC 2606 / 6761 reserved domain — `<slug>@example.com`.
+ *
+ * @param rng - The seeded generator.
+ * @param person - Optional name to derive the local-part slug from; otherwise a random slug is used.
+ * @returns A synthetic email address.
+ * @example
+ * ```ts
+ * import { createRng, email, name } from "@cosyte/synth";
+ * email(createRng(1), name(createRng(1))); // "<given>.<family>@example.com"
+ * ```
+ */
+declare function email(rng: Rng, person?: SyntheticName): string;
+/**
+ * A **synthetic IPv4** in an RFC 5737 TEST-NET block — never routable.
+ *
+ * @param rng - The seeded generator.
+ * @returns A TEST-NET IPv4 address string.
+ * @example
+ * ```ts
+ * import { createRng, ipv4 } from "@cosyte/synth";
+ * ipv4(createRng(1)); // e.g. "192.0.2.NN"
+ * ```
+ */
+declare function ipv4(rng: Rng): string;
+/**
+ * A **synthetic IPv6** in the RFC 3849 documentation prefix `2001:db8::/32` — never routable.
+ *
+ * @param rng - The seeded generator.
+ * @returns A documentation-prefix IPv6 address string.
+ * @example
+ * ```ts
+ * import { createRng, ipv6 } from "@cosyte/synth";
+ * ipv6(createRng(1)); // e.g. "2001:db8::NNNN"
+ * ```
+ */
+declare function ipv6(rng: Rng): string;
+/**
+ * A **deterministic UUIDv4-shaped** surrogate key from the seeded generator. Because it is seeded (not
+ * from `node:crypto`, which is not reproducible), the cryptographic non-collision argument is weaker —
+ * acceptable because the identifier namespace is synthetic anyway, and noted honestly.
+ *
+ * @param rng - The seeded generator.
+ * @returns A canonical `8-4-4-4-12` lowercase-hex UUID string with version `4` and RFC 4122 variant.
+ * @example
+ * ```ts
+ * import { createRng, uuid } from "@cosyte/synth";
+ * uuid(createRng(1)); // "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"
+ * ```
+ */
+declare function uuid(rng: Rng): string;
+/**
+ * A **synthetic NPI** — a 10-digit National Provider Identifier with a **deliberately-invalid Luhn
+ * check digit**, so it can never be a NPPES-issued NPI (a real NPI must satisfy the `80840`-prefixed
+ * Luhn check). The 9-digit base is drawn from the seeded generator; the check digit is
+ * set to `(correct + 1) mod 10`, guaranteeing the full value fails validation.
+ *
+ * @param rng - The seeded generator.
+ * @returns A 10-digit NPI-shaped string that is provably not a real NPI.
+ * @example
+ * ```ts
+ * import { createRng, npi, isSyntheticNpi } from "@cosyte/synth";
+ * isSyntheticNpi(npi(createRng(1))); // true — invalid check digit by construction
+ * ```
+ */
+declare function npi(rng: Rng): string;
+/**
+ * A **synthetic DEA number** — `<registrant-type><initial>` + 7 digits with a **deliberately-invalid
+ * checksum**, so it can never be a validly-issued DEA registration (a real DEA number's 7th digit
+ * satisfies the published DEA checksum). The first letter is a registrant-type letter, the
+ * second is derived from `person` (its family initial) when supplied so the number reads plausibly; the
+ * 6-digit base is seeded and the check digit is set to `(correct + 1) mod 10`, guaranteeing the value
+ * fails validation. NCPDP carries prescriber DEA, and this is the identity locus a refuter attacks
+ * hardest, so — like {@link npi} — non-collision is a construction-level guarantee, not a heuristic.
+ *
+ * @param rng - The seeded generator.
+ * @param person - Optional name whose family initial becomes the DEA's second letter.
+ * @returns A DEA-shaped string that is provably not a real DEA registration.
+ * @example
+ * ```ts
+ * import { createRng, dea, isSyntheticDea } from "@cosyte/synth";
+ * isSyntheticDea(dea(createRng(1))); // true — invalid checksum by construction
+ * ```
+ */
+declare function dea(rng: Rng, person?: SyntheticName): string;
+/**
+ * A **synthetic identifier** (MRN / account / member id) scoped to the synthetic assigning authority.
+ * There is no reserved MRN range, so non-collision is guaranteed by the *namespace*, not the value: the
+ * identifier lives under a `SYNTH` authority no real facility uses.
+ *
+ * @param rng - The seeded generator.
+ * @param typeCode - The HL7 identifier type: `MR` (default), `AN`, or `MB`.
+ * @returns A {@link SyntheticIdentifier}.
+ * @example
+ * ```ts
+ * import { createRng, identifier } from "@cosyte/synth";
+ * identifier(createRng(1), "MR"); // { value, typeCode: "MR", assigningAuthority: "COSYTE-SYNTH", ... }
+ * ```
+ */
+declare function identifier(rng: Rng, typeCode?: SyntheticIdentifier["typeCode"]): SyntheticIdentifier;
+/**
+ * A **synthetic address** — a fake street + city, a reserved non-real ZIP (`00000`). A real state
+ * abbreviation may appear (structural only) but is never combined with a real street + name + DOB.
+ *
+ * @param rng - The seeded generator.
+ * @returns A {@link SyntheticAddress}.
+ * @example
+ * ```ts
+ * import { createRng, address } from "@cosyte/synth";
+ * address(createRng(1)); // { street, city, state, zip: "00000" }
+ * ```
+ */
+declare function address(rng: Rng): SyntheticAddress;
+/**
+ * A **synthetic date** in HL7 `YYYYMMDD` form, drawn uniformly within an inclusive year range. Comes
+ * from the seeded generator (never wall-clock), so it is reproducible and implies no real event.
+ *
+ * @param rng - The seeded generator.
+ * @param minYear - Inclusive lower year bound (default `1930`).
+ * @param maxYear - Inclusive upper year bound (default `2010`).
+ * @returns An `YYYYMMDD` date string (always a valid calendar day).
+ * @example
+ * ```ts
+ * import { createRng, dateYmd } from "@cosyte/synth";
+ * dateYmd(createRng(1), 1970, 2000); // "YYYYMMDD"
+ * ```
+ */
+declare function dateYmd(rng: Rng, minYear?: number, maxYear?: number): string;
+
+export { type Artifact as A, type Corpus as C, type Rng as R, type SyntheticName as S, type SyntheticIdentifier as a, type SyntheticAddress as b, ipv6 as c, identifier as d, email as e, address as f, dateYmd as g, npi as h, ipv4 as i, dea as j, type CorpusManifest as k, type SsnBlock as l, type SynthFormat as m, name as n, createRng as o, phone as p, makeCorpus as q, ssn as s, uuid as u };

package/dist/quirk-DmkgoZdh.d.cts

@@ -0,0 +1,239 @@
+import { m as SynthFormat } from './providers-OLz3zAc-.cjs';
+
+/**
+ * `defineSynthProfile` — the growth-loop hook for site/vendor fixture recipes. A profile bundles the
+ * value pools and the quirk recipe a fixture set should use, authored through the same public API as
+ * the built-ins: a validated, frozen `SynthProfile` carrying a name, optional value overrides, and the
+ * quirk names a format's quirk corpus should apply.
+ *
+ * @module
+ */
+/** The user-authored spec passed to {@link defineSynthProfile}. */
+interface SynthProfileSpec {
+    /** A stable, human-readable profile name (e.g. `"acme-hospital"`). Required, non-empty. */
+    readonly name: string;
+    /** Optional given-name pool override (clearly-synthetic names only — see the safety invariant). */
+    readonly givenNames?: readonly string[];
+    /** Optional family-name pool override (clearly-synthetic names only). */
+    readonly familyNames?: readonly string[];
+    /**
+     * The vendor quirk recipe names this profile requests. Validated against the target format's quirk
+     * registry when the profile drives a quirk corpus (an unsupported quirk is a fatal
+     * `SYNTH_UNSUPPORTED_QUIRK`, never a silent no-op).
+     */
+    readonly quirks?: readonly string[];
+}
+/** A frozen, validated fixture recipe produced by {@link defineSynthProfile}. */
+interface SynthProfile {
+    /** The profile name. */
+    readonly name: string;
+    /** The given-name pool this profile draws from (overrides or the built-in default). */
+    readonly givenNames?: readonly string[];
+    /** The family-name pool this profile draws from. */
+    readonly familyNames?: readonly string[];
+    /** The requested quirk recipe names. */
+    readonly quirks: readonly string[];
+}
+/**
+ * Define a reusable, frozen synthetic-fixture profile.
+ *
+ * @param spec - The profile spec; `name` is required and non-empty.
+ * @returns A deep-frozen {@link SynthProfile}.
+ * @throws TypeError when `name` is missing or blank.
+ * @example
+ * ```ts
+ * import { defineSynthProfile } from "@cosyte/synth";
+ * const acme = defineSynthProfile({ name: "acme-hospital", quirks: [] });
+ * ```
+ */
+declare function defineSynthProfile(spec: SynthProfileSpec): SynthProfile;
+
+/**
+ * The **quirk core**. Where the spec-clean generators prove
+ * *synthetic-by-construction* through each parser's own builder, the quirk layer proves the mirror
+ * property: a **deliberately off-spec** fixture round-trips to **exactly the intended parser warning
+ * code(s)** — no more, no fewer. The quirk vocabulary **is the parsers' own profile systems**
+ * (`hl7.defineProfile`, `ccda.defineCcdaProfile`, `astm.defineAstmProfile`): a quirk exercises exactly
+ * the tolerance the corresponding parser profile encodes, so a quirk fixture is never a fiction — it
+ * targets a documented, coded leniency (the **intended-warning contract**).
+ *
+ * This module is the **format-agnostic** part: the descriptor a quirk carries, the artifact a quirk
+ * generator returns, the round-trip verdict shape, and the `SYNTH_UNSUPPORTED_QUIRK` fail-closed. Each
+ * format's concrete quirk recipes + transforms live behind its own subpath (`@cosyte/synth/hl7`, …).
+ *
+ * @module
+ */
+
+/**
+ * How the parser's matching profile treats a quirk once it is active — the three shapes the parsers'
+ * profile systems actually exhibit (verified firsthand against each parser):
+ *
+ * - `"suppressed"` — the profile makes the warning **disappear** (HL7 v2: a `defineProfile`
+ *   `customSegments` claim suppresses `UNKNOWN_SEGMENT` for a declared Z-segment).
+ * - `"rebadged"` — the profile **downgrades** the warning to the value-free `PROFILE_QUIRK_APPLIED`
+ *   marker with `expected: true` (C-CDA `defineCcdaProfile` / ASTM `defineAstmProfile`
+ *   `profileQuirkApplied`).
+ * - `"bare"` — no shipped profile tolerates it; the quirk targets a real coded leniency a consumer can
+ *   tolerate via their own `defineProfile`/`defineAstmProfile`, but no built-in re-badges it.
+ */
+type QuirkProfileDisposition = "suppressed" | "rebadged" | "bare";
+/**
+ * The stable, value-free re-badge code the C-CDA and ASTM parsers emit when a profile tolerates a
+ * quirk. HL7 v2 has no equivalent (it suppresses instead — see {@link QuirkProfileDisposition}).
+ */
+declare const PROFILE_QUIRK_APPLIED = "PROFILE_QUIRK_APPLIED";
+/**
+ * A public, grounded description of one vendor quirk — the metadata that binds a quirk recipe to a real
+ * parser warning code and a **publicly-groundable** deviation (cited-public, never a private
+ * vendor corpus).
+ */
+interface QuirkDescriptor {
+    /** The quirk recipe name (e.g. `"unknown-zsegment"`). Stable; part of the public contract. */
+    readonly name: string;
+    /** The format this quirk applies to. */
+    readonly format: SynthFormat;
+    /**
+     * The **exact** parser warning code(s) a bare parse (no profile) surfaces for this quirk — the
+     * intended-warning contract. A quirk that produces any other code, or none, is a generation bug.
+     */
+    readonly intendedWarnings: readonly string[];
+    /**
+     * The **public** grounding for this quirk — the spec clause or the parser's public profile that
+     * documents the tolerance. Never a private vendor-attributed corpus.
+     */
+    readonly grounding: string;
+    /** The parser profile that tolerates this quirk (when a built-in public one exists). */
+    readonly toleratingProfile?: string;
+    /** How {@link toleratingProfile} treats the quirk. */
+    readonly disposition: QuirkProfileDisposition;
+}
+/** One generated quirk artifact — the off-spec wire text plus the contract it is meant to satisfy. */
+interface QuirkArtifact {
+    /** The format this artifact belongs to. */
+    readonly format: SynthFormat;
+    /** The quirk recipe applied. */
+    readonly quirk: string;
+    /** The underlying spec-clean message kind the quirk was injected into (e.g. `"ORU^R01"`). */
+    readonly kind: string;
+    /** The **quirked** wire text (deterministic in the seed + quirk). */
+    readonly content: string;
+    /** The exact parser warning code(s) this artifact is meant to round-trip to. */
+    readonly intendedWarnings: readonly string[];
+}
+/** The verdict of a bare parse under the tolerating profile, if any. */
+interface QuirkProfiledVerdict {
+    /** The profile applied. */
+    readonly profileName: string;
+    /** How the profile treats the quirk. */
+    readonly disposition: QuirkProfileDisposition;
+    /** The warning codes the parser emitted with the profile active. */
+    readonly warnings: readonly string[];
+    /**
+     * `true` iff the profile handled the quirk as its disposition declares: `"suppressed"` ⇒ the intended
+     * code is gone; `"rebadged"` ⇒ the intended code is gone and `PROFILE_QUIRK_APPLIED` is present.
+     */
+    readonly tolerated: boolean;
+}
+/** The verdict of round-tripping a quirk artifact through its parser. */
+interface QuirkRoundTripResult {
+    /** The quirked wire text that was parsed. */
+    readonly content: string;
+    /** The warning codes a **bare** parse (no profile) emitted. */
+    readonly warnings: readonly string[];
+    /** The exact code(s) the quirk is meant to produce. */
+    readonly intendedWarnings: readonly string[];
+    /**
+     * `true` iff the bare parse produced **exactly** the intended code(s) — the intended-warning contract.
+     */
+    readonly intendedWarningHeld: boolean;
+    /** The verdict under the tolerating profile, when a built-in public one exists. */
+    readonly withProfile?: QuirkProfiledVerdict;
+}
+/**
+ * Exact multiset (order-independent) equality of two code lists — the intended-warning comparison.
+ *
+ * @param a - The first code list.
+ * @param b - The second code list.
+ * @returns `true` iff the two lists contain the same codes with the same multiplicities.
+ * @example
+ * ```ts
+ * import { sameCodeSet } from "@cosyte/synth";
+ * sameCodeSet(["A", "B"], ["B", "A"]); // true
+ * ```
+ */
+declare function sameCodeSet(a: readonly string[], b: readonly string[]): boolean;
+/**
+ * Resolve a requested quirk name against a format's registry, or **fail closed**. A quirk the format's
+ * profile system does not support is a fatal `SYNTH_UNSUPPORTED_QUIRK` — never a silent no-op and never
+ * a fabricated quirk with a made-up warning.
+ *
+ * @param registry - The format's quirk descriptors, keyed by name.
+ * @param format - The format being generated (for the error message).
+ * @param name - The requested quirk name.
+ * @returns The matching {@link QuirkDescriptor}.
+ * @throws SynthError with code `SYNTH_UNSUPPORTED_QUIRK` when `name` is not a supported quirk.
+ * @example
+ * ```ts
+ * import { resolveQuirk } from "@cosyte/synth";
+ * import { HL7_QUIRKS } from "@cosyte/synth/hl7";
+ * resolveQuirk(HL7_QUIRKS, "hl7v2", "unknown-zsegment").intendedWarnings; // ["UNKNOWN_SEGMENT"]
+ * ```
+ */
+declare function resolveQuirk(registry: Readonly<Record<string, QuirkDescriptor>>, format: SynthFormat, name: string): QuirkDescriptor;
+/**
+ * Evaluate whether a profiled parse tolerated a quirk as its disposition declares. Shared across the
+ * formats so the "suppressed vs re-badged" logic lives in exactly one place.
+ *
+ * @param disposition - The quirk's declared profile disposition.
+ * @param intendedWarnings - The bare-parse intended code(s).
+ * @param warningsUnderProfile - The code(s) the parser emitted with the profile active.
+ * @returns `true` iff the profile handled the quirk correctly for its disposition.
+ * @example
+ * ```ts
+ * import { profileTolerated } from "@cosyte/synth";
+ * profileTolerated("suppressed", ["UNKNOWN_SEGMENT"], []); // true — the profile suppressed it
+ * ```
+ */
+declare function profileTolerated(disposition: QuirkProfileDisposition, intendedWarnings: readonly string[], warningsUnderProfile: readonly string[]): boolean;
+/**
+ * Assert a freshly-generated quirk artifact **actually** round-trips to its intended warning(s), or
+ * **fail closed**. This is the generator's self-check on the intended-warning contract: a
+ * fixture whose bare parse does not produce exactly the declared code(s) is a *mislabeled* fixture — a
+ * golden file that lies about the parser verdict it anchors — and must never be emitted. It is a
+ * stronger guard than "the transform changed some bytes": a transform can mutate the wrong element (a
+ * template a given document type does not key its warning on) and still change bytes while producing no
+ * warning. Every format's `generate*Quirk` calls this after transforming, so the contract is enforced at
+ * generation time, not merely at round-trip time.
+ *
+ * @param quirk - The quirk name (for the error message).
+ * @param intendedWarnings - The declared intended code(s).
+ * @param bareWarnings - The code(s) a bare parse of the generated artifact actually produced.
+ * @throws Error when the bare parse did not produce exactly the intended code(s).
+ * @example
+ * ```ts
+ * import { assertIntendedWarnings } from "@cosyte/synth";
+ * assertIntendedWarnings("unknown-zsegment", ["UNKNOWN_SEGMENT"], ["UNKNOWN_SEGMENT"]); // ok
+ * ```
+ */
+declare function assertIntendedWarnings(quirk: string, intendedWarnings: readonly string[], bareWarnings: readonly string[]): void;
+/**
+ * Validate the quirk names carried by a {@link SynthProfile} against a format's registry, failing closed
+ * on the first unsupported one. Lets a consumer author a fixture recipe with `defineSynthProfile` and
+ * have its quirks checked against the *parser's* real tolerance before any fixture is generated.
+ *
+ * @param profile - The synth profile whose `quirks` to validate.
+ * @param registry - The format's quirk descriptors.
+ * @param format - The format being generated.
+ * @returns The validated quirk names (the profile's, in order).
+ * @throws SynthError `SYNTH_UNSUPPORTED_QUIRK` for the first unsupported quirk.
+ * @example
+ * ```ts
+ * import { validateProfileQuirks, defineSynthProfile } from "@cosyte/synth";
+ * import { HL7_QUIRKS } from "@cosyte/synth/hl7";
+ * const p = defineSynthProfile({ name: "site", quirks: ["unknown-zsegment"] });
+ * validateProfileQuirks(p, HL7_QUIRKS, "hl7v2"); // ["unknown-zsegment"]
+ * ```
+ */
+declare function validateProfileQuirks(profile: SynthProfile, registry: Readonly<Record<string, QuirkDescriptor>>, format: SynthFormat): readonly string[];
+
+export { PROFILE_QUIRK_APPLIED as P, type QuirkDescriptor as Q, type SynthProfile as S, type QuirkArtifact as a, type QuirkRoundTripResult as b, type QuirkProfileDisposition as c, type QuirkProfiledVerdict as d, type SynthProfileSpec as e, assertIntendedWarnings as f, defineSynthProfile as g, profileTolerated as p, resolveQuirk as r, sameCodeSet as s, validateProfileQuirks as v };