@cosyte/synth 0.0.1

package/dist/deid/index.d.ts

@@ -0,0 +1,464 @@
+import { Hl7MessageKind } from '../hl7/index.js';
+import { DeidPolicy, GenericLocus } from '@cosyte/deid';
+import '@cosyte/hl7';
+import '../providers-OLz3zAc-.js';
+import '../quirk-JLyO1Ncj.js';
+
+/**
+ * The format-agnostic core of the **`@cosyte/deid` pairing loop** — a **closed-loop
+ * co-validation harness** for the `synth` ⇄ `deid` pair.
+ *
+ * The loop's shape is: **generate a spec-clean synthetic artifact → enumerate the distinctive synthetic
+ * PHI sentinels `@cosyte/synth` planted at its patient loci → run it through `@cosyte/deid` → verify
+ * every planted sentinel is gone from the de-identified output** (a surviving sentinel is a hard
+ * failure), **and that the non-PHI clinical content survived** (the over-scrub guard). It is
+ * deterministic and seeded, and it does **not** change what the generators emit — it consumes their
+ * output.
+ *
+ * **Honesty line (governs the whole module).** This is a **co-validation harness**, not an independent
+ * audit of `@cosyte/deid` against real-world data. It proves *the pair works on `synth`'s own output*:
+ * that the synthetic PHI `synth` plants at the patient loci is removed by `deid`, and that `deid` does
+ * not over-scrub `synth`'s clinical payload. A sentinel that `deid` **blocks** rather than redacts still
+ * passes the removal check (blocked = gone from the wire). Formats where `@cosyte/deid` ships no adapter
+ * (NCPDP **SCRIPT**, **ASTM**) — and DICOM, which `synth` does not generate — are **skipped and named**
+ * (see `DEID_LOOP_SKIPPED` in `./index`), never silently.
+ *
+ * This module holds only the pure, parser-free pieces (the policy, the sentinel model, the sweep, the
+ * over-scrub check, the verdict). The per-format loops that drive the generators and the `deid` adapters
+ * live in `./index`.
+ *
+ * @module
+ */
+
+/**
+ * The set of cosyte formats the loop covers — every format for which **both** `@cosyte/synth` generates
+ * and `@cosyte/deid` ships an adapter.
+ */
+type DeidLoopFormat = "hl7" | "fhir" | "ccda" | "x12" | "ncpdp-telecom";
+/**
+ * A single **planted sentinel**: one distinctive, synthetic-by-construction PHI token that
+ * `@cosyte/synth` placed at a patient locus of a generated artifact, tracked so the loop can prove
+ * `@cosyte/deid` removed it. The token is always drawn from a synthetic-safety provider —
+ * a fake-name-pool name, a `900`-range SSN, a `555-01xx` phone, a synthetic-assigning-authority
+ * identifier — so a sentinel can never be, or collide with, a real person's PHI.
+ *
+ * @example
+ * ```ts
+ * const s: DeidSentinel = { token: "Examplewood", locus: "PID-5", category: "names" };
+ * ```
+ */
+interface DeidSentinel {
+    /** The exact synthetic token planted at the locus — a literal substring of the spec-clean artifact. */
+    readonly token: string;
+    /** Where it lives — a format-neutral path (e.g. `"PID-5"`, `"recordTarget"`, `"NM1[0]-3"`). */
+    readonly locus: string;
+    /** The Safe Harbor category `@cosyte/deid` assigned to the locus, when known. */
+    readonly category?: string;
+}
+/**
+ * The verdict of one pass through the pairing loop for one artifact.
+ *
+ * `pass` is `true` **iff** at least one sentinel was planted, **no** planted sentinel survived
+ * de-identification, and **no** probed clinical value was over-scrubbed.
+ *
+ * @example
+ * ```ts
+ * import { hl7DeidLoop } from "@cosyte/synth/deid";
+ * const r = hl7DeidLoop({ seed: 42 });
+ * r.pass;            // => true
+ * r.survivors.length; // => 0
+ * ```
+ */
+interface DeidLoopResult {
+    /** The covered format. */
+    readonly format: DeidLoopFormat;
+    /** The concrete artifact label (e.g. `"ORU^R01"`, `"837P"`, `"CCD"`). */
+    readonly artifact: string;
+    /** The seed — the same seed yields the same artifact and the same verdict. */
+    readonly seed: number;
+    /** Every distinctive synthetic PHI sentinel `synth` planted at a patient locus of the artifact. */
+    readonly planted: readonly DeidSentinel[];
+    /** Planted sentinels still present in the de-identified output — **must be empty**. */
+    readonly survivors: readonly DeidSentinel[];
+    /** The non-PHI clinical code tokens probed for over-scrub (present in the spec-clean artifact). */
+    readonly clinicalProbed: readonly string[];
+    /** Probed clinical tokens missing after de-identification (over-scrub) — **must be empty**. */
+    readonly clinicalScrubbed: readonly string[];
+    /** The spec-clean serialized artifact (before de-identification). */
+    readonly original: string;
+    /** The serialized de-identified artifact (`@cosyte/deid`'s output). */
+    readonly deidentified: string;
+    /** `true` iff sentinels were planted, none survived, and nothing clinical was over-scrubbed. */
+    readonly pass: boolean;
+}
+/**
+ * The name of the removal-oriented policy the loop runs `@cosyte/deid` under.
+ *
+ * @example
+ * ```ts
+ * import { DEID_LOOP_POLICY_NAME } from "@cosyte/synth/deid";
+ * DEID_LOOP_POLICY_NAME; // => "synth-deid-loop-removal"
+ * ```
+ */
+declare const DEID_LOOP_POLICY_NAME = "synth-deid-loop-removal";
+/**
+ * Build the **removal-oriented** de-identification policy the loop runs `@cosyte/deid` under: HIPAA Safe
+ * Harbor, but with the three keyed-by-default identifier categories (MRN, health-plan-beneficiary,
+ * account) switched from `pseudonymize` to `redact`.
+ *
+ * Two reasons this is the right policy for a co-validation loop: (1) it needs **no key context**, so the
+ * loop is a pure function of the seed (the default Safe Harbor policy pseudonymizes those three
+ * categories, which requires the consumer's HMAC key); and (2) it makes the removal contract crisp —
+ * every PHI locus is **removed or generalized away**, never replaced by a surrogate that a naive sweep
+ * might mistake for a survivor. `pseudonymize` also removes the original value, so this is a stricter,
+ * not weaker, check.
+ *
+ * @returns A frozen {@link DeidPolicy} suitable for the `policy` option of any `@cosyte/deid` adapter.
+ * @example
+ * ```ts
+ * import { deidLoopPolicy } from "@cosyte/synth/deid";
+ * import { deidentifyHl7 } from "@cosyte/deid/hl7";
+ * const { document } = deidentifyHl7(msg, { policy: deidLoopPolicy() });
+ * ```
+ */
+declare function deidLoopPolicy(): DeidPolicy;
+/**
+ * Enumerate the distinctive synthetic PHI sentinels from a de-identifier's **patient-scoped**
+ * identifier loci, decomposed to **literal** tokens of the spec-clean artifact.
+ *
+ * The loci come from `@cosyte/deid`'s own per-format extractor (`extractHl7Loci` / `extractFhirLoci` /
+ * `extractX12Loci` / `extractTelecomLoci`), which locates PHI **structurally** — so provider and
+ * organization names, which a de-identifier legitimately retains, are never extracted and never become
+ * false sentinels. Only `identifier`-kind loci are used (names, SSNs, phones, emails, member/account
+ * ids); dates (generalized to a year, not removed) and ZIPs (generalized to three digits) are handled by
+ * the format's own contract, not asserted here.
+ *
+ * Requiring each token to be a **literal substring of `original`** keeps the removal check non-vacuous:
+ * a sentinel the sweep later looks for is one that is provably present before de-identification.
+ *
+ * @param loci - The located candidate values from a `@cosyte/deid` extractor.
+ * @param original - The spec-clean serialized artifact the loci were extracted from.
+ * @returns The distinctive, literal, synthetic PHI sentinels — de-duplicated by token.
+ * @example
+ * ```ts
+ * import { extractHl7Loci } from "@cosyte/deid/hl7";
+ * const sentinels = identifierSentinels(extractHl7Loci(msg).loci, msg.toString());
+ * ```
+ */
+declare function identifierSentinels(loci: readonly GenericLocus[], original: string): readonly DeidSentinel[];
+/**
+ * Enumerate the patient sentinels of a **C-CDA** document by reading the `<recordTarget>` element of the
+ * serialized XML — the patient participation. Scoping to `recordTarget` (rather than `author` /
+ * `custodian`, which carry provider identity a de-identifier retains) is what keeps the sentinels
+ * patient-PHI only. Used for C-CDA because `@cosyte/deid`'s C-CDA extractor operates on a raw DOM, which
+ * this zero-dependency module does not construct.
+ *
+ * @param xml - The serialized spec-clean C-CDA document.
+ * @returns The distinctive synthetic patient sentinels (given/family names, the patient id extensions).
+ * @example
+ * ```ts
+ * import { serializeCcda } from "@cosyte/ccda";
+ * const sentinels = recordTargetSentinels(serializeCcda(generateCcd({ seed: 1 })));
+ * ```
+ */
+declare function recordTargetSentinels(xml: string): readonly DeidSentinel[];
+/**
+ * Sweep the **PHI-locus residue** of a de-identified artifact for **surviving** planted sentinels — the
+ * heart of the removal check. A sentinel survives if its exact token still appears in the values that
+ * remain at the (former) PHI loci after de-identification; a non-empty result is a **hard failure** (real
+ * PHI-shaped data leaked through de-identification).
+ *
+ * **Why the PHI-locus residue and not the whole document.** `@cosyte/synth` draws patient *and*
+ * provider/organization names, addresses, and phones from the same synthetic pools, and a de-identifier
+ * legitimately **retains** provider identity. So the same synthetic token can sit at both a patient locus
+ * (removed) and a provider locus (retained); a whole-document sweep would read the retained provider copy
+ * as a false survivor. Sweeping only the residue at the loci that were PHI — re-read from the
+ * de-identifier's own output — is locus-scoped and collision-proof: a token still present *there* is a
+ * genuine leak. It remains independent of the de-identifier's manifest: it reads the actual serialized
+ * output, so a de-identifier that locates a locus but fails to strip it is still caught.
+ *
+ * @param phiResidue - The de-identified values that remain at the former PHI loci (for the model formats,
+ *   the re-extracted identifier-locus values joined; for C-CDA, the de-identified `<recordTarget>` block).
+ * @param sentinels - The sentinels planted in the corresponding spec-clean artifact.
+ * @returns The subset of `sentinels` still present in `phiResidue` — empty on a clean pass.
+ * @example
+ * ```ts
+ * sweepSurvivors(deidPhiResidue, planted); // => []  (all removed)
+ * ```
+ */
+declare function sweepSurvivors(phiResidue: string, sentinels: readonly DeidSentinel[]): readonly DeidSentinel[];
+/**
+ * The over-scrub side of the loop: of the clinical (non-PHI) code tokens that appear in the spec-clean
+ * artifact, which are **missing** after de-identification. A de-identifier must keep clinical content; a
+ * non-empty result means it over-scrubbed. Only structured code tokens present before de-identification
+ * are probed (a code that appears solely inside a free-text narrative a de-identifier legitimately blocks
+ * is not a structured-content loss).
+ *
+ * Only **distinctive** codes (four or more characters) are probed: a short 2–3 digit code (e.g. a CVX
+ * vaccine code) can appear by coincidence *inside* a PHI value a de-identifier removes — a timestamp, an
+ * SSN — and would read as a false over-scrub. Distinctive codes (LOINC `4548-4`, SNOMED `44054006`,
+ * 11-digit NDCs, CPT `99213`) do not collide this way. An artifact whose clinical codes are all short
+ * simply yields an empty probe (the guard is skipped, never falsely tripped).
+ *
+ * @param original - The spec-clean serialized artifact.
+ * @param deidentified - The serialized de-identified artifact.
+ * @param clinicalCodes - Candidate structured clinical code tokens (e.g. LOINC/ICD/NDC from the example
+ *   pools) to probe.
+ * @returns `{ probed, scrubbed }` — the distinctive codes present before, and the subset absent after.
+ * @example
+ * ```ts
+ * const { probed, scrubbed } = clinicalRetention(before, after, ["4548-4", "44054006"]);
+ * scrubbed; // => []  (clinical content retained)
+ * ```
+ */
+declare function clinicalRetention(original: string, deidentified: string, clinicalCodes: readonly string[]): {
+    readonly probed: readonly string[];
+    readonly scrubbed: readonly string[];
+};
+/**
+ * Assemble a {@link DeidLoopResult} from the planted sentinels, the de-identified output, and the
+ * clinical probe — computing the `pass` verdict (sentinels planted, none survived, nothing over-scrubbed).
+ *
+ * @param parts - The pieces gathered by a per-format loop.
+ * @returns The immutable verdict.
+ * @example
+ * ```ts
+ * const result = assembleVerdict({
+ *   format: "hl7", artifact: "ORU^R01", seed: 1,
+ *   planted, original, deidentified, clinicalCodes,
+ * });
+ * ```
+ */
+declare function assembleVerdict(parts: {
+    readonly format: DeidLoopFormat;
+    readonly artifact: string;
+    readonly seed: number;
+    readonly planted: readonly DeidSentinel[];
+    readonly original: string;
+    readonly deidentified: string;
+    /**
+     * The de-identified values that remain at the former PHI loci — what the survivor sweep reads (see
+     * {@link sweepSurvivors}). Defaults to `deidentified` when omitted (a whole-document sweep), but the
+     * per-format loops supply the locus-scoped residue so provider/organization identity a de-identifier
+     * legitimately retains never reads as a false survivor.
+     */
+    readonly phiResidue?: string;
+    readonly clinicalCodes: readonly string[];
+}): DeidLoopResult;
+
+/**
+ * `@cosyte/synth/deid` — the **`@cosyte/deid` pairing loop**: a deterministic,
+ * seeded **co-validation harness** for the `synth` ⇄ `deid` pair.
+ *
+ * For each covered format it **generates** a spec-clean synthetic artifact through `@cosyte/synth`'s own
+ * generators, **enumerates** the distinctive synthetic PHI sentinels planted at the patient loci,
+ * **de-identifies** it through `@cosyte/deid`, and **verifies** that every planted sentinel is gone from
+ * the de-identified output while the clinical payload survives. A surviving sentinel is a hard failure;
+ * an over-scrubbed clinical value is a hard failure.
+ *
+ * **Scope & honesty.** This proves *the pair works on `synth`'s own output* — it
+ * is **not** an independent audit of `@cosyte/deid` against real-world documents. The sentinels are
+ * synthetic-by-construction (never realistic); a sentinel `deid` **blocks** rather than redacts still
+ * passes (blocked = gone). The loop covers the five formats both packages support
+ * ({@link DEID_LOOP_COVERED_FORMATS}); NCPDP **SCRIPT**, **ASTM**, and **DICOM** are **skipped and
+ * named** ({@link DEID_LOOP_SKIPPED}), never silently. `@cosyte/deid` is an **optional peer dependency**
+ * (the `mllp`/`ncpdp` vendoring pattern); importing this subpath pulls it in.
+ *
+ * @module
+ */
+
+/**
+ * The cosyte formats the pairing loop covers — every format for which **both** `@cosyte/synth`
+ * generates and `@cosyte/deid` ships an adapter.
+ *
+ * @example
+ * ```ts
+ * import { DEID_LOOP_COVERED_FORMATS } from "@cosyte/synth/deid";
+ * DEID_LOOP_COVERED_FORMATS; // ["hl7","fhir","ccda","x12","ncpdp-telecom"]
+ * ```
+ */
+declare const DEID_LOOP_COVERED_FORMATS: readonly ["hl7", "fhir", "ccda", "x12", "ncpdp-telecom"];
+/**
+ * The format paths the loop **deliberately skips**, each with the honest reason — so a coverage gap is
+ * named, never silent.
+ *
+ * @example
+ * ```ts
+ * import { DEID_LOOP_SKIPPED } from "@cosyte/synth/deid";
+ * DEID_LOOP_SKIPPED.map((s) => s.format); // ["ncpdp-script","astm","dicom"]
+ * ```
+ */
+declare const DEID_LOOP_SKIPPED: readonly [Readonly<{
+    format: "ncpdp-script";
+    reason: "@cosyte/deid ships no NCPDP SCRIPT locus map; synth generates SCRIPT but the loop cannot pair it.";
+}>, Readonly<{
+    format: "astm";
+    reason: "@cosyte/deid ships no ASTM adapter; synth generates ASTM but the loop cannot pair it.";
+}>, Readonly<{
+    format: "dicom";
+    reason: "@cosyte/synth does not generate DICOM, so there is nothing to pair.";
+}>];
+/** Options accepted by {@link hl7DeidLoop}. */
+interface Hl7DeidLoopOptions {
+    /** The seed — the same seed yields the same artifact and the same verdict. Defaults to `0`. */
+    readonly seed?: number;
+    /** The HL7 v2 message family to generate. Defaults to `"ORU^R01"` (a PHI- and clinically-dense report). */
+    readonly kind?: Hl7MessageKind;
+}
+/**
+ * Run the pairing loop for **HL7 v2**: generate a spec-clean message through `@cosyte/hl7`'s builder,
+ * plant PHI sentinels at the `PID`, de-identify through `@cosyte/deid/hl7`, and verify removal +
+ * clinical retention.
+ *
+ * @param options - The seed and message family. See {@link Hl7DeidLoopOptions}.
+ * @returns The {@link DeidLoopResult} for the message.
+ * @example
+ * ```ts
+ * import { hl7DeidLoop } from "@cosyte/synth/deid";
+ * const { pass, survivors } = hl7DeidLoop({ seed: 42, kind: "ORU^R01" });
+ * // pass === true, survivors.length === 0
+ * ```
+ */
+declare function hl7DeidLoop(options?: Hl7DeidLoopOptions): DeidLoopResult;
+/** Options accepted by {@link fhirDeidLoop}. */
+interface FhirDeidLoopOptions {
+    /** The seed. Defaults to `0`. */
+    readonly seed?: number;
+}
+/**
+ * Run the pairing loop for **FHIR R4**: generate a spec-clean `Bundle` (US-Core `Patient` + a clinical
+ * spine) through `@cosyte/fhir`'s model, plant PHI sentinels at the `Patient` demographics, de-identify
+ * through `@cosyte/deid/fhir`, and verify removal + clinical retention. A `Bundle` (not a bare
+ * `Patient`) is used so there is clinical content to prove is **not** over-scrubbed.
+ *
+ * @param options - The seed. See {@link FhirDeidLoopOptions}.
+ * @returns The {@link DeidLoopResult} for the bundle.
+ * @example
+ * ```ts
+ * import { fhirDeidLoop } from "@cosyte/synth/deid";
+ * fhirDeidLoop({ seed: 7 }).pass; // => true
+ * ```
+ */
+declare function fhirDeidLoop(options?: FhirDeidLoopOptions): DeidLoopResult;
+/** The X12 transaction families the loop can pair. */
+type X12DeidVariant = "837P" | "837I" | "837D" | "271" | "835";
+/** Options accepted by {@link x12DeidLoop}. */
+interface X12DeidLoopOptions {
+    /** The seed. Defaults to `0`. */
+    readonly seed?: number;
+    /** The transaction family. Defaults to `"837P"`. */
+    readonly variant?: X12DeidVariant;
+}
+/**
+ * Run the pairing loop for **X12 005010**: generate a spec-clean transaction through `@cosyte/x12`'s
+ * builders, plant PHI sentinels across the subscriber/patient loops, de-identify through
+ * `@cosyte/deid/x12`, and verify removal + clinical retention.
+ *
+ * @param options - The seed and transaction family. See {@link X12DeidLoopOptions}.
+ * @returns The {@link DeidLoopResult} for the transaction.
+ * @example
+ * ```ts
+ * import { x12DeidLoop } from "@cosyte/synth/deid";
+ * x12DeidLoop({ seed: 1, variant: "837P" }).survivors; // => []
+ * ```
+ */
+declare function x12DeidLoop(options?: X12DeidLoopOptions): DeidLoopResult;
+/** The NCPDP Telecom transactions the loop can pair. */
+type NcpdpTelecomVariant = "B1" | "B2" | "B3";
+/** Options accepted by {@link ncpdpTelecomDeidLoop}. */
+interface NcpdpTelecomDeidLoopOptions {
+    /** The seed. Defaults to `0`. */
+    readonly seed?: number;
+    /** The Telecom transaction. Defaults to `"B1"` (a claim, the PHI- and clinically-densest). */
+    readonly transaction?: NcpdpTelecomVariant;
+}
+/**
+ * Run the pairing loop for **NCPDP Telecom** (pharmacy claims): generate a spec-clean transaction
+ * through `@cosyte/ncpdp`, plant PHI sentinels at the patient/cardholder segments, de-identify through
+ * `@cosyte/deid/ncpdp`, and verify removal + clinical retention. **NCPDP SCRIPT is out of scope** —
+ * `@cosyte/deid` ships no SCRIPT adapter ({@link DEID_LOOP_SKIPPED}).
+ *
+ * @param options - The seed and transaction. See {@link NcpdpTelecomDeidLoopOptions}.
+ * @returns The {@link DeidLoopResult} for the transaction.
+ * @example
+ * ```ts
+ * import { ncpdpTelecomDeidLoop } from "@cosyte/synth/deid";
+ * ncpdpTelecomDeidLoop({ seed: 3, transaction: "B1" }).pass; // => true
+ * ```
+ */
+declare function ncpdpTelecomDeidLoop(options?: NcpdpTelecomDeidLoopOptions): DeidLoopResult;
+/** The C-CDA document types the loop can pair. */
+type CcdaDeidDocumentType = "ccd" | "referral";
+/** Options accepted by {@link ccdaDeidLoop}. */
+interface CcdaDeidLoopOptions {
+    /** The seed. Defaults to `0`. */
+    readonly seed?: number;
+    /** The document type. Defaults to `"ccd"`. */
+    readonly documentType?: CcdaDeidDocumentType;
+}
+/**
+ * Run the pairing loop for **C-CDA R2.1**: generate a spec-clean document through `@cosyte/ccda`'s
+ * `buildCcda`, plant PHI sentinels at the `recordTarget` patient participation, de-identify through
+ * `@cosyte/deid/ccda`, and verify removal + clinical retention.
+ *
+ * Sentinels are read from the `<recordTarget>` element of the serialized XML (not `@cosyte/deid`'s DOM
+ * extractor) so that this zero-dependency subpath constructs no XML DOM; scoping to `recordTarget` keeps
+ * the sentinels patient-PHI only (`author`/`custodian` provider identity is legitimately retained).
+ *
+ * @param options - The seed and document type. See {@link CcdaDeidLoopOptions}.
+ * @returns The {@link DeidLoopResult} for the document.
+ * @example
+ * ```ts
+ * import { ccdaDeidLoop } from "@cosyte/synth/deid";
+ * ccdaDeidLoop({ seed: 5, documentType: "ccd" }).survivors; // => []
+ * ```
+ */
+declare function ccdaDeidLoop(options?: CcdaDeidLoopOptions): DeidLoopResult;
+/** A per-format row of a {@link DeidCoverageSummary}. */
+interface DeidCoverageRow {
+    /** The covered format. */
+    readonly format: string;
+    /** The concrete artifacts run for this format. */
+    readonly artifacts: readonly string[];
+    /** Total distinctive PHI sentinels planted across the runs. */
+    readonly planted: number;
+    /** Total surviving sentinels — **0** on a clean pass. */
+    readonly survivors: number;
+    /** Total clinical tokens probed for over-scrub. */
+    readonly clinicalProbed: number;
+    /** Total clinical tokens over-scrubbed — **0** on a clean pass. */
+    readonly clinicalScrubbed: number;
+    /** `true` iff every run for this format passed. */
+    readonly pass: boolean;
+}
+/** The aggregate coverage summary across a set of loop runs. */
+interface DeidCoverageSummary {
+    /** One row per format. */
+    readonly byFormat: readonly DeidCoverageRow[];
+    /** Total sentinels planted across every run. */
+    readonly totalPlanted: number;
+    /** Total surviving sentinels across every run — **0** on a clean pass. */
+    readonly totalSurvivors: number;
+    /** Total clinical over-scrubs across every run — **0** on a clean pass. */
+    readonly totalClinicalScrubbed: number;
+    /** `true` iff every run passed. */
+    readonly allPass: boolean;
+    /** The named, deliberately-skipped format paths (from {@link DEID_LOOP_SKIPPED}). */
+    readonly skipped: typeof DEID_LOOP_SKIPPED;
+}
+/**
+ * Summarize a set of loop runs into a per-format coverage report — the "coverage summary per format" the
+ * harness reports.
+ *
+ * @param results - The loop results to aggregate.
+ * @returns The {@link DeidCoverageSummary}.
+ * @example
+ * ```ts
+ * import { hl7DeidLoop, fhirDeidLoop, summarizeDeidCoverage } from "@cosyte/synth/deid";
+ * const summary = summarizeDeidCoverage([hl7DeidLoop(), fhirDeidLoop()]);
+ * summary.allPass; // => true
+ * ```
+ */
+declare function summarizeDeidCoverage(results: readonly DeidLoopResult[]): DeidCoverageSummary;
+
+export { type CcdaDeidDocumentType, type CcdaDeidLoopOptions, DEID_LOOP_COVERED_FORMATS, DEID_LOOP_POLICY_NAME, DEID_LOOP_SKIPPED, type DeidCoverageRow, type DeidCoverageSummary, type DeidLoopFormat, type DeidLoopResult, type DeidSentinel, type FhirDeidLoopOptions, type Hl7DeidLoopOptions, type NcpdpTelecomDeidLoopOptions, type NcpdpTelecomVariant, type X12DeidLoopOptions, type X12DeidVariant, assembleVerdict, ccdaDeidLoop, clinicalRetention, deidLoopPolicy, fhirDeidLoop, hl7DeidLoop, identifierSentinels, ncpdpTelecomDeidLoop, recordTargetSentinels, summarizeDeidCoverage, sweepSurvivors, x12DeidLoop };