@cosyte/x12 0.0.3 → 0.0.5

package/dist/index.d.ts

@@ -12,12 +12,35 @@ import { Buffer } from 'node:buffer';
  * (see `test/warning-codes.snapshot.test.ts`). Phase 2+ extends, never
  * renames.
  *
- * Warning messages NEVER echo field VALUES (matches the hl7 H-PHI invariant
- * locked in 2026-06). They carry positional context plus bounded metadata
- * (e.g. counts, expected-vs-actual control numbers) - never the raw bytes
- * the warning describes. The `snippet` on a fatal {@link
- * "./errors.js".X12ParseError} is the documented consumer-redaction
- * boundary; warnings have no snippet.
+ * ## A warning message is built from this registry, never from the document
+ *
+ * This is the load-bearing PHI invariant of the library, and it is enforced
+ * structurally rather than by review: **no factory in this file takes a
+ * value parameter.** Every factory takes an {@link X12Position} plus, where
+ * one code covers more than one situation, a library-owned discriminant
+ * ({@link X12ControlNumberPair}, {@link X12UnexpectedSegmentContext},
+ * {@link X12BalanceInvariant}, {@link X12RequiredLoop}). `message` is a
+ * lookup into a frozen table, so it cannot interpolate anything a sender
+ * controls no matter what the input contains.
+ *
+ * That is a deliberate change of shape. Earlier versions shape-validated an
+ * echoed value against a spec grammar and substituted `(non-spec)` when it
+ * did not match. That held for the code-list slots and did NOT hold for the
+ * six envelope control numbers, whose grammar is "whatever the trading
+ * partner sent": a `X12_CONTROL_NUMBER_MISMATCH` echoed both sides verbatim
+ * and unbounded. A shape test is a filter somebody has to remember to
+ * apply; taking no value at all is a property of the type signature.
+ *
+ * The values themselves are never discarded. Every one of them is preserved
+ * verbatim on the model (`isa.elements`, `seg.raw`,
+ * `adjustment.reasonCode`, and so on), which is where a consumer that has
+ * decided it may handle PHI goes to read them. The diagnostic says *what*
+ * is wrong and *where*; the model says what the bytes were.
+ *
+ * `X12ParseError.snippet` on a **Tier-3 fatal** is the one deliberate
+ * exception in the library, and it is bounded to 64 characters. Warnings
+ * have no `snippet`, and a strict-mode escalation of a warning carries none
+ * either. See `KNOWN-LIMITATIONS.md`.
  */
 
 /**
@@ -79,20 +102,163 @@ declare const WARNING_CODES: {
  * ```
  */
 type X12WarningCode = (typeof WARNING_CODES)[keyof typeof WARNING_CODES];
+/**
+ * Which header/trailer control-number pair disagreed. A library-owned
+ * discriminant, NOT a value read out of the document: the useful part of
+ * the diagnostic is that the two disagree and where each one sits, never
+ * what either one says.
+ *
+ * @example
+ * ```ts
+ * import { controlNumberMismatch, CONTROL_NUMBER_PAIRS } from "@cosyte/x12";
+ * const w = controlNumberMismatch({ segmentIndex: 6 }, CONTROL_NUMBER_PAIRS.INTERCHANGE);
+ * ```
+ */
+declare const CONTROL_NUMBER_PAIRS: {
+    /** ISA-13 against IEA-02. */
+    readonly INTERCHANGE: "interchange";
+    /** GS-06 against GE-02. */
+    readonly GROUP: "group";
+    /** ST-02 against SE-02. */
+    readonly TRANSACTION: "transaction";
+};
+/**
+ * String-literal union over {@link CONTROL_NUMBER_PAIRS}.
+ *
+ * @example
+ * ```ts
+ * import type { X12ControlNumberPair } from "@cosyte/x12";
+ * const pair: X12ControlNumberPair = "group";
+ * ```
+ */
+type X12ControlNumberPair = (typeof CONTROL_NUMBER_PAIRS)[keyof typeof CONTROL_NUMBER_PAIRS];
+/**
+ * Which structural rule an out-of-place segment broke. A closed,
+ * library-owned set. The segment's own id is deliberately NOT part of it:
+ * a segment that is not where it belongs is exactly the case where its
+ * first element is arbitrary sender bytes rather than a spec name.
+ *
+ * @example
+ * ```ts
+ * import { unexpectedSegment, UNEXPECTED_SEGMENT_CONTEXTS } from "@cosyte/x12";
+ * const w = unexpectedSegment({ segmentIndex: 12 }, UNEXPECTED_SEGMENT_CONTEXTS.GE_WITHOUT_GS);
+ * ```
+ */
+declare const UNEXPECTED_SEGMENT_CONTEXTS: {
+    /** A `TA1` (envelope-level by spec) appeared inside an open functional group. */
+    readonly TA1_INSIDE_GROUP: "ta1-inside-group";
+    /** A `GE` appeared with no open `GS`. */
+    readonly GE_WITHOUT_GS: "ge-without-gs";
+    /** An `ST` appeared with no open functional group. */
+    readonly ST_WITHOUT_GS: "st-without-gs";
+    /** An `SE` appeared with no open transaction set. */
+    readonly SE_WITHOUT_ST: "se-without-st";
+    /** A body segment appeared outside any open transaction set. */
+    readonly BODY_OUTSIDE_TRANSACTION: "body-outside-transaction";
+};
+/**
+ * String-literal union over {@link UNEXPECTED_SEGMENT_CONTEXTS}.
+ *
+ * @example
+ * ```ts
+ * import type { X12UnexpectedSegmentContext } from "@cosyte/x12";
+ * const ctx: X12UnexpectedSegmentContext = "se-without-st";
+ * ```
+ */
+type X12UnexpectedSegmentContext = (typeof UNEXPECTED_SEGMENT_CONTEXTS)[keyof typeof UNEXPECTED_SEGMENT_CONTEXTS];
+/**
+ * Which 835 balance invariant failed. A library-owned discriminant naming
+ * the TR3 equation. The amounts on either side stay on the model as
+ * `X12Decimal` and are never rendered into the message: an EDI amount is a
+ * consumer-controlled element like any other, and a 300,000-digit "amount"
+ * would otherwise become a 300,000-byte diagnostic.
+ *
+ * @example
+ * ```ts
+ * import { remitBalanceMismatch, BALANCE_INVARIANTS } from "@cosyte/x12";
+ * const w = remitBalanceMismatch({ segmentIndex: 12 }, BALANCE_INVARIANTS.CLAIM);
+ * ```
+ */
+declare const BALANCE_INVARIANTS: {
+    /** `CLP-04 + Σ(claim CAS + line CAS) == CLP-03`. */
+    readonly CLAIM: "claim";
+    /** `SVC-03 + Σ(line CAS) == SVC-02`. */
+    readonly SERVICE_LINE: "service-line";
+    /** `Σ(CLP-04) - Σ(PLB amounts) == BPR-02`. */
+    readonly REMIT_TOTAL: "remit-total";
+};
+/**
+ * String-literal union over {@link BALANCE_INVARIANTS}.
+ *
+ * @example
+ * ```ts
+ * import type { X12BalanceInvariant } from "@cosyte/x12";
+ * const which: X12BalanceInvariant = "service-line";
+ * ```
+ */
+type X12BalanceInvariant = (typeof BALANCE_INVARIANTS)[keyof typeof BALANCE_INVARIANTS];
+/**
+ * The TR3-required loops the parser reports as structurally absent. A
+ * closed set owned by the loop specs under `src/transactions/`, so both the
+ * loop id and its rationale are library constants rather than anything read
+ * out of the document.
+ *
+ * @example
+ * ```ts
+ * import { missingRequiredLoop, REQUIRED_LOOPS } from "@cosyte/x12";
+ * const w = missingRequiredLoop({ segmentIndex: 12 }, REQUIRED_LOOPS.PAYER_NAME_2010BB);
+ * ```
+ */
+declare const REQUIRED_LOOPS: {
+    /** Loop 2000A, Billing Provider HL. */
+    readonly BILLING_PROVIDER_2000A: "2000A";
+    /** Loop 2000B, Subscriber HL. */
+    readonly SUBSCRIBER_2000B: "2000B";
+    /** Loop 2010BA, Subscriber Name. */
+    readonly SUBSCRIBER_NAME_2010BA: "2010BA";
+    /** Loop 2010BB, Payer Name. */
+    readonly PAYER_NAME_2010BB: "2010BB";
+};
+/**
+ * String-literal union over {@link REQUIRED_LOOPS}.
+ *
+ * @example
+ * ```ts
+ * import type { X12RequiredLoop } from "@cosyte/x12";
+ * const loop: X12RequiredLoop = "2010BB";
+ * ```
+ */
+type X12RequiredLoop = (typeof REQUIRED_LOOPS)[keyof typeof REQUIRED_LOOPS];
+/**
+ * Every message string this library can put on a warning. Exported so a
+ * consumer, or a conformance gate, can assert set membership: if
+ * `ALL_WARNING_MESSAGES.has(w.message)` is ever false, something
+ * interpolated document bytes into a diagnostic.
+ *
+ * @example
+ * ```ts
+ * import { parseX12, ALL_WARNING_MESSAGES } from "@cosyte/x12";
+ * const ix = parseX12(raw);
+ * ix.warnings.every((w) => ALL_WARNING_MESSAGES.has(w.message)); // true, always
+ * ```
+ */
+declare const ALL_WARNING_MESSAGES: ReadonlySet<string>;
 /**
  * Data shape for every Tier-2 warning emitted by the parser. Warnings are
  * plain data (distinct from `X12ParseError`, which is a thrown `Error`
  * subclass) so they can be safely accumulated on `X12Interchange.warnings`
  * and passed to `onWarning` callbacks.
  *
+ * `message` is always a member of {@link ALL_WARNING_MESSAGES}: it names
+ * the deviation, never the bytes that caused it. `position` says where to
+ * look and the bytes stay on the model. A warning has no `snippet`.
+ *
  * @example
  * ```ts
  * import type { X12ParseWarning } from "@cosyte/x12";
- * const w: X12ParseWarning = {
- *   code: "X12_PRE_005010",
- *   message: "ISA-12 declares pre-005010 version.",
- *   position: { segmentIndex: 0, interchangeIndex: 0, elementIndex: 12 },
- * };
+ * declare const w: X12ParseWarning;
+ * w.code; // "X12_PRE_005010"
+ * w.position; // { segmentIndex: 0, interchangeIndex: 0, elementIndex: 12 }
  * ```
  */
 interface X12ParseWarning {
@@ -102,111 +268,101 @@ interface X12ParseWarning {
 }
 /**
  * Build an `X12_CONTROL_NUMBER_MISMATCH` warning. Emitted when an
- * envelope-trailer control number does not match its matching header -
- * ISA-13 ↔ IEA-02, GS-06 ↔ GE-02, or ST-02 ↔ SE-02. Message carries the
- * field pair label and the expected-vs-actual values bounded to the 9-char
- * (interchange) / variable (group/transaction) numeric forms - these are
- * control numbers, not PHI.
+ * envelope-trailer control number does not match its matching header:
+ * ISA-13 ↔ IEA-02, GS-06 ↔ GE-02, or ST-02 ↔ SE-02.
+ *
+ * Neither side is echoed, not truncated and not hashed. A control number is
+ * free-form trading-partner text on five of the six slots (only ISA-13 is
+ * fixed-width), routinely carries a batch or patient-account identifier in
+ * the field, and is entirely sender-controlled. Read `isa.elements[13]`,
+ * `iea.elements[2]`, `gs.elements[6]`, `ge.elements[2]`, `st.elements[2]`
+ * and `se.elements[2]` off the model when you need the values.
  *
  * @example
  * ```ts
- * import { controlNumberMismatch } from "@cosyte/x12";
+ * import { controlNumberMismatch, CONTROL_NUMBER_PAIRS } from "@cosyte/x12";
  * const w = controlNumberMismatch(
- *   { segmentIndex: 1, interchangeIndex: 0, elementIndex: 2 },
- *   "ISA-13/IEA-02",
- *   "000000001",
- *   "000000002",
+ *   { segmentIndex: 6, interchangeIndex: 0, elementIndex: 2 },
+ *   CONTROL_NUMBER_PAIRS.INTERCHANGE,
  * );
  * ```
  */
-declare function controlNumberMismatch(position: X12Position, pair: string, header: string, trailer: string): X12ParseWarning;
+declare function controlNumberMismatch(position: X12Position, pair: X12ControlNumberPair): X12ParseWarning;
 /**
- * Build an `X12_PRE_005010` warning. Emitted when ISA-12 declares a version
- * earlier than `00501` - the HIPAA-mandated baseline. The parser still
+ * Build an `X12_PRE_005010` warning. Emitted when ISA-12 declares any version
+ * other than `00501`, the HIPAA-mandated baseline. The code name reads as a
+ * "pre-005010" test and the guard is an inequality, so a LATER family
+ * (`00602`, `00700`) raises it too. The parser still
  * accepts the input (Postel's Law: lenient on parse) but flags the
  * mismatch so consumers know the input may diverge from 005010 semantics.
+ * The declared version stays on `isa.elements[12]`.
  *
  * @example
  * ```ts
  * import { pre005010 } from "@cosyte/x12";
- * const w = pre005010({ segmentIndex: 0, interchangeIndex: 0, elementIndex: 12 }, "00401");
+ * const w = pre005010({ segmentIndex: 0, interchangeIndex: 0, elementIndex: 12 });
  * ```
  */
-declare function pre005010(position: X12Position, declared: string): X12ParseWarning;
+declare function pre005010(position: X12Position): X12ParseWarning;
 /**
  * Build an `X12_GROUP_COUNT_MISMATCH` warning. Emitted when IEA-01 does not
  * equal the actual number of GS..GE groups present in the interchange.
- * Trading partners use this to detect transmission truncation; the parser
- * surfaces both values verbatim and never silently corrects them.
+ * Trading partners use this to detect transmission truncation. Both numbers
+ * stay on the model (`iea.elements[1]` and `ix.groups.length`) and neither
+ * is silently corrected.
  *
  * @example
  * ```ts
  * import { groupCountMismatch } from "@cosyte/x12";
- * const w = groupCountMismatch(
- *   { segmentIndex: 5, interchangeIndex: 0, elementIndex: 1 },
- *   "2",
- *   1,
- * );
+ * const w = groupCountMismatch({ segmentIndex: 5, interchangeIndex: 0, elementIndex: 1 });
  * ```
  */
-declare function groupCountMismatch(position: X12Position, declared: string, actual: number): X12ParseWarning;
+declare function groupCountMismatch(position: X12Position): X12ParseWarning;
 /**
  * Build an `X12_TRANSACTION_COUNT_MISMATCH` warning. Emitted when GE-01
  * does not equal the actual number of ST..SE transaction sets present in
- * the group. As with group counts, the parser surfaces both values
- * verbatim and never silently corrects them.
+ * the group. Both numbers stay on the model (`ge.elements[1]` and
+ * `group.transactions.length`).
  *
  * @example
  * ```ts
  * import { transactionCountMismatch } from "@cosyte/x12";
- * const w = transactionCountMismatch(
- *   { segmentIndex: 4, interchangeIndex: 0, groupIndex: 0, elementIndex: 1 },
- *   "3",
- *   2,
- * );
+ * const w = transactionCountMismatch({ segmentIndex: 4, groupIndex: 0, elementIndex: 1 });
  * ```
  */
-declare function transactionCountMismatch(position: X12Position, declared: string, actual: number): X12ParseWarning;
+declare function transactionCountMismatch(position: X12Position): X12ParseWarning;
 /**
  * Build an `X12_SEGMENT_COUNT_MISMATCH` warning. Emitted by the spec-clean
  * serializer when an SE-01 value does not equal the actual number of
- * segments in the transaction set it closes (ST through SE inclusive). Like
- * the group/transaction count factories, the serializer surfaces both values
- * verbatim and NEVER silently corrects them - corrected counts are emitted
- * only on `serializeX12(ix, { recomputeCounts: true })`. The parser does not
- * emit this code (it leaves SE-01 reconciliation to the emit half); it is a
- * Phase-8 serializer diagnostic.
+ * segments in the transaction set it closes (ST through SE inclusive).
+ * Corrected counts are emitted only on `serializeX12(ix, { specClean: true,
+ * recomputeCounts: true })`. The parser does not emit this code (it leaves
+ * SE-01 reconciliation to the emit half); it is a Phase-8 serializer
+ * diagnostic.
  *
  * @example
  * ```ts
  * import { segmentCountMismatch } from "@cosyte/x12";
- * const w = segmentCountMismatch(
- *   { segmentIndex: 2, interchangeIndex: 0, groupIndex: 0, transactionIndex: 0, elementIndex: 1 },
- *   "6",
- *   7,
- * );
+ * const w = segmentCountMismatch({ segmentIndex: 2, transactionIndex: 0, elementIndex: 1 });
  * ```
  */
-declare function segmentCountMismatch(position: X12Position, declared: string, actual: number): X12ParseWarning;
+declare function segmentCountMismatch(position: X12Position): X12ParseWarning;
 /**
  * Build an `X12_TRAILING_GARBAGE` warning. Emitted when non-empty bytes
  * appear after the IEA segment terminator and any optional CRLF. The bytes
  * are preserved verbatim on {@link
- * "./types.js".X12Interchange}.`trailingBytes` so consumers can inspect or
- * re-emit them. Common cause: a second interchange concatenated into the
- * same file (multi-ISA - out of v1 scope; only the first interchange is
- * decoded).
+ * "./types.js".X12Interchange}.`trailingBytes` so consumers can inspect,
+ * measure, or re-emit them. Common cause: a second interchange concatenated
+ * into the same file (multi-ISA, out of v1 scope; only the first
+ * interchange is decoded).
  *
  * @example
  * ```ts
  * import { trailingGarbage } from "@cosyte/x12";
- * const w = trailingGarbage(
- *   { segmentIndex: 6, interchangeIndex: 0 },
- *   42,
- * );
+ * const w = trailingGarbage({ segmentIndex: 6, interchangeIndex: 0 });
  * ```
  */
-declare function trailingGarbage(position: X12Position, byteCount: number): X12ParseWarning;
+declare function trailingGarbage(position: X12Position): X12ParseWarning;
 /**
  * Build an `X12_MISSING_IEA` warning. Emitted when the input opened a
  * valid ISA but EOF arrived before any IEA segment. The parser returns the
@@ -242,12 +398,7 @@ declare function missingGe(position: X12Position): X12ParseWarning;
  * @example
  * ```ts
  * import { missingSe } from "@cosyte/x12";
- * const w = missingSe({
- *   segmentIndex: 2,
- *   interchangeIndex: 0,
- *   groupIndex: 0,
- *   transactionIndex: 0,
- * });
+ * const w = missingSe({ segmentIndex: 2, groupIndex: 0, transactionIndex: 0 });
  * ```
  */
 declare function missingSe(position: X12Position): X12ParseWarning;
@@ -268,249 +419,197 @@ declare function missingSe(position: X12Position): X12ParseWarning;
 declare function danglingReleaseChar(position: X12Position): X12ParseWarning;
 /**
  * Build an `X12_UNEXPECTED_SEGMENT` warning. Emitted when a structurally
- * meaningful envelope segment (`GE`, `SE`, body segments) appears outside
- * its expected parent - e.g. a `GE` with no open `GS`, an `SE` with no open
- * `ST`, or any body segment before the first `ST`. The parser preserves
- * lenient-never-throw and continues; the warning carries the segment id (if
- * it matches the X12 segment-id grammar - otherwise the literal
- * `(non-spec)` is substituted to avoid echoing arbitrary bytes / PHI) and
- * its global segment index so a consumer can locate the deviation.
+ * meaningful segment (`GE`, `SE`, `ST`, `TA1`, or a body segment) appears
+ * outside its expected parent. The parser preserves lenient-never-throw and
+ * continues; `context` names which structural rule broke and `position`
+ * locates the segment.
  *
- * Message NEVER echoes element values - only a SHAPE-VALIDATED 2-or-3-
- * letter segment id (the spec name, not user data) and the structural
- * context, mirroring the H-PHI invariant locked for `@cosyte/hl7`. A
- * hostile input that puts PHI in the first slot of a malformed "segment"
- * still has its bytes preserved on the parent container - they are simply
- * not echoed in the diagnostic message.
+ * The segment's own id is deliberately not a parameter. Note that a segment
+ * in one of these positions is NOT retained on the model at all (it has no
+ * open container to belong to), so `position.segmentIndex` against the input
+ * is the only way back to its bytes. For a segment that IS retained, the
+ * `X12Segment.id` a consumer reads is bounded to the X12 segment-id grammar
+ * (see {@link "./segment.js".decodeSegment}) while `seg.raw` and
+ * `seg.elements[0]` stay verbatim.
  *
  * @example
  * ```ts
- * import { unexpectedSegment } from "@cosyte/x12";
+ * import { unexpectedSegment, UNEXPECTED_SEGMENT_CONTEXTS } from "@cosyte/x12";
  * const w = unexpectedSegment(
  *   { segmentIndex: 12, interchangeIndex: 0 },
- *   "GE",
- *   "no open functional group",
+ *   UNEXPECTED_SEGMENT_CONTEXTS.GE_WITHOUT_GS,
  * );
  * ```
  */
-declare function unexpectedSegment(position: X12Position, segmentId: string, context: string): X12ParseWarning;
+declare function unexpectedSegment(position: X12Position, context: X12UnexpectedSegmentContext): X12ParseWarning;
 /**
  * Build an `X12_835_REMIT_BALANCE_MISMATCH` warning. Emitted by the 835
- * helper when a balance invariant fails - typically `CLP-04 + CLP-05 +
- * Σ(claim-level CAS amounts) !== CLP-03`, or `Σ(SVC paid) + Σ(line CAS)
- * !== CLP-04`, or `Σ(claim CLP-04) + Σ(PLB adjustments) !== BPR-02`.
+ * helper when a TR3 X221A1 §1.10.2 balance invariant fails. `invariant`
+ * names which equation broke; the spec'd, computed and delta amounts stay
+ * on the model as {@link "../decimal.js".X12Decimal} values and are never
+ * rendered into the message.
  *
- * The message carries the invariant label, the spec'd value, the
- * computed value, and the side-by-side diff - all numeric strings (the
- * outputs of {@link "../decimal.js".X12Decimal} `toString()`). It NEVER
- * echoes patient identifiers, member ids, names, account numbers, or any
- * other PHI-shaped value - mirrors the H-PHI invariant from `@cosyte/hl7`.
- * The parser ALWAYS surfaces this and NEVER silently rebalances.
+ * The parser ALWAYS surfaces this and NEVER silently rebalances. To report
+ * the numbers, recompute them from the model: `claim.totalChargeAmount`,
+ * `claim.totalPaymentAmount` and the CAS adjustments are all present.
  *
  * @example
  * ```ts
- * import { remitBalanceMismatch } from "@cosyte/x12";
+ * import { remitBalanceMismatch, BALANCE_INVARIANTS } from "@cosyte/x12";
  * const w = remitBalanceMismatch(
- *   { segmentIndex: 12, interchangeIndex: 0, groupIndex: 0, transactionIndex: 0 },
- *   "CLP-04 + CLP-05 + ΣCAS == CLP-03",
- *   "500.00",
- *   "499.99",
- *   "0.01",
+ *   { segmentIndex: 12, groupIndex: 0, transactionIndex: 0 },
+ *   BALANCE_INVARIANTS.CLAIM,
  * );
  * ```
  */
-declare function remitBalanceMismatch(position: X12Position, invariant: string, spec: string, computed: string, delta: string): X12ParseWarning;
+declare function remitBalanceMismatch(position: X12Position, invariant: X12BalanceInvariant): X12ParseWarning;
 /**
  * Build an `X12_UNKNOWN_CARC` warning. Emitted when a CAS adjustment
  * carries a CARC code outside the bundled snapshot (see
- * {@link "../code-lists/carc.js".CARC}). The verbatim code is still
- * preserved on the parsed adjustment - only the description is missing.
- * The code value is shape-validated against `[A-Z0-9]{1,5}` before
- * echoing in the message; a hostile non-conformant value collapses to
- * the literal `(non-spec)` so the parser never echoes arbitrary bytes
- * (H-PHI invariant).
+ * {@link "../code-lists/carc.js".CARC}). The verbatim code is preserved on
+ * the parsed adjustment (`adjustment.reasonCode`); only the description is
+ * missing.
  *
  * @example
  * ```ts
  * import { unknownCarc } from "@cosyte/x12";
- * const w = unknownCarc(
- *   { segmentIndex: 14, interchangeIndex: 0, groupIndex: 0, transactionIndex: 0 },
- *   "9999",
- * );
+ * const w = unknownCarc({ segmentIndex: 14, groupIndex: 0, transactionIndex: 0 });
  * ```
  */
-declare function unknownCarc(position: X12Position, code: string): X12ParseWarning;
+declare function unknownCarc(position: X12Position): X12ParseWarning;
 /**
  * Build an `X12_UNKNOWN_RARC` warning. Companion to {@link unknownCarc}
- * for RARC codes on `MIA` / `MOA` / `LQ` / `NTE`. Same shape-validation
- * + verbatim-preserve posture.
+ * for RARC codes on `MIA` / `MOA` / `LQ` / `NTE`. Same verbatim-preserve
+ * posture; the code lives on the parsed remark.
  *
  * @example
  * ```ts
  * import { unknownRarc } from "@cosyte/x12";
- * const w = unknownRarc(
- *   { segmentIndex: 16, interchangeIndex: 0, groupIndex: 0, transactionIndex: 0 },
- *   "ZZZZZ",
- * );
+ * const w = unknownRarc({ segmentIndex: 16, groupIndex: 0, transactionIndex: 0 });
  * ```
  */
-declare function unknownRarc(position: X12Position, code: string): X12ParseWarning;
+declare function unknownRarc(position: X12Position): X12ParseWarning;
 /**
- * Build an `X12_HL_PARENT_MISMATCH` warning. Emitted by the 837 helper
- * when an HL segment's HL-02 (parent id) does not match any earlier-
- * emitted HL-01 in the same transaction. The walker NEVER silently
- * re-numbers the hierarchy - the safety primitive of the 837 is HL
- * parent-pointer integrity. The reported ids are shape-validated against
- * the HL-id grammar before echoing.
+ * Build an `X12_HL_PARENT_MISMATCH` warning. Emitted when an HL segment's
+ * HL-02 (parent id) does not match any earlier-emitted HL-01 in the same
+ * transaction. The walker NEVER silently re-numbers the hierarchy (HL
+ * parent-pointer integrity is the safety primitive of the 837), so the
+ * declared pointer stays verbatim on `hierarchy.parentHlId` and the warning
+ * reports only that the pointer is dangling, and where.
  *
  * @example
  * ```ts
  * import { hlParentMismatch } from "@cosyte/x12";
- * const w = hlParentMismatch(
- *   { segmentIndex: 14, interchangeIndex: 0, groupIndex: 0, transactionIndex: 0 },
- *   "3",
- *   "9",
- * );
+ * const w = hlParentMismatch({ segmentIndex: 14, groupIndex: 0, transactionIndex: 0 });
  * ```
  */
-declare function hlParentMismatch(position: X12Position, hlId: string, declaredParentId: string): X12ParseWarning;
+declare function hlParentMismatch(position: X12Position): X12ParseWarning;
 /**
  * Build an `X12_HL_PARENT_LEVEL_INVALID` warning. Emitted when an HL's
- * level code (HL-03) is inconsistent with its declared parent's level
- * code per the 837 TR3 (e.g. a `22` Subscriber claiming a `22`
- * Subscriber as its parent - the parent must be `20` Information
- * Source). The verbatim level codes are shape-validated before echoing.
+ * level code (HL-03) is inconsistent with its declared parent's level code
+ * per the TR3 (e.g. a `22` Subscriber claiming a `22` Subscriber as its
+ * parent, where the parent must be `20` Information Source). Both level
+ * codes stay verbatim on the model.
  *
  * @example
  * ```ts
  * import { hlParentLevelInvalid } from "@cosyte/x12";
- * const w = hlParentLevelInvalid(
- *   { segmentIndex: 14, interchangeIndex: 0, groupIndex: 0, transactionIndex: 0 },
- *   "3",
- *   "23",
- *   "2",
- *   "22",
- *   "20",
- * );
+ * const w = hlParentLevelInvalid({ segmentIndex: 14, groupIndex: 0, transactionIndex: 0 });
  * ```
  */
-declare function hlParentLevelInvalid(position: X12Position, hlId: string, hlLevel: string, parentHlId: string, parentLevel: string, expectedParentLevel: string): X12ParseWarning;
+declare function hlParentLevelInvalid(position: X12Position): X12ParseWarning;
 /**
- * Build an `X12_UNKNOWN_HI_QUALIFIER` warning. Emitted by the 837 helper
- * when an HI composite's qualifier (first component) is outside the
+ * Build an `X12_UNKNOWN_HI_QUALIFIER` warning. Emitted by the 837 / 278
+ * helpers when an HI composite's qualifier (first component) is outside the
  * bundled snapshot at {@link "../code-lists/hi-qualifiers.js".
- * HI_QUALIFIERS}. The verbatim code is preserved on the parsed
- * diagnosis/procedure with `codeSystem: "unknown"` so consumers can
- * still react. Qualifier is shape-validated before echoing - the H-PHI
- * invariant.
+ * HI_QUALIFIERS}. The verbatim qualifier and code are preserved on the
+ * parsed diagnosis / procedure with `codeSystem: "unknown"` so consumers
+ * can still react.
  *
  * @example
  * ```ts
  * import { unknownHiQualifier } from "@cosyte/x12";
- * const w = unknownHiQualifier(
- *   { segmentIndex: 25, interchangeIndex: 0, groupIndex: 0, transactionIndex: 0 },
- *   "ZZZ",
- * );
+ * const w = unknownHiQualifier({ segmentIndex: 25, groupIndex: 0, transactionIndex: 0 });
  * ```
  */
-declare function unknownHiQualifier(position: X12Position, qualifier: string): X12ParseWarning;
+declare function unknownHiQualifier(position: X12Position): X12ParseWarning;
 /**
  * Build an `X12_MISSING_REQUIRED_LOOP` warning. Emitted when a TR3-required
  * loop is structurally absent (e.g. no Loop 2010BB Payer Name inside a
- * Subscriber HL). The parser does not enforce situational rules - only
- * loops marked `usage: "required"` in the loop spec fire this warning.
- * The loop id is shape-validated before echoing.
+ * Subscriber HL). The parser does not enforce situational rules: only loops
+ * marked `usage: "required"` in the loop spec fire this warning, so the
+ * loop id and its rationale are both library constants.
  *
  * @example
  * ```ts
- * import { missingRequiredLoop } from "@cosyte/x12";
+ * import { missingRequiredLoop, REQUIRED_LOOPS } from "@cosyte/x12";
  * const w = missingRequiredLoop(
- *   { segmentIndex: 12, interchangeIndex: 0, groupIndex: 0, transactionIndex: 0 },
- *   "2010BB",
- *   "Loop 2010BB Payer Name required when Loop 2000B (Subscriber HL) is present",
+ *   { segmentIndex: 12, groupIndex: 0, transactionIndex: 0 },
+ *   REQUIRED_LOOPS.PAYER_NAME_2010BB,
  * );
  * ```
  */
-declare function missingRequiredLoop(position: X12Position, loopId: string, rationale: string): X12ParseWarning;
+declare function missingRequiredLoop(position: X12Position, loop: X12RequiredLoop): X12ParseWarning;
 /**
  * Build an `X12_837_UNKNOWN_VARIANT` warning. Emitted when the 837 helper
  * cannot resolve the variant from ST-03's implementation-convention
  * reference AND no SVx service-line segment is present to fall back on.
- * The parsed submission still ships with `variant: "unknown"`; the walker
- * does its best on shared structure (envelope, HL, claim header) and
- * skips variant-specific service-line decoding. The implementation-
- * convention reference is shape-validated before echoing.
+ * The parsed submission still ships with `variant: "unknown"` and the
+ * verbatim reference on `submission.implementationConventionReference`; the
+ * walker does its best on shared structure (envelope, HL, claim header) and
+ * skips variant-specific service-line decoding.
  *
  * @example
  * ```ts
  * import { unknown837Variant } from "@cosyte/x12";
- * const w = unknown837Variant(
- *   { segmentIndex: 1, interchangeIndex: 0, groupIndex: 0, transactionIndex: 0 },
- *   "005010X999",
- * );
+ * const w = unknown837Variant({ segmentIndex: 1, groupIndex: 0, transactionIndex: 0 });
  * ```
  */
-declare function unknown837Variant(position: X12Position, implementationConventionReference: string | undefined): X12ParseWarning;
+declare function unknown837Variant(position: X12Position): X12ParseWarning;
 /**
  * Build an `X12_UNKNOWN_CLAIM_STATUS_CATEGORY` warning. Emitted by the 277
  * / 277CA helpers when an STC composite's Claim Status Category Code
- * (CSCC, first component) is outside the bundled snapshot (see
- * {@link "../code-lists/claim-status-category.js".
- * CLAIM_STATUS_CATEGORY_CODES}). The verbatim CSCC is still preserved on
- * the parsed status - only the description is missing. The code value is
- * shape-validated against the CSCC grammar before echoing; a hostile
- * non-conformant value collapses to the literal `(non-spec)` so the
- * parser never echoes arbitrary bytes (H-PHI invariant).
+ * (CSCC, first component; X12 code source 507) is outside the bundled
+ * snapshot. The verbatim CSCC is preserved on the parsed status; only the
+ * description is missing.
  *
  * @example
  * ```ts
  * import { unknownClaimStatusCategory } from "@cosyte/x12";
- * const w = unknownClaimStatusCategory(
- *   { segmentIndex: 18, interchangeIndex: 0, groupIndex: 0, transactionIndex: 0 },
- *   "Z9",
- * );
+ * const w = unknownClaimStatusCategory({ segmentIndex: 18, transactionIndex: 0 });
  * ```
  */
-declare function unknownClaimStatusCategory(position: X12Position, code: string): X12ParseWarning;
+declare function unknownClaimStatusCategory(position: X12Position): X12ParseWarning;
 /**
  * Build an `X12_UNKNOWN_CLAIM_STATUS` warning. Companion to
  * {@link unknownClaimStatusCategory} for the Claim Status Code (CSC, the
  * second component of an STC composite; X12 code source 508). Same
- * shape-validation + verbatim-preserve posture; reuses the CARC/RARC
- * `[A-Z0-9]{1,5}` value grammar (CSCs are short numeric tokens).
+ * verbatim-preserve posture.
  *
  * @example
  * ```ts
  * import { unknownClaimStatus } from "@cosyte/x12";
- * const w = unknownClaimStatus(
- *   { segmentIndex: 18, interchangeIndex: 0, groupIndex: 0, transactionIndex: 0 },
- *   "99999",
- * );
+ * const w = unknownClaimStatus({ segmentIndex: 18, transactionIndex: 0 });
  * ```
  */
-declare function unknownClaimStatus(position: X12Position, code: string): X12ParseWarning;
+declare function unknownClaimStatus(position: X12Position): X12ParseWarning;
 /**
  * Build an `X12_834_UNKNOWN_MAINTENANCE_TYPE` warning. Emitted by the 834
  * helper when a member-level `INS-03` (or a health-coverage `HD-01`)
  * maintenance type code falls outside the bundled snapshot (see
  * {@link "../code-lists/maintenance-type.js".MAINTENANCE_TYPE_CODES}).
- * Maintenance type is the 834's safety-critical field - an unknown action
+ * Maintenance type is the 834's safety-critical field: an unknown action
  * code must NEVER be silently coerced to add / change / terminate, so the
  * verbatim code is preserved on the parsed enrollment and this warning
- * flags the gap. The code value is shape-validated against `[0-9]{3}`
- * before echoing; a hostile non-conformant value collapses to the literal
- * `(non-spec)` (H-PHI invariant).
+ * flags the gap.
  *
  * @example
  * ```ts
  * import { unknownMaintenanceType } from "@cosyte/x12";
- * const w = unknownMaintenanceType(
- *   { segmentIndex: 9, interchangeIndex: 0, groupIndex: 0, transactionIndex: 0 },
- *   "999",
- * );
+ * const w = unknownMaintenanceType({ segmentIndex: 9, transactionIndex: 0 });
  * ```
  */
-declare function unknownMaintenanceType(position: X12Position, code: string): X12ParseWarning;
+declare function unknownMaintenanceType(position: X12Position): X12ParseWarning;
 
 /**
  * Type definitions for the `@cosyte/x12` profile subsystem (Phase 9).
@@ -961,6 +1060,21 @@ interface X12Segment {
     readonly raw: string;
     readonly elements: readonly string[];
 }
+/**
+ * The value {@link X12Segment.id} takes when the first element does not
+ * match the X12 segment-id grammar. Not a valid segment id, so it can
+ * never collide with a real one in a `seg.id === "NM1"` comparison.
+ *
+ * @example
+ * ```ts
+ * import { parseX12, NON_SPEC_SEGMENT_ID } from "@cosyte/x12";
+ * const seg = parseX12(raw).groups[0]?.transactions[0]?.segments[1];
+ * if (seg?.id === NON_SPEC_SEGMENT_ID) {
+ *   // the sender's "segment" name is not a spec segment id; its bytes are on seg.raw
+ * }
+ * ```
+ */
+declare const NON_SPEC_SEGMENT_ID = "(non-spec)";
 /**
  * Decode a raw segment string into an {@link X12Segment}. Splits on the
  * detected element separator (honouring the `?`-release-character escape),
@@ -1378,14 +1492,173 @@ interface X12FunctionalGroup {
     readonly ge: GeSegment | undefined;
     readonly transactions: readonly X12TransactionSet[];
 }
+/**
+ * Where an orphan sat in the STRUCTURE of the interchange, as opposed to
+ * where it sat in the input byte stream. This is what lets `serializeX12`
+ * put an orphan back without guessing.
+ *
+ * `X12OrphanSegment.segmentIndex` cannot do that job. It indexes the INPUT
+ * stream, and the emit is not in input order: `ta1Segments` are hoisted ahead
+ * of the groups, and a doubled terminator's zero-length segment occupies an
+ * input index that is never emitted. Either one shifts the output's indices
+ * away from the input's, so replaying by index splices the orphan into
+ * whatever occupies that slot - measurably, into an 835's `ST..SE` body,
+ * where a re-parse reports nothing. An anchor names a slot in the typed tree
+ * instead, which survives both reorderings because it does not mention bytes.
+ *
+ * Three kinds, one per structural level:
+ *
+ * - **`"interchange"`** - between the ISA and the IEA but outside every
+ *   functional group. `groupIndex` is the number of groups that had already
+ *   closed, so the orphan is emitted immediately before `ix.groups[groupIndex]`
+ *   (or before the IEA when `groupIndex === ix.groups.length`).
+ * - **`"group"`** - inside `ix.groups[groupIndex]` but outside every
+ *   transaction set in it. `transactionIndex` is the number of transactions
+ *   that had already closed, so the orphan is emitted immediately before that
+ *   group's `transactions[transactionIndex]` (or before its `GE` when
+ *   `transactionIndex === transactions.length`).
+ * - **`"transaction"`** - inside an open `ST..SE`, which only a `TA1` can be,
+ *   since every other segment arriving there is body content. `segmentOffset`
+ *   is the number of `rawSegments` already collected, so the orphan is emitted
+ *   immediately before `rawSegments[segmentOffset]`. It is never `0` (the `ST`
+ *   is always `rawSegments[0]`) and never exceeds `rawSegments.length`. Such an
+ *   orphan is written back BETWEEN the `ST` and the `SE`, so `serializeX12`
+ *   counts it toward SE-01 in spec-clean mode even though it is not on
+ *   `tx.rawSegments` - it is a segment of that transaction set per X12.6.
+ *
+ * **An anchor is a POSITION, so reshaping the model invalidates it.** The
+ * indices address `ix.groups`, that group's `transactions`, and that
+ * transaction's `rawSegments` as they stand on the interchange you pass to
+ * `serializeX12`. Filter or reorder any of those and an orphan's anchor may
+ * still resolve while naming a different slot, and it will be emitted there
+ * with no warning. An anchor that resolves to nothing is emitted at
+ * interchange level before the IEA rather than dropped. Re-parse rather than
+ * hand-edit if you need anchors to stay meaningful.
+ *
+ * @example
+ * ```ts
+ * import { parseX12 } from "@cosyte/x12";
+ * const ix = parseX12(raw);
+ * for (const o of ix.orphanSegments) {
+ *   if (o.anchor.kind === "group") console.warn(o.anchor.groupIndex);
+ * }
+ * ```
+ */
+type X12OrphanAnchor = {
+    readonly kind: "interchange";
+    /** How many functional groups had closed before this segment arrived. */
+    readonly groupIndex: number;
+} | {
+    readonly kind: "group";
+    /** Index into `ix.groups` of the group that was open. */
+    readonly groupIndex: number;
+    /** How many transaction sets in that group had closed. */
+    readonly transactionIndex: number;
+} | {
+    readonly kind: "transaction";
+    /** Index into `ix.groups` of the group that was open. */
+    readonly groupIndex: number;
+    /** Index into that group's `transactions` of the set that was open. */
+    readonly transactionIndex: number;
+    /** How many of that set's `rawSegments` had been collected. */
+    readonly segmentOffset: number;
+};
+/**
+ * String-literal union over the `kind` discriminant of {@link X12OrphanAnchor}.
+ *
+ * @example
+ * ```ts
+ * import type { X12OrphanAnchorKind } from "@cosyte/x12";
+ * const kind: X12OrphanAnchorKind = "transaction";
+ * ```
+ */
+type X12OrphanAnchorKind = X12OrphanAnchor["kind"];
+/**
+ * A segment the envelope grammar has no place for, captured verbatim rather
+ * than discarded. Every segment recorded here also raised exactly one
+ * `X12_UNEXPECTED_SEGMENT` warning whose `position.segmentIndex` equals
+ * {@link segmentIndex}, and `context` is that warning's library-owned
+ * discriminant, so the two surfaces can be joined without string matching.
+ *
+ * These are structural anomalies, not a normal shape: a stray segment
+ * between `GE` and `IEA`, a body segment between an `SE` and its group's
+ * `GE`, a body segment between `GS` and the first `ST`, an `ST` with no open
+ * group, an `SE` closing nothing, a `GE` closing nothing, or a `TA1` inside
+ * an open functional group. The parser cannot place any of them in the typed
+ * tree, but it no longer drops them either, so a segment that used to vanish
+ * is now readable here.
+ *
+ * **Most of these sit outside every ST..SE transaction set, but the `TA1`
+ * case does not.** `TA1` is envelope-level by spec, so a `TA1` anywhere
+ * inside an open group is routed here even when it arrives BETWEEN an `ST`
+ * and its `SE` - in which case it is lifted out of that transaction's
+ * `segments` / `rawSegments` and appears only on this array. That is
+ * long-standing behaviour (it predates this array; the segment simply used
+ * to be discarded), and it is the one case where `ix.groups` is not the whole
+ * typed model.
+ *
+ * **`serializeX12` re-emits these, at {@link anchor}**, so an orphan and its
+ * `X12_UNEXPECTED_SEGMENT` warning both survive a round trip. Placement is by
+ * the structural anchor and NEVER by {@link segmentIndex}: that index is an
+ * index into the INPUT stream, and the emit is not in input order (it hoists
+ * `ta1Segments` ahead of the groups and skips the zero-length segment a
+ * doubled terminator produces), so replaying by index splices an orphan into
+ * whatever occupies that slot - measurably, into an 835's `ST..SE` body,
+ * where a re-parse reports nothing at all. Use {@link segmentIndex} to join
+ * back to the warning, not to place the segment. See `KNOWN-LIMITATIONS.md`.
+ *
+ * Two things are NOT recorded here. A doubled segment terminator delimits a
+ * zero-length segment carrying no elements, so there is nothing to retain.
+ * A segment whose first element is empty (`*A*B~`) has no id for the
+ * envelope walker to dispatch on and is skipped without a warning; that is
+ * long-standing behaviour this array does not change.
+ *
+ * **This is document content, so treat it as PHI.** Unlike an
+ * `X12ParseWarning`, whose `message` is a lookup into a frozen registry and
+ * whose metadata is positional only, an orphan carries the sender's bytes
+ * verbatim, exactly as `X12TransactionSet.rawSegments` and `isa.raw` do. A
+ * segment outside a transaction is not required to be PHI-free, so do NOT
+ * log this array wholesale when triaging; log `context` and `segmentIndex`,
+ * which name the structural rule and the location without echoing content.
+ *
+ * @example
+ * ```ts
+ * import { parseX12 } from "@cosyte/x12";
+ * const ix = parseX12(raw);
+ * for (const o of ix.orphanSegments) {
+ *   console.warn(o.context, o.segmentIndex, o.segment.id);
+ * }
+ * ```
+ */
+interface X12OrphanSegment {
+    /** The verbatim segment text, segment terminator stripped. */
+    readonly raw: string;
+    /** The decoded segment (id + 1-indexed elements), as for any body segment. */
+    readonly segment: X12Segment;
+    /**
+     * Global segment index in the post-ISA stream (ISA itself is index 0) -
+     * identical to the `position.segmentIndex` of the segment's
+     * `X12_UNEXPECTED_SEGMENT` warning.
+     */
+    readonly segmentIndex: number;
+    /** Which structural rule the segment broke. */
+    readonly context: X12UnexpectedSegmentContext;
+    /**
+     * Where the segment sat in the typed tree - the slot `serializeX12` puts it
+     * back into. See {@link X12OrphanAnchor} for why a structural anchor and not
+     * {@link segmentIndex} is what makes re-emission sound.
+     */
+    readonly anchor: X12OrphanAnchor;
+}
 /**
  * The top-level X12 interchange returned by `parseX12`. `isa` carries the
  * envelope header verbatim; `delimiters` is the four-class delimiter set
  * detected from fixed positions inside `isa.raw`; `groups` is the ordered
- * GS..GE list; `warnings` accumulates every Tier-2 deviation observed
- * during the parse (lenient mode); `trailingBytes` (when present) is any
- * non-empty content after IEA - preserved verbatim so a consumer can
- * inspect or re-emit it.
+ * GS..GE list; `orphanSegments` holds any segment that fell outside every
+ * transaction set (empty for a well-formed interchange); `warnings`
+ * accumulates every Tier-2 deviation observed during the parse (lenient
+ * mode); `trailingBytes` (when present) is any non-empty content after IEA -
+ * preserved verbatim so a consumer can inspect or re-emit it.
  *
  * @example
  * ```ts
@@ -1400,6 +1673,14 @@ interface X12Interchange {
     readonly delimiters: Delimiters;
     readonly groups: readonly X12FunctionalGroup[];
     readonly ta1Segments: readonly Ta1Segment[];
+    /**
+     * Segments the envelope grammar could not place, in input order - almost
+     * always because they fell outside every ST..SE transaction set, plus the
+     * `TA1`-inside-a-group case, which is lifted out of the transaction it
+     * arrived in. Empty for a well-formed interchange. See
+     * {@link X12OrphanSegment}.
+     */
+    readonly orphanSegments: readonly X12OrphanSegment[];
     readonly warnings: readonly X12ParseWarning[];
     readonly trailingBytes?: string;
     /**
@@ -1432,7 +1713,9 @@ interface X12Interchange {
  * throw {@link X12ParseError}: `X12_EMPTY_INPUT`, `X12_NO_ISA_HEADER`,
  * `X12_ISA_TOO_SHORT`, `X12_INVALID_DELIMITERS`. Opt into strict mode with
  * `{ strict: true }` to escalate every Tier-2 warning into an
- * `X12ParseError` carrying the warning's code.
+ * `X12ParseError` carrying the warning's code. A strict-mode escalation
+ * carries an empty `snippet`: the warning it wraps is registry-built and
+ * fully located by `position`, so there is nothing to redact.
  *
  * Phase 1 decodes the envelope (ISA / GS / ST / SE / GE / IEA) and
  * detects the four delimiters from fixed ISA byte positions. Transaction-
@@ -1610,11 +1893,19 @@ type X12FatalCode = (typeof FATAL_CODES)[keyof typeof FATAL_CODES];
  * snippet of the offending input so consumers can log actionable errors.
  *
  * @remarks
- * Snippets may contain PHI/PII when parsing real interchanges (member IDs
- * appear in ISA-06/08 only as trading-partner IDs, not patient identity -
- * but real claim/eligibility bodies elsewhere in the input can carry PHI).
- * Redact at the call site if required by your compliance posture. The
- * library does not redact snippets itself.
+ * `snippet` is the library's ONE deliberate PHI exception, and it exists for
+ * the four Tier-3 structural fatals only. Those are raised before the
+ * envelope is readable and are undebuggable without a few bytes of context.
+ * It may contain PHI/PII when parsing real interchanges (member IDs appear in
+ * ISA-06/08 only as trading-partner IDs, not patient identity, but a real
+ * claim / eligibility body elsewhere in the input can carry PHI). Redact at
+ * the call site if required by your compliance posture; the library does not
+ * redact snippets itself.
+ *
+ * A strict-mode escalation of a Tier-2 warning carries `snippet: ""`. That
+ * error's `message` is the same frozen-registry entry the warning carried and
+ * `position` locates it, so there is nothing to attach and nothing to
+ * redact.
  *
  * @example
  * ```ts
@@ -3931,8 +4222,12 @@ declare const REMIT_835_LOOP_1000B: LoopSpec;
  * cash to the wrong dollar. These checks NEVER silently rebalance: a
  * failed invariant emits an {@link
  * "../../parser/warnings.js".WARNING_CODES.X12_835_REMIT_BALANCE_MISMATCH}
- * carrying the side-by-side spec'd vs computed values + delta, and the
- * model still resolves with the verbatim inbound amounts.
+ * naming which TR3 equation broke, and the model still resolves with the
+ * verbatim inbound amounts. The amounts themselves are NOT rendered into
+ * the message: an EDI amount is a consumer-controlled element like any
+ * other, and the spec'd / computed / delta trio used to be interpolated
+ * unbounded. Recompute them from the model, which carries every one of
+ * them as an `X12Decimal`.
  *
  * Three invariants per TR3 005010X221A1 §1.10.2 ("Balancing"):
  *
@@ -3960,11 +4255,46 @@ declare const REMIT_835_LOOP_1000B: LoopSpec;
  * > slice with a forward-pointer to this module so the contract stays
  * > consistent.
  *
- * **PHI discipline:** mismatch messages echo only the invariant label +
- * the X12Decimal text values (numeric - no PHI by shape). Patient
- * control numbers / member ids are NOT in the message - consumers
- * locate the offending claim via the warning's `position` + the claim's
- * sequence in `remit.claims`.
+ * **PHI discipline: the message names the equation and carries no value at
+ * all**, not even an amount. An EDI amount is a consumer-controlled element
+ * like any other: `CLP-03` is whatever the payer sent, so the spec'd /
+ * computed / delta trio these messages used to interpolate was an unbounded
+ * echo of sender bytes. Recompute the numbers from the model, which carries
+ * every one of them as an `X12Decimal`.
+ *
+ * **Which claim, then?** Three different answers, one per invariant.
+ *
+ * - **Claim-level** ({@link checkClaimBalance}): `position.segmentIndex` is
+ *   the CLP segment's own 1-based index inside the transaction body, so
+ *   `tx.segments[position.segmentIndex]` is that exact CLP.
+ * - **Service-line** ({@link checkServiceLineBalance}): that CLP index plus
+ *   the line's zero-based ordinal plus one, which is a **unique locator, not
+ *   a pointer at the SVC**. The segment sitting at that index is usually
+ *   something else in the claim's loop. Read it as "the claim whose CLP is at
+ *   `segmentIndex - (ordinal + 1)`, service line `ordinal`", or match against
+ *   `remit.claims` and `claim.serviceLines`, which carry the decoded model.
+ *   What the offset guarantees is non-collision across claims: a claim with
+ *   `n` service lines spans at least `n + 1` body segments, so the next CLP
+ *   always sits past the previous claim's last line position.
+ * - **Remit-level** ({@link checkRemitTotalBalance}): `segmentIndex` is the
+ *   **BPR's** own 1-based body index, so `tx.segments[position.segmentIndex]`
+ *   is that exact BPR. The equation spans the whole transaction set, so no
+ *   single segment is uniquely "at fault" - but BPR-02 is the one element the
+ *   invariant compares against, and the BPR is the only segment a reader can
+ *   act on. `get835` was passing a literal `0` here, and `0` is not a neutral
+ *   sentinel: `tx.segments[0]` is the ST, so a consumer resolving the position
+ *   landed on the ST. The one remaining `0` is the transaction that carries no
+ *   BPR at all (malformed - TR3 005010X221A1 makes BPR mandatory - but
+ *   reachable, since the check still runs against an all-zero payment header).
+ *   Take the amounts from `remit.payment.totalActualPayment` and
+ *   `remit.claims`; the message names the equation and carries no value.
+ *
+ * **A caller that constructs the position itself gets whatever it passes.**
+ * These three functions are exported, and they do not derive a position - they
+ * forward one. `build835` exploits that: it hands in a synthetic position
+ * because it has no parsed segment stream to index into, and it uses only
+ * `.message`, which is a registry lookup keyed by the invariant and therefore
+ * position-independent.
  */
 
 /**
@@ -3978,7 +4308,8 @@ declare const REMIT_835_LOOP_1000B: LoopSpec;
  * declare const claim: X12RemitClaim;
  * const w = checkClaimBalance(claim, { segmentIndex: 12 });
  * if (w !== undefined) {
- *   // not balanced - w.message names invariant + spec + computed + delta
+ *   // not balanced - w.message names the TR3 equation; the amounts are on `claim`,
+ *   // and w.position.segmentIndex is the CLP's own index in the transaction body
  * }
  * ```
  */
@@ -11873,14 +12204,71 @@ interface BuildTA1Options {
  * - **Byte-faithful (default).** Reconstructs the interchange purely from the
  *   verbatim `.raw` strings the parser preserved (ISA + terminator, then each
  *   GS / transaction segment / GE / IEA terminator-joined, then any
- *   `trailingBytes`). For a Tier-1 (spec-clean, no-CRLF) input this is exactly
- *   the source bytes - the idempotency fixed point `serialize(parse(s)) === s`.
- *   Inter-segment CRLF and a trailing newline are NOT reproduced: the parser
- *   silently normalizes them away (they are not in the model), so a
- *   pretty-printed source round-trips to its compact spec-clean form.
+ *   `trailingBytes`). "Byte-faithful" is a statement about SEGMENTS ON THE
+ *   MODEL, and the distinction matters to anyone diffing output against input.
+ *
+ *   Every segment the parser recorded comes back verbatim, including element
+ *   padding, composite structure and `?`-release escapes, but it comes back in
+ *   the ORDER the model holds it, which is not always the input order. SIX
+ *   constructs are known not to survive, and line breaks are only the most
+ *   common:
+ *
+ *   1. **Line breaks between segments.** The parser absorbs any run of CR /
+ *      LF bytes between segments and the model has nowhere to record it, so a
+ *      pretty-printed or double-spaced source emits as its compact form.
+ *      Silent.
+ *   2. **A doubled segment terminator** outside a transaction. It delimits a
+ *      zero-length segment carrying no elements, so there is nothing to
+ *      retain. Silent.
+ *   3. **A missing final terminator**, which the emit supplies. Silent.
+ *   4. **Post-IEA `trailingBytes`**, re-joined from segment slices rather than
+ *      preserved verbatim.
+ *   5. **TA1 position.** A TA1 that appeared AFTER a functional group is
+ *      collected onto `ix.ta1Segments` and emitted immediately after the ISA,
+ *      so the emit reorders it. Silent, and unlike the others nothing is
+ *      dropped: the model and the warning stream both round-trip identically.
+ *      This is also the only construct that can move something ELSE - a
+ *      segment outside a transaction is placed correctly relative to the
+ *      groups but not relative to a TA1 that was hoisted past it. This library
+ *      takes no position here on where ASC X12 requires a TA1 to sit.
+ *   6. **A segment whose first element is empty** (`*A*B~`), outside a
+ *      transaction. It has no id for the envelope walker to dispatch on, so it
+ *      is skipped: absent from the model, absent from the emit, and it does
+ *      not even raise `X12_UNEXPECTED_SEGMENT`. Silent, and the only case here
+ *      that loses a value with no diagnostic at all. Inside an open
+ *      transaction the same segment is kept and re-emitted normally.
+ *
+ *   **A segment outside a transaction is no longer on that list.** It is
+ *   retained on `ix.orphanSegments` with a structural `anchor`, and this
+ *   function re-emits it at that anchor, so the segment, its value and its
+ *   `X12_UNEXPECTED_SEGMENT` warning all survive the round trip. See the
+ *   `orphans` block below for why placement is by anchor and never by
+ *   `segmentIndex`.
+ *
+ *   So `serialize(parse(s)) === s` is still NOT guaranteed in general, and the
+ *   absence of line breaks is still not sufficient to make it hold: cases 2 to
+ *   6 all break it on inputs that contain none. Five of the six (1, 2, 3, 5, 6)
+ *   produce no warning at all, so the warning stream is not a reliable signal
+ *   that a round trip will be byte-exact - only case 4 warns.
+ *
+ *   What IS measured, across the 56 committed fixtures: all 56 emits are fixed
+ *   points (serializing again is a byte-level no-op), all 56 re-parse to an
+ *   identical model with an identical warning stream, the 14 fixtures carrying
+ *   no line breaks return byte-identical, and the 42 that are pretty-printed
+ *   differ from their source by line breaks and nothing else. Two caveats on
+ *   that corpus: it contains no instance of cases 2 to 6 and no orphan at all,
+ *   and 13 of the 14 byte-identical fixtures are `golden/*.edi`, which are
+ *   serializer output by construction, so `envelope/no-trailing-crlf.edi` is
+ *   the only independent witness. `test/serialize.test.ts` covers the corpus
+ *   sweep, the orphan round trip, and cases 1 to 6 separately.
  *
  * - **Spec-clean (`{ specClean: true }`).** Same byte-faithful structure, but
- *   the serializer ALSO reconciles the envelope counts and control numbers:
+ *   the serializer ALSO reconciles the envelope counts and control numbers.
+ *   Every count is taken from the bytes this function WRITES, which for SE-01
+ *   is `tx.rawSegments` PLUS any orphan re-emitted between the `ST` and the
+ *   `SE` - a lifted `TA1` is off the model's transaction but is still a
+ *   segment of that transaction set per X12.6, and counting the model alone
+ *   made `recomputeCounts` shrink a correct SE-01. The pairs reconciled are
  *   SE-01 (segment count) vs the actual ST..SE segment count, GE-01
  *   (transaction count) vs the actual ST count, IEA-01 (group count) vs the
  *   actual group count, plus the ISA-13↔IEA-02 / GS-06↔GE-02 / ST-02↔SE-02
@@ -11891,9 +12279,12 @@ interface BuildTA1Options {
  *   segments. Control numbers are identity, not derived, so they are NEVER
  *   rewritten - only flagged.
  *
- * Warning messages carry positional context + bounded numeric metadata only;
- * they never echo element VALUES (the H-PHI invariant shared across the
- * `@cosyte/x12` warning factories).
+ * Every warning it emits is built by the same value-free factories the parser
+ * uses: `message` is a frozen-registry lookup and `position` locates the
+ * control segment, so a declared count or control number can never reach a
+ * diagnostic. Read the declared and actual values off the model
+ * (`se.elements[1]` against `tx.rawSegments.length`, `ge.elements[1]` against
+ * `group.transactions.length`, `iea.elements[1]` against `ix.groups.length`).
  */
 
 /**
@@ -11943,7 +12334,10 @@ interface SerializeOptions {
  * ```ts
  * import { parseX12, serializeX12 } from "@cosyte/x12";
  * const ix = parseX12(raw);
- * const bytes = serializeX12(ix); // byte-faithful for a Tier-1 input
+ * // Segments on the model come back verbatim, orphans included. Anything the
+ * // parser did not record (line breaks, a doubled terminator, ...) does not,
+ * // so this is not guaranteed to equal `raw`. See the module header.
+ * const bytes = serializeX12(ix);
  * ```
  */
 declare function serializeX12(interchange: X12Interchange, opts?: SerializeOptions): string;
@@ -12133,6 +12527,124 @@ interface InterchangeSpec {
  */
 declare function buildInterchange(spec: InterchangeSpec): X12Interchange;
 
+/**
+ * The single route a caller-supplied value takes into a `build*` refusal
+ * message.
+ *
+ * ## Why this exists
+ *
+ * The parse side closed its equivalent hole first: no warning factory takes a
+ * value parameter at all, and `message` is a lookup into the frozen
+ * `ALL_WARNING_MESSAGES` table, so a *document's* bytes cannot reach a
+ * diagnostic (`PHI-WARNING-MESSAGE-LEAK`). The builder side is the mirror
+ * image with one material asymmetry, and the claim made here is deliberately
+ * narrower because of it:
+ *
+ * > **A builder refusal echoes a value the CALLER passed in, which is usually
+ * > but NOT ALWAYS their own.** They just handed it to the builder, so bounding
+ * > it is **robustness and log hygiene, not redaction**. This module does not
+ * > make a builder refusal PHI-safe, and nothing in this library claims it
+ * > does. If a caller puts PHI in a control number, the refusal will show up
+ * > to {@link BUILD_REFUSAL_VALUE_MAX_LENGTH} characters of it.
+ *
+ * **Do not state that dichotomy categorically, because the ack builders break
+ * it.** `build999` renders the AK2-02 transaction-set control number and
+ * `buildTA1` exists to echo an inbound ISA-13: TR3 005010X231A1 requires AK2-02
+ * to be a verbatim copy of the acknowledged transaction set's ST-02, so on the
+ * ack path a *document's* bytes reach the spec by the standard's own design,
+ * and from there a refusal message. They are envelope control numbers rather
+ * than clinical content, and they are bounded here like everything else - but
+ * "the value is always the caller's own" is false, and this library should not
+ * say it.
+ *
+ * What it does guarantee is that `Error.message` from a `build*` refusal has a
+ * **fixed ceiling**. Before this, **twenty-three** refusal sites across ten builder
+ * modules interpolated a caller value verbatim, so a 120,000-character control
+ * number produced a 120,066-**character** `X12BuildError.message` - measured on
+ * this tree, and the length grew without limit with the input. An unbounded
+ * `Error.message` is a real operational hazard independent of PHI: it is what
+ * gets serialized into a log line, a crash report, or a JSON error envelope.
+ *
+ * ## What is bounded and what is not
+ *
+ * - **Bounded:** the number of UTF-16 code units. The rendered fragment never
+ *   exceeds {@link BUILD_REFUSAL_VALUE_MAX_RENDERED}. **Code units, not bytes** -
+ *   an all-astral value renders 86 units but 152 UTF-8 bytes, and a CJK one
+ *   around 216. Every figure this package publishes says "characters" for that
+ *   reason. A slice at the bound can also split a surrogate pair, leaving a lone
+ *   surrogate that becomes U+FFFD once the message is UTF-8 encoded; the bound
+ *   holds regardless, and the fragment is diagnostic text, not data.
+ * - **NOT escaped, and this is not an oversight.** The surviving characters are
+ *   whatever the caller supplied, including a segment terminator, a quote, or a
+ *   newline. A refusal message is therefore bounded but not guaranteed to be a
+ *   single log line. Escaping was considered and left out: it would expand the
+ *   rendered length by up to 6x per character for a hazard the caller creates
+ *   in their own data, and this slice makes the claim it can support and no
+ *   wider.
+ *
+ * @see `src/parser/errors.ts` for the parse-side `SNIPPET_MAX_INPUT` bound this
+ * mirrors, which is the one deliberate place a *document's* bytes are copied.
+ */
+/**
+ * How many characters of a caller-supplied value survive into a `build*`
+ * refusal message. Set to mirror the parser's own `SNIPPET_MAX_INPUT` (63),
+ * so the two bounded copies in this library agree rather than each picking a
+ * number. Comfortably wider than every slot it guards: an ISA-13 / IEA-02
+ * control number is 9, a TA1-05 note code 3, an ST-01 transaction set id 3, an
+ * 834 maintenance type 2-3, an 837 service-line variant 1.
+ *
+ * @example
+ * ```ts
+ * import { BUILD_REFUSAL_VALUE_MAX_LENGTH } from "@cosyte/x12";
+ * BUILD_REFUSAL_VALUE_MAX_LENGTH; // 63
+ * ```
+ */
+declare const BUILD_REFUSAL_VALUE_MAX_LENGTH = 63;
+/**
+ * Hard ceiling, in characters, on the fragment {@link renderCallerValue}
+ * returns: {@link BUILD_REFUSAL_VALUE_MAX_LENGTH} surviving characters, two
+ * quotes, one ellipsis, and the ` (N characters)` suffix at its widest.
+ *
+ * **This is the bound on the FRAGMENT, not on the message.** A refusal message
+ * is this plus the site's own fixed template text, which differs per site, so
+ * the message is bounded by a constant but not by *this* constant. Measured on
+ * this tree: a 120,000-character control number gives an 86-character fragment
+ * and a **150-character** `X12BuildError.message` from `buildInterchange`. Do
+ * not quote the ceiling as though it were a message length - an earlier
+ * revision of the docs did exactly that, reporting "now 90 bytes" for a message
+ * that is 150. The suite asserts the fragment against this constant and each
+ * message against its own site.
+ *
+ * @example
+ * ```ts
+ * import { BUILD_REFUSAL_VALUE_MAX_RENDERED } from "@cosyte/x12";
+ * BUILD_REFUSAL_VALUE_MAX_RENDERED; // 90
+ * ```
+ */
+declare const BUILD_REFUSAL_VALUE_MAX_RENDERED: number;
+/**
+ * Render a caller-supplied value as a bounded, quoted fragment for a `build*`
+ * refusal message. **This is the only sanctioned route a caller value takes
+ * into a thrown message**, and `test/builder-refusal-bounds.test.ts` scans
+ * `src/` for any other route - a twenty-fourth refusal site that interpolates a
+ * value directly reds that test. That scan keys on `throw new *BuildError(` and
+ * on template-literal holes, so it is a strong tripwire for the shape this
+ * library uses rather than a proof over every shape one could write.
+ *
+ * Returns the value quoted when it fits, and otherwise the first
+ * {@link BUILD_REFUSAL_VALUE_MAX_LENGTH} characters, an ellipsis, and the true
+ * length - the length is the diagnostically useful part when the value is
+ * over-long, since that is usually *why* the builder refused.
+ *
+ * @example
+ * ```ts
+ * import { renderCallerValue } from "@cosyte/x12";
+ * renderCallerValue("000000001");        // '"000000001"'
+ * renderCallerValue("9".repeat(120000)); // '"999…" (120000 characters)'
+ * ```
+ */
+declare function renderCallerValue(value: string | number): string;
+
 /**
  * Thrown errors emitted by the general-purpose interchange builder
  * (`buildInterchange`). Distinct from `X12ParseError` (the parser stays
@@ -12479,4 +12991,4 @@ declare const profiles: {
  */
 declare const VERSION: string;
 
-export { ACK_BUILD_ERROR_CODES, AUTH_278_BUILD_ERROR_CODES, AUTH_278_LOOP_2000A, AUTH_278_LOOP_2000B, AUTH_278_LOOP_2000C, AUTH_278_LOOP_2000D, AUTH_278_LOOP_2000E, AUTH_278_LOOP_2000F, AckBuildError, type AckBuildErrorCode, type Build271AddressSpec, type Build271BenefitSpec, type Build271DateSpec, type Build271DependentSpec, type Build271EntitySpec, type Build271EnvelopeSpec, type Build271InformationReceiverSpec, type Build271InformationSourceSpec, type Build271MemberSpec, type Build271ReferenceSpec, type Build271ServiceTypeSpec, type Build271Spec, type Build271SubscriberSpec, type Build271TraceSpec, type Build277ClaimSpec, type Build277DateSpec, type Build277DependentSpec, type Build277EntitySpec, type Build277EnvelopeSpec, type Build277InformationReceiverSpec, type Build277InformationSourceSpec, type Build277MemberSpec, type Build277ProviderSpec, type Build277ReferenceSpec, type Build277ServiceLineSpec, type Build277Spec, type Build277StatusCodeSpec, type Build277StatusSpec, type Build277SubscriberSpec, type Build277TraceSpec, type Build278DateSpec, type Build278DecisionSpec, type Build278DependentSpec, type Build278DiagnosisSpec, type Build278EntitySpec, type Build278EnvelopeSpec, type Build278HeaderSpec, type Build278MemberSpec, type Build278ReferenceSpec, type Build278ReviewSpec, type Build278Spec, type Build278SubscriberSpec, type Build278TraceSpec, type Build820AddressSpec, type Build820AdjustmentSpec, type Build820DateSpec, type Build820EntitySpec, type Build820EnvelopeSpec, type Build820OpenItemSpec, type Build820PartySpec, type Build820PaymentSpec, type Build820PersonSpec, type Build820ReferenceSpec, type Build820RemittanceSpec, type Build820Spec, type Build820TraceSpec, type Build834AddressSpec, type Build834AmountSpec, type Build834CoordinationOfBenefitsSpec, type Build834CoverageSpec, type Build834DateSpec, type Build834EnvelopeSpec, type Build834HeaderSpec, type Build834MemberNameSpec, type Build834MemberSpec, type Build834PartySpec, type Build834ReferenceSpec, type Build834Spec, type Build835AddressSpec, type Build835AdjustmentSpec, type Build835AmountSpec, type Build835ClaimSpec, type Build835ContactSpec, type Build835EnvelopeSpec, type Build835PartySpec, type Build835PaymentSpec, type Build835PersonSpec, type Build835ProviderAdjustmentSpec, type Build835ProviderSpec, type Build835ReferenceSpec, type Build835RemarkSpec, type Build835ServiceLineSpec, type Build835Spec, type Build835TraceSpec, type Build837AddressSpec, type Build837AdjudicationSpec, type Build837AdjustmentSpec, type Build837AmountSpec, type Build837BillingProviderSpec, type Build837ClaimSpec, type Build837ContactSpec, type Build837DateSpec, type Build837DrugSpec, type Build837EntitySpec, type Build837EnvelopeSpec, type Build837HiCodeSpec, type Build837NoteSpec, type Build837OtherSubscriberSpec, type Build837PatientSpec, type Build837ReferenceSpec, type Build837ServiceLineBaseSpec, type Build837ServiceLineDentalSpec, type Build837ServiceLineInstitutionalSpec, type Build837ServiceLineProfessionalSpec, type Build837ServiceLineSpec, type Build837Spec, type Build837SubscriberInfoSpec, type Build837SubscriberSpec, type Build837ToothSpec, type Build999ElementErrorSpec, type Build999EnvelopeSpec, type Build999FunctionalGroupSpec, type Build999SegmentErrorSpec, type Build999Spec, type Build999TransactionResponseSpec, type BuildTA1Options, type BuildTA1Spec, CARC, CLAIM_837D_LOOP_2000A, CLAIM_837D_LOOP_2300, CLAIM_837D_LOOP_2400, CLAIM_837I_LOOP_2000A, CLAIM_837I_LOOP_2300, CLAIM_837I_LOOP_2400, CLAIM_837P_LOOP_2000A, CLAIM_837P_LOOP_2300, CLAIM_837P_LOOP_2400, CLAIM_837P_LOOP_2410, CLAIM_837_BUILD_ERROR_CODES, CLAIM_837_LOOP_1000A, CLAIM_837_LOOP_1000B, CLAIM_837_LOOP_2010AA, CLAIM_837_LOOP_2010BA, CLAIM_837_LOOP_2010BB, CLAIM_837_LOOP_2010CA, CLAIM_837_LOOP_2430, CLAIM_ADJUSTMENT_GROUP_CODES, CLAIM_STATUS_277_BUILD_ERROR_CODES, CLAIM_STATUS_CATEGORY_CODES, CLAIM_STATUS_CODES, CLP_STATUS, Claim837BuildError, type Claim837BuildErrorCode, type ClaimAdjustmentGroupCode, ClaimStatus277BuildError, type ClaimStatus277BuildErrorCode, type CodeListEntry, type CodeListMeta, type CodeListSnapshot, DELIMITER_POSITIONS, type DefineLoopSpecInput, type Delimiters, ELIGIBILITY_271_BUILD_ERROR_CODES, ELIGIBILITY_271_LOOP_2000A, ELIGIBILITY_271_LOOP_2000B, ELIGIBILITY_271_LOOP_2000C, ELIGIBILITY_271_LOOP_2000D, ELIGIBILITY_271_LOOP_2100C, ELIGIBILITY_271_LOOP_2100D, ELIGIBILITY_271_LOOP_2110, ENROLLMENT_834_BUILD_ERROR_CODES, ENROLLMENT_834_LOOP_1000A, ENROLLMENT_834_LOOP_1000B, ENROLLMENT_834_LOOP_2000, ENROLLMENT_834_LOOP_2100A, ENROLLMENT_834_LOOP_2300, ENROLLMENT_834_LOOP_2320, Eligibility271BuildError, type Eligibility271BuildErrorCode, Enrollment834BuildError, type Enrollment834BuildErrorCode, FATAL_CODES, type FunctionalGroupSpec, type GeSegment, type GsSegment, HI_QUALIFIERS, HL_LEVEL_CODES, IK3_SYNTAX_ERROR_CODES, IK4_SYNTAX_ERROR_CODES, ISA_MIN_LENGTH, type IeaSegment, type Ik304Code, type Ik403Code, type InterchangeSpec, type IsaSegment, type LoopMax, type LoopSegmentSpec, type LoopSpec, LoopSpecDefinitionError, type LoopUsage, MAINTENANCE_TYPE_CODES, NM1_QUALIFIERS, type OnWarningCallback, PREMIUM_820_BUILD_ERROR_CODES, PREMIUM_820_LOOP_1000A, PREMIUM_820_LOOP_1000B, PREMIUM_820_LOOP_2000A, PREMIUM_820_LOOP_2100A, PREMIUM_820_LOOP_2300A, PREMIUM_820_LOOP_2310A, Premium820BuildError, type Premium820BuildErrorCode, RARC, RELEASE_CHAR, REMIT_835_BUILD_ERROR_CODES, REMIT_835_LOOP_1000A, REMIT_835_LOOP_1000B, REMIT_835_LOOP_2000, REMIT_835_LOOP_2100, REMIT_835_LOOP_2110, Remit835BuildError, type Remit835BuildErrorCode, SERVICE_TYPE_CODES, STATUS_277_LOOP_2000A, STATUS_277_LOOP_2000B, STATUS_277_LOOP_2000C, STATUS_277_LOOP_2000D, STATUS_277_LOOP_2000E, STATUS_277_LOOP_2200, STATUS_277_LOOP_2220, type SegmentSpec, type SerializeOptions, ServicesReview278BuildError, type ServicesReview278BuildErrorCode, TA1_ACK_CODES, TA1_NOTE_CODES, type Ta1AckCode, type Ta1NoteCode, type Ta1Segment, type TransactionSetSpec, VERSION, WARNING_CODES, type X12Ack999, type X12Ack999Ak1, type X12Ack999Ak2, type X12Ack999Ak9, type X12Ack999ElementNote, type X12Ack999Ik3, type X12Ack999Ik4, type X12Ack999Ik4Position, type X12Ack999Ik5, type X12Ack999SegmentNote, type X12Ack999TransactionResponse, type X12AckDispositionCode, type X12AckTA1, type X12AuthDate, type X12AuthDiagnosis, type X12AuthEntity, type X12AuthHeader, type X12AuthMember, type X12AuthReference, type X12AuthTrace, X12BuildError, type X12BuildErrorCode, type X12Claim, type X12Claim837Variant, type X12ClaimAddress, type X12ClaimAmount, type X12ClaimContact, type X12ClaimDate, type X12ClaimEntity, type X12ClaimHiCode, type X12ClaimMember, type X12ClaimNote, type X12ClaimReference, type X12ClaimStatus, type X12ClaimStatusResponse, type X12CoordinationOfBenefits, X12Decimal, type X12Eligibility, type X12EligibilityAddress, type X12EligibilityBenefit, type X12EligibilityDate, type X12EligibilityDependent, type X12EligibilityEntity, type X12EligibilityMember, type X12EligibilityReference, type X12EligibilityServiceType, type X12EligibilitySubscriber, type X12EligibilityTrace, type X12Enrollment, type X12EnrollmentAddress, type X12EnrollmentAmount, type X12EnrollmentDate, type X12EnrollmentHeader, type X12EnrollmentMember, type X12EnrollmentParty, type X12EnrollmentReference, type X12FatalCode, type X12FunctionalGroup, type X12HealthCoverage, type X12HiCategory, type X12HiCodeSystem, type X12HiQualifier, type X12HierarchicalLevel, type X12Hl, type X12Interchange, type X12LineAdjudication, type X12LineDrug, type X12OtherSubscriber, X12ParseError, type X12ParseOptions, type X12ParseWarning, type X12Position, type X12PremiumAddress, type X12PremiumAdjustment, type X12PremiumDate, type X12PremiumEntity, type X12PremiumOpenItem, type X12PremiumParty, type X12PremiumPaymentHeader, type X12PremiumPayments, type X12PremiumPerson, type X12PremiumReference, type X12PremiumRemittance, type X12PremiumTrace, type X12Profile, type X12ProfileDescription, type X12ProfileEffect, X12ProfileError, type X12ProfileQuirk, type X12ProfileSpec, type X12RemitAddress, type X12RemitAdjustment, type X12RemitAmount, type X12RemitClaim, type X12RemitContact, type X12RemitParty, type X12RemitPaymentHeader, type X12RemitPerson, type X12RemitProvider, type X12RemitProviderAdjustment, type X12RemitReference, type X12RemitRemark, type X12RemitServiceLine, type X12RemitTrace, type X12Remittance, type X12ReviewDecision, type X12Segment, type X12ServiceLineStatus, type X12ServiceReview, type X12ServicesReview, type X12StatusCode, type X12StatusDate, type X12StatusEntity, type X12StatusInfo, type X12StatusMember, type X12StatusReference, type X12StatusTrace, type X12SubscriberInfo, type X12ToothInformation, type X12TransactionSet, type X12WarningCode, type X12WarningPartition, type X12_837ServiceLine, type X12_837ServiceLineDental, type X12_837ServiceLineInstitutional, type X12_837ServiceLineProfessional, type X12_837Submission, X12_ACK_DISPOSITION_CODES, X12_BUILD_ERROR_CODES, build271, build277, build277CA, build278Request, build278Response, build820, build834, build835, build837D, build837I, build837P, build999, buildInterchange, buildTA1, checkClaimBalance, checkRemitTotalBalance, checkServiceLineBalance, collectElementValues, componentOptional, controlNumberMismatch, danglingReleaseChar, decodeSegment, defineLoopSpec, defineProfile, detectDelimiters, elementDecimal, elementDecimalOrZero, elementOptional, elementValue, escapeRelease, get271Eligibility, get277CADisposition, get277Status, get278Request, get278Response, get820Payments, get834Enrollments, get834Header, get835, get837Claims, getAllSegmentValues, getDefaultProfile, getSegmentValue, groupCountMismatch, hlParentLevelInvalid, hlParentMismatch, isAcceptDisposition, isClaimAdjustmentGroupCode, isDiagnosisQualifier, isProcedureQualifier, lookupCarc, lookupClaimStatus, lookupClaimStatusCategory, lookupClpStatus, lookupMaintenanceType, lookupRarc, lookupServiceType, missingGe, missingIea, missingRequiredLoop, missingSe, parse999, parseTA1, parseX12, partitionWarnings, pre005010, profiles, remitBalanceMismatch, resolveHiQualifier, segmentCountMismatch, serializeX12, setDefaultProfile, trailingGarbage, transactionCountMismatch, unescapeRelease, unexpectedSegment, unknown837Variant, unknownCarc, unknownClaimStatus, unknownClaimStatusCategory, unknownHiQualifier, unknownMaintenanceType, unknownRarc };
+export { ACK_BUILD_ERROR_CODES, ALL_WARNING_MESSAGES, AUTH_278_BUILD_ERROR_CODES, AUTH_278_LOOP_2000A, AUTH_278_LOOP_2000B, AUTH_278_LOOP_2000C, AUTH_278_LOOP_2000D, AUTH_278_LOOP_2000E, AUTH_278_LOOP_2000F, AckBuildError, type AckBuildErrorCode, BALANCE_INVARIANTS, BUILD_REFUSAL_VALUE_MAX_LENGTH, BUILD_REFUSAL_VALUE_MAX_RENDERED, type Build271AddressSpec, type Build271BenefitSpec, type Build271DateSpec, type Build271DependentSpec, type Build271EntitySpec, type Build271EnvelopeSpec, type Build271InformationReceiverSpec, type Build271InformationSourceSpec, type Build271MemberSpec, type Build271ReferenceSpec, type Build271ServiceTypeSpec, type Build271Spec, type Build271SubscriberSpec, type Build271TraceSpec, type Build277ClaimSpec, type Build277DateSpec, type Build277DependentSpec, type Build277EntitySpec, type Build277EnvelopeSpec, type Build277InformationReceiverSpec, type Build277InformationSourceSpec, type Build277MemberSpec, type Build277ProviderSpec, type Build277ReferenceSpec, type Build277ServiceLineSpec, type Build277Spec, type Build277StatusCodeSpec, type Build277StatusSpec, type Build277SubscriberSpec, type Build277TraceSpec, type Build278DateSpec, type Build278DecisionSpec, type Build278DependentSpec, type Build278DiagnosisSpec, type Build278EntitySpec, type Build278EnvelopeSpec, type Build278HeaderSpec, type Build278MemberSpec, type Build278ReferenceSpec, type Build278ReviewSpec, type Build278Spec, type Build278SubscriberSpec, type Build278TraceSpec, type Build820AddressSpec, type Build820AdjustmentSpec, type Build820DateSpec, type Build820EntitySpec, type Build820EnvelopeSpec, type Build820OpenItemSpec, type Build820PartySpec, type Build820PaymentSpec, type Build820PersonSpec, type Build820ReferenceSpec, type Build820RemittanceSpec, type Build820Spec, type Build820TraceSpec, type Build834AddressSpec, type Build834AmountSpec, type Build834CoordinationOfBenefitsSpec, type Build834CoverageSpec, type Build834DateSpec, type Build834EnvelopeSpec, type Build834HeaderSpec, type Build834MemberNameSpec, type Build834MemberSpec, type Build834PartySpec, type Build834ReferenceSpec, type Build834Spec, type Build835AddressSpec, type Build835AdjustmentSpec, type Build835AmountSpec, type Build835ClaimSpec, type Build835ContactSpec, type Build835EnvelopeSpec, type Build835PartySpec, type Build835PaymentSpec, type Build835PersonSpec, type Build835ProviderAdjustmentSpec, type Build835ProviderSpec, type Build835ReferenceSpec, type Build835RemarkSpec, type Build835ServiceLineSpec, type Build835Spec, type Build835TraceSpec, type Build837AddressSpec, type Build837AdjudicationSpec, type Build837AdjustmentSpec, type Build837AmountSpec, type Build837BillingProviderSpec, type Build837ClaimSpec, type Build837ContactSpec, type Build837DateSpec, type Build837DrugSpec, type Build837EntitySpec, type Build837EnvelopeSpec, type Build837HiCodeSpec, type Build837NoteSpec, type Build837OtherSubscriberSpec, type Build837PatientSpec, type Build837ReferenceSpec, type Build837ServiceLineBaseSpec, type Build837ServiceLineDentalSpec, type Build837ServiceLineInstitutionalSpec, type Build837ServiceLineProfessionalSpec, type Build837ServiceLineSpec, type Build837Spec, type Build837SubscriberInfoSpec, type Build837SubscriberSpec, type Build837ToothSpec, type Build999ElementErrorSpec, type Build999EnvelopeSpec, type Build999FunctionalGroupSpec, type Build999SegmentErrorSpec, type Build999Spec, type Build999TransactionResponseSpec, type BuildTA1Options, type BuildTA1Spec, CARC, CLAIM_837D_LOOP_2000A, CLAIM_837D_LOOP_2300, CLAIM_837D_LOOP_2400, CLAIM_837I_LOOP_2000A, CLAIM_837I_LOOP_2300, CLAIM_837I_LOOP_2400, CLAIM_837P_LOOP_2000A, CLAIM_837P_LOOP_2300, CLAIM_837P_LOOP_2400, CLAIM_837P_LOOP_2410, CLAIM_837_BUILD_ERROR_CODES, CLAIM_837_LOOP_1000A, CLAIM_837_LOOP_1000B, CLAIM_837_LOOP_2010AA, CLAIM_837_LOOP_2010BA, CLAIM_837_LOOP_2010BB, CLAIM_837_LOOP_2010CA, CLAIM_837_LOOP_2430, CLAIM_ADJUSTMENT_GROUP_CODES, CLAIM_STATUS_277_BUILD_ERROR_CODES, CLAIM_STATUS_CATEGORY_CODES, CLAIM_STATUS_CODES, CLP_STATUS, CONTROL_NUMBER_PAIRS, Claim837BuildError, type Claim837BuildErrorCode, type ClaimAdjustmentGroupCode, ClaimStatus277BuildError, type ClaimStatus277BuildErrorCode, type CodeListEntry, type CodeListMeta, type CodeListSnapshot, DELIMITER_POSITIONS, type DefineLoopSpecInput, type Delimiters, ELIGIBILITY_271_BUILD_ERROR_CODES, ELIGIBILITY_271_LOOP_2000A, ELIGIBILITY_271_LOOP_2000B, ELIGIBILITY_271_LOOP_2000C, ELIGIBILITY_271_LOOP_2000D, ELIGIBILITY_271_LOOP_2100C, ELIGIBILITY_271_LOOP_2100D, ELIGIBILITY_271_LOOP_2110, ENROLLMENT_834_BUILD_ERROR_CODES, ENROLLMENT_834_LOOP_1000A, ENROLLMENT_834_LOOP_1000B, ENROLLMENT_834_LOOP_2000, ENROLLMENT_834_LOOP_2100A, ENROLLMENT_834_LOOP_2300, ENROLLMENT_834_LOOP_2320, Eligibility271BuildError, type Eligibility271BuildErrorCode, Enrollment834BuildError, type Enrollment834BuildErrorCode, FATAL_CODES, type FunctionalGroupSpec, type GeSegment, type GsSegment, HI_QUALIFIERS, HL_LEVEL_CODES, IK3_SYNTAX_ERROR_CODES, IK4_SYNTAX_ERROR_CODES, ISA_MIN_LENGTH, type IeaSegment, type Ik304Code, type Ik403Code, type InterchangeSpec, type IsaSegment, type LoopMax, type LoopSegmentSpec, type LoopSpec, LoopSpecDefinitionError, type LoopUsage, MAINTENANCE_TYPE_CODES, NM1_QUALIFIERS, NON_SPEC_SEGMENT_ID, type OnWarningCallback, PREMIUM_820_BUILD_ERROR_CODES, PREMIUM_820_LOOP_1000A, PREMIUM_820_LOOP_1000B, PREMIUM_820_LOOP_2000A, PREMIUM_820_LOOP_2100A, PREMIUM_820_LOOP_2300A, PREMIUM_820_LOOP_2310A, Premium820BuildError, type Premium820BuildErrorCode, RARC, RELEASE_CHAR, REMIT_835_BUILD_ERROR_CODES, REMIT_835_LOOP_1000A, REMIT_835_LOOP_1000B, REMIT_835_LOOP_2000, REMIT_835_LOOP_2100, REMIT_835_LOOP_2110, REQUIRED_LOOPS, Remit835BuildError, type Remit835BuildErrorCode, SERVICE_TYPE_CODES, STATUS_277_LOOP_2000A, STATUS_277_LOOP_2000B, STATUS_277_LOOP_2000C, STATUS_277_LOOP_2000D, STATUS_277_LOOP_2000E, STATUS_277_LOOP_2200, STATUS_277_LOOP_2220, type SegmentSpec, type SerializeOptions, ServicesReview278BuildError, type ServicesReview278BuildErrorCode, TA1_ACK_CODES, TA1_NOTE_CODES, type Ta1AckCode, type Ta1NoteCode, type Ta1Segment, type TransactionSetSpec, UNEXPECTED_SEGMENT_CONTEXTS, VERSION, WARNING_CODES, type X12Ack999, type X12Ack999Ak1, type X12Ack999Ak2, type X12Ack999Ak9, type X12Ack999ElementNote, type X12Ack999Ik3, type X12Ack999Ik4, type X12Ack999Ik4Position, type X12Ack999Ik5, type X12Ack999SegmentNote, type X12Ack999TransactionResponse, type X12AckDispositionCode, type X12AckTA1, type X12AuthDate, type X12AuthDiagnosis, type X12AuthEntity, type X12AuthHeader, type X12AuthMember, type X12AuthReference, type X12AuthTrace, type X12BalanceInvariant, X12BuildError, type X12BuildErrorCode, type X12Claim, type X12Claim837Variant, type X12ClaimAddress, type X12ClaimAmount, type X12ClaimContact, type X12ClaimDate, type X12ClaimEntity, type X12ClaimHiCode, type X12ClaimMember, type X12ClaimNote, type X12ClaimReference, type X12ClaimStatus, type X12ClaimStatusResponse, type X12ControlNumberPair, type X12CoordinationOfBenefits, X12Decimal, type X12Eligibility, type X12EligibilityAddress, type X12EligibilityBenefit, type X12EligibilityDate, type X12EligibilityDependent, type X12EligibilityEntity, type X12EligibilityMember, type X12EligibilityReference, type X12EligibilityServiceType, type X12EligibilitySubscriber, type X12EligibilityTrace, type X12Enrollment, type X12EnrollmentAddress, type X12EnrollmentAmount, type X12EnrollmentDate, type X12EnrollmentHeader, type X12EnrollmentMember, type X12EnrollmentParty, type X12EnrollmentReference, type X12FatalCode, type X12FunctionalGroup, type X12HealthCoverage, type X12HiCategory, type X12HiCodeSystem, type X12HiQualifier, type X12HierarchicalLevel, type X12Hl, type X12Interchange, type X12LineAdjudication, type X12LineDrug, type X12OrphanAnchor, type X12OrphanAnchorKind, type X12OrphanSegment, type X12OtherSubscriber, X12ParseError, type X12ParseOptions, type X12ParseWarning, type X12Position, type X12PremiumAddress, type X12PremiumAdjustment, type X12PremiumDate, type X12PremiumEntity, type X12PremiumOpenItem, type X12PremiumParty, type X12PremiumPaymentHeader, type X12PremiumPayments, type X12PremiumPerson, type X12PremiumReference, type X12PremiumRemittance, type X12PremiumTrace, type X12Profile, type X12ProfileDescription, type X12ProfileEffect, X12ProfileError, type X12ProfileQuirk, type X12ProfileSpec, type X12RemitAddress, type X12RemitAdjustment, type X12RemitAmount, type X12RemitClaim, type X12RemitContact, type X12RemitParty, type X12RemitPaymentHeader, type X12RemitPerson, type X12RemitProvider, type X12RemitProviderAdjustment, type X12RemitReference, type X12RemitRemark, type X12RemitServiceLine, type X12RemitTrace, type X12Remittance, type X12RequiredLoop, type X12ReviewDecision, type X12Segment, type X12ServiceLineStatus, type X12ServiceReview, type X12ServicesReview, type X12StatusCode, type X12StatusDate, type X12StatusEntity, type X12StatusInfo, type X12StatusMember, type X12StatusReference, type X12StatusTrace, type X12SubscriberInfo, type X12ToothInformation, type X12TransactionSet, type X12UnexpectedSegmentContext, type X12WarningCode, type X12WarningPartition, type X12_837ServiceLine, type X12_837ServiceLineDental, type X12_837ServiceLineInstitutional, type X12_837ServiceLineProfessional, type X12_837Submission, X12_ACK_DISPOSITION_CODES, X12_BUILD_ERROR_CODES, build271, build277, build277CA, build278Request, build278Response, build820, build834, build835, build837D, build837I, build837P, build999, buildInterchange, buildTA1, checkClaimBalance, checkRemitTotalBalance, checkServiceLineBalance, collectElementValues, componentOptional, controlNumberMismatch, danglingReleaseChar, decodeSegment, defineLoopSpec, defineProfile, detectDelimiters, elementDecimal, elementDecimalOrZero, elementOptional, elementValue, escapeRelease, get271Eligibility, get277CADisposition, get277Status, get278Request, get278Response, get820Payments, get834Enrollments, get834Header, get835, get837Claims, getAllSegmentValues, getDefaultProfile, getSegmentValue, groupCountMismatch, hlParentLevelInvalid, hlParentMismatch, isAcceptDisposition, isClaimAdjustmentGroupCode, isDiagnosisQualifier, isProcedureQualifier, lookupCarc, lookupClaimStatus, lookupClaimStatusCategory, lookupClpStatus, lookupMaintenanceType, lookupRarc, lookupServiceType, missingGe, missingIea, missingRequiredLoop, missingSe, parse999, parseTA1, parseX12, partitionWarnings, pre005010, profiles, remitBalanceMismatch, renderCallerValue, resolveHiQualifier, segmentCountMismatch, serializeX12, setDefaultProfile, trailingGarbage, transactionCountMismatch, unescapeRelease, unexpectedSegment, unknown837Variant, unknownCarc, unknownClaimStatus, unknownClaimStatusCategory, unknownHiQualifier, unknownMaintenanceType, unknownRarc };