@cosyte/dicom 0.0.16 → 0.0.18

package/dist/index.d.cts

@@ -184,6 +184,220 @@ declare namespace index {
   export { type index_DictionaryEntry as DictionaryEntry, type index_Tag as Tag, type index_UidEntry as UidEntry, type index_VR as VR, index_byKeyword as byKeyword, index_lookup as lookup, index_uid as uid };
 }
 
+/**
+ * Fatal error taxonomy for the `@cosyte/dicom` parser pipeline.
+ *
+ * Phase 2 core-parser context:
+ *   - D-09 - `FATAL_CODES` is a frozen `as const` registry with EXACTLY
+ *     four codes; anything less severe MUST be a Tier-2 warning.
+ *   - D-10 - `DicomParseError` carries `code`, `byteOffset`, `offsetFrame`,
+ *     `snippet` (up to 16 source bytes, space-separated lowercase hex), and
+ *     an optional `contextPath`. The thrown `Error.message` is formatted
+ *     `[CODE] msg (offset=N frame=F)` with `… in path/segments` appended when
+ *     `contextPath` is provided.
+ *
+ * @module
+ */
+
+/**
+ * Stable string codes for every Tier-3 fatal the parser may throw.
+ *
+ * Locked at four codes per `PROJECT.md` "Fatal errors only for unrecoverable
+ * structural corruption": anything less severe MUST be a Tier-2 warning
+ * (see `./warnings.ts`). Consumers narrow on `err.code` to react to
+ * specific structural failures.
+ *
+ * @example
+ * ```ts
+ * import { parseDicom, FATAL_CODES, DicomParseError } from "@cosyte/dicom";
+ * try {
+ *   parseDicom(Buffer.alloc(0));
+ * } catch (err) {
+ *   if (err instanceof DicomParseError && err.code === FATAL_CODES.EMPTY_INPUT) {
+ *     // handle empty input
+ *   }
+ * }
+ * ```
+ */
+declare const FATAL_CODES: {
+    readonly NOT_DICOM_PART_10: "NOT_DICOM_PART_10";
+    readonly INVALID_FILE_META: "INVALID_FILE_META";
+    readonly UNSUPPORTED_TRANSFER_SYNTAX: "UNSUPPORTED_TRANSFER_SYNTAX";
+    readonly EMPTY_INPUT: "EMPTY_INPUT";
+};
+/**
+ * Discriminant type for `DicomParseError.code`. Narrowing a caught error
+ * by this code lets consumers write exhaustive `switch` blocks (enabled
+ * by the `switch-exhaustiveness-check` lint rule) and guarantees a
+ * typo-free comparison against the `FATAL_CODES` registry.
+ *
+ * @example
+ * ```ts
+ * import type { FatalCode } from "@cosyte/dicom";
+ * function describe(code: FatalCode): string {
+ *   switch (code) {
+ *     case "EMPTY_INPUT":
+ *       return "input was empty";
+ *     case "NOT_DICOM_PART_10":
+ *       return "input is not a DICOM Part 10 file";
+ *     case "INVALID_FILE_META":
+ *       return "File Meta group is missing or malformed";
+ *     case "UNSUPPORTED_TRANSFER_SYNTAX":
+ *       return "Transfer Syntax UID is not supported by v1";
+ *   }
+ * }
+ * ```
+ */
+type FatalCode = (typeof FATAL_CODES)[keyof typeof FATAL_CODES];
+/**
+ * The coordinate systems a `byteOffset` this parser publishes can be counted
+ * in.
+ *
+ * A byte offset is a number and a number alone says nothing about where its
+ * zero is. This parser reads a Data Set out of three different buffers over one
+ * `parseDicom` call, so the same small integer means three different things
+ * depending on which one is being read - and until `DICOM-DIAGNOSTIC-PHI-
+ * RESIDUALS` closed it, nothing on the thrown error said which. A consumer
+ * cutting `input.subarray(err.byteOffset, err.byteOffset + 16)` to see what
+ * upset the parser was, inside a Sequence Item, cutting an unrelated element -
+ * the exact defect the `{ strict: true }` snippet itself was fixed for in
+ * `#80`.
+ *
+ * **A frame NAME is published; a frame ORIGIN is not, and that asymmetry is
+ * deliberate.** The name is drawn from the closed set below, which the parser
+ * chooses and no sender can influence, and that membership is the whole of its
+ * bound. An origin has no such table: it is a position reached by summing the
+ * declared lengths that led to it, so two of them differ by a wire field, and a
+ * message that already publishes `byteOffset` would be one number short of
+ * one. **That is a weaker argument than an impossibility and is stated as
+ * weaker**, since the library publishes positions freely in the `"input"`
+ * frame; a graded pass said so. The item asked for the frame to be NAMED, and
+ * nothing here needs the origin, so the cheap side of the trade is taken.
+ *
+ * @example
+ * ```ts
+ * import { parseDicom, DicomParseError, OFFSET_FRAMES } from "@cosyte/dicom";
+ * try {
+ *   parseDicom(buffer);
+ * } catch (err) {
+ *   if (err instanceof DicomParseError && err.offsetFrame === OFFSET_FRAMES.INPUT) {
+ *     // Only here is `err.byteOffset` an index into the buffer you passed in.
+ *     console.error(buffer.subarray(err.byteOffset, err.byteOffset + 16));
+ *   }
+ * }
+ * ```
+ */
+declare const OFFSET_FRAMES: {
+    /**
+     * Byte 0 is byte 0 of the buffer handed to `parseDicom`. The only frame in
+     * which indexing the caller's own input by `byteOffset` is meaningful.
+     */
+    readonly INPUT: "input";
+    /**
+     * Byte 0 is byte 0 of the inflated Data Set of a Deflated Explicit VR LE
+     * object (`1.2.840.10008.1.2.1.99`). The compressed input holds no such
+     * byte, so the offset does not index it at any scale.
+     */
+    readonly INFLATED_DATASET: "inflated-dataset";
+    /**
+     * Byte 0 is byte 0 of a slice this parser cut from inside a Value Field: a
+     * defined-length Sequence Item's value, or an `SQ`/`UN` value handed to a
+     * descent. **Where that slice begins is deliberately not published** - see
+     * this table's own note.
+     */
+    readonly VALUE_SLICE: "value-slice";
+};
+/**
+ * The frame a `DicomParseError.byteOffset` is counted in. See
+ * {@link OFFSET_FRAMES}.
+ *
+ * @example
+ * ```ts
+ * import type { OffsetFrame } from "@cosyte/dicom";
+ * function indexable(frame: OffsetFrame): boolean {
+ *   // Only the root frame's offsets index the buffer the caller passed in.
+ *   switch (frame) {
+ *     case "input":
+ *       return true;
+ *     case "inflated-dataset":
+ *     case "value-slice":
+ *       return false;
+ *   }
+ * }
+ * ```
+ */
+type OffsetFrame = (typeof OFFSET_FRAMES)[keyof typeof OFFSET_FRAMES];
+/**
+ * Thrown by `parseDicom` when the input violates one of the four
+ * unrecoverable Tier-3 structural rules - or, under `{ strict: true }`,
+ * when any Tier-2 warning is escalated through the single `emit`
+ * chokepoint (D-35). Carries byte-offset positional context plus a short
+ * source snippet so consumers can log actionable errors.
+ *
+ * Message format: `[CODE] msg (offset=N frame=F)`, with `… in a/b/c`
+ * appended when `contextPath` is provided.
+ *
+ * @remarks
+ * Snippets may contain PHI when parsing real clinical files - redact at
+ * the call site if required by your compliance posture. The library does
+ * not redact snippets itself.
+ *
+ * **`byteOffset` is only an index into your own buffer when `offsetFrame` is
+ * `"input"`.** This parser reads a Data Set out of a slice in two situations -
+ * a defined-length Sequence Item, and an `SQ`/`UN` descent - and out of an
+ * inflated stream in a third, and an offset raised in any of them counts from
+ * that buffer's byte 0. {@link OFFSET_FRAMES} names which; where a slice
+ * begins is deliberately not published, because the distance between two
+ * frames is a declared length off the wire.
+ *
+ * **`snippet` is cut in the frame `offsetFrame` names, on every fatal but one.**
+ * The exception is `UNSUPPORTED_TRANSFER_SYNTAX`, whose snippet slot carries
+ * PS3.6's own NAME for the unsupported UID when the registry publishes one
+ * (`"RLE Lossless"`), and 16 raw bytes only when it does not. That is
+ * deliberate and predates the frame; it is named here because a universal about
+ * `snippet` written without it is false on the code a compressed object reaches
+ * first. Everywhere else the two agree, so a consumer that only wants the bytes
+ * at the offset already has them. **The frame is what a consumer needs before
+ * indexing anything of its OWN by `byteOffset`**, which is the case no field on
+ * this class used to cover.
+ *
+ * @example
+ * ```ts
+ * import { parseDicom, DicomParseError, OFFSET_FRAMES } from "@cosyte/dicom";
+ * try {
+ *   parseDicom(buffer);
+ * } catch (err) {
+ *   if (err instanceof DicomParseError && err.code === "NOT_DICOM_PART_10") {
+ *     // err.byteOffset, err.offsetFrame, err.snippet, err.contextPath
+ *     if (err.offsetFrame !== OFFSET_FRAMES.INPUT) {
+ *       // `byteOffset` counts from somewhere inside the file, not from its start.
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare class DicomParseError extends Error {
+    readonly code: FatalCode;
+    readonly byteOffset: number;
+    /**
+     * The coordinate system {@link DicomParseError.byteOffset} is counted in.
+     * See {@link OFFSET_FRAMES}.
+     */
+    readonly offsetFrame: OffsetFrame;
+    readonly snippet: string;
+    readonly contextPath: readonly string[] | undefined;
+    /**
+     * Construct a new `DicomParseError`. All fields except `contextPath` are
+     * required so every thrower populates positional context per `TOL-02` - and
+     * `offsetFrame` is required for the same reason `byteOffset` is, because an
+     * offset whose frame is optional is an offset whose frame is usually
+     * missing.
+     *
+     * @internal
+     */
+    constructor(code: FatalCode, message: string, byteOffset: number, offsetFrame: OffsetFrame, snippet: string, contextPath?: readonly string[]);
+}
+
 /**
  * Shared parser-pipeline types for `@cosyte/dicom`.
  *
@@ -263,10 +477,21 @@ interface Profile {
 /**
  * Positional context for a `DicomParseWarning` or `DicomParseError`.
  *
- * Byte offsets are relative to the source buffer for non-deflated transfer
- * syntaxes; for the Deflated Explicit VR LE transfer syntax (D-27),
- * `deflated: true` indicates the offset is into the inflated dataset buffer
- * rather than the on-disk source.
+ * **🛑 `byteOffset` IS NOT ALWAYS RELATIVE TO THE SOURCE BUFFER, AND THIS
+ * JSDOC SAID IT WAS.** For the Deflated Explicit VR LE transfer syntax (D-27),
+ * `deflated: true` says the offset indexes the inflated dataset buffer rather
+ * than the on-disk source. That flag is the only frame this type carries, and
+ * it is not the only frame this parser has: a defined-length Sequence Item is
+ * parsed from a **slice**, so a warning raised inside one carries an
+ * item-relative offset with nothing on the position to say so. The same is true
+ * of `Element.byteOffset`, and has been since the parser was written.
+ *
+ * **The residual is `PRE-EXISTING` and is not closed here.** What is closed is
+ * the thrown side: `DicomParseError.offsetFrame` names the coordinate system
+ * from a closed set (see `OFFSET_FRAMES`), and that covers a Tier-3 fatal and
+ * the `{ strict: true }` escalation of a Tier-2 warning. It does not reach a
+ * warning on the lenient path, which is this type. Do not read the fatal's
+ * frame contract as one this type has.
  *
  * With `exactOptionalPropertyTypes: true`, callers should omit unset keys
  * rather than passing `undefined` (mirrors `@cosyte/hl7` sibling discipline).
@@ -356,8 +581,8 @@ interface ParseOptions {
      * carries `snippet`,
      * **16 raw bytes, unredacted** (D-10), read at the warning's own `byteOffset`.
      * A message-only PHI review of the lenient path therefore does not transfer to
-     * the strict one. Log `err.code`, `err.byteOffset` and `err.message`; treat
-     * `err.snippet` as PHI.
+     * the strict one. Log `err.code`, `err.byteOffset`, `err.offsetFrame` and
+     * `err.message`; treat `err.snippet` as PHI.
      *
      * **The snippet is cut in the SAME FRAME the `byteOffset` is counted in**, so
      * it is the bytes at the offset the diagnostic names: file-absolute at the
@@ -372,9 +597,15 @@ interface ParseOptions {
      * message beside them is registry-bound is the mistake this whole paragraph
      * exists to prevent.
      *
-     * **`byteOffset` still carries no frame-of-reference contract**, and closing
-     * the mismatch did not give it one: a nested offset is still not a key you can
-     * look up against the root. Measure it rather than reasoning about it.
+     * **`byteOffset` NOW CARRIES A FRAME-OF-REFERENCE CONTRACT, AND IT IS A NAME
+     * AND NOT AN ORIGIN.** `err.offsetFrame` says which of three coordinate
+     * systems the number is counted in (`OFFSET_FRAMES`), so a consumer can tell a
+     * root offset from an Item-relative one instead of guessing. **A nested offset
+     * is still not a key you can look up against the root**, and it is not made
+     * into one here: where a slice begins is deliberately unpublished, because the
+     * distance between two frames is a declared Value Length off the wire. The
+     * escalated warning's own `position` is unchanged and still carries no frame
+     * beyond `deflated` - see `DicomPosition`.
      *
      * Omit (do not pass `undefined`) to use the default.
      */
@@ -491,6 +722,7 @@ declare const WARNING_CODES: {
     readonly DICOM_DEIDENT_METHOD_NOT_ADDED: "DICOM_DEIDENT_METHOD_NOT_ADDED";
     readonly DICOM_DEIDENT_METHOD_NOT_LO: "DICOM_DEIDENT_METHOD_NOT_LO";
     readonly DICOM_DEIDENT_METHOD_PRIOR_RETAINED: "DICOM_DEIDENT_METHOD_PRIOR_RETAINED";
+    readonly DICOM_DEIDENT_METHOD_VALUE_OVER_LENGTH: "DICOM_DEIDENT_METHOD_VALUE_OVER_LENGTH";
     readonly DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE: "DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE";
     readonly DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE: "DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE";
     readonly DICOM_PRIVATE_CREATOR_UNKNOWN: "DICOM_PRIVATE_CREATOR_UNKNOWN";
@@ -1549,112 +1781,6 @@ declare class Sequence {
     constructor(items: readonly Item[], length: number);
 }
 
-/**
- * Fatal error taxonomy for the `@cosyte/dicom` parser pipeline.
- *
- * Phase 2 core-parser context:
- *   - D-09 - `FATAL_CODES` is a frozen `as const` registry with EXACTLY
- *     four codes; anything less severe MUST be a Tier-2 warning.
- *   - D-10 - `DicomParseError` carries `code`, `byteOffset`, `snippet`
- *     (up to 16 source bytes, space-separated lowercase hex), and an
- *     optional `contextPath`. The thrown `Error.message` is formatted
- *     `[CODE] msg (offset=N)` with `… in path/segments` appended when
- *     `contextPath` is provided.
- *
- * @module
- */
-
-/**
- * Stable string codes for every Tier-3 fatal the parser may throw.
- *
- * Locked at four codes per `PROJECT.md` "Fatal errors only for unrecoverable
- * structural corruption": anything less severe MUST be a Tier-2 warning
- * (see `./warnings.ts`). Consumers narrow on `err.code` to react to
- * specific structural failures.
- *
- * @example
- * ```ts
- * import { parseDicom, FATAL_CODES, DicomParseError } from "@cosyte/dicom";
- * try {
- *   parseDicom(Buffer.alloc(0));
- * } catch (err) {
- *   if (err instanceof DicomParseError && err.code === FATAL_CODES.EMPTY_INPUT) {
- *     // handle empty input
- *   }
- * }
- * ```
- */
-declare const FATAL_CODES: {
-    readonly NOT_DICOM_PART_10: "NOT_DICOM_PART_10";
-    readonly INVALID_FILE_META: "INVALID_FILE_META";
-    readonly UNSUPPORTED_TRANSFER_SYNTAX: "UNSUPPORTED_TRANSFER_SYNTAX";
-    readonly EMPTY_INPUT: "EMPTY_INPUT";
-};
-/**
- * Discriminant type for `DicomParseError.code`. Narrowing a caught error
- * by this code lets consumers write exhaustive `switch` blocks (enabled
- * by the `switch-exhaustiveness-check` lint rule) and guarantees a
- * typo-free comparison against the `FATAL_CODES` registry.
- *
- * @example
- * ```ts
- * import type { FatalCode } from "@cosyte/dicom";
- * function describe(code: FatalCode): string {
- *   switch (code) {
- *     case "EMPTY_INPUT":
- *       return "input was empty";
- *     case "NOT_DICOM_PART_10":
- *       return "input is not a DICOM Part 10 file";
- *     case "INVALID_FILE_META":
- *       return "File Meta group is missing or malformed";
- *     case "UNSUPPORTED_TRANSFER_SYNTAX":
- *       return "Transfer Syntax UID is not supported by v1";
- *   }
- * }
- * ```
- */
-type FatalCode = (typeof FATAL_CODES)[keyof typeof FATAL_CODES];
-/**
- * Thrown by `parseDicom` when the input violates one of the four
- * unrecoverable Tier-3 structural rules - or, under `{ strict: true }`,
- * when any Tier-2 warning is escalated through the single `emit`
- * chokepoint (D-35). Carries byte-offset positional context plus a short
- * source snippet so consumers can log actionable errors.
- *
- * Message format: `[CODE] msg (offset=N)`, with `… in a/b/c` appended
- * when `contextPath` is provided.
- *
- * @remarks
- * Snippets may contain PHI when parsing real clinical files - redact at
- * the call site if required by your compliance posture. The library does
- * not redact snippets itself.
- *
- * @example
- * ```ts
- * import { parseDicom, DicomParseError } from "@cosyte/dicom";
- * try {
- *   parseDicom(buffer);
- * } catch (err) {
- *   if (err instanceof DicomParseError && err.code === "NOT_DICOM_PART_10") {
- *     // err.byteOffset, err.snippet, err.contextPath all available
- *   }
- * }
- * ```
- */
-declare class DicomParseError extends Error {
-    readonly code: FatalCode;
-    readonly byteOffset: number;
-    readonly snippet: string;
-    readonly contextPath: readonly string[] | undefined;
-    /**
-     * Construct a new `DicomParseError`. All fields except `contextPath` are
-     * required so every thrower populates positional context per `TOL-02`.
-     *
-     * @internal
-     */
-    constructor(code: FatalCode, message: string, byteOffset: number, snippet: string, contextPath?: readonly string[]);
-}
-
 /**
  * VR-aware value dispatch - the body behind `Element.value`.
  *
@@ -2974,10 +3100,19 @@ interface DeidentifyOptions {
      * legally carry. The Profile name is now one Value of 61 characters and each
      * active option is its own, so no option subset can exceed the maximum.
      *
-     * **Your string is not bounded here.** A value of your own longer than 64
-     * characters is written through as given, with no warning: it is yours, and
-     * splitting or truncating it would invent a record you did not write. Split it
-     * on `\` yourself if a strict receiver is in your path.
+     * **Your string is not bounded here, but it is no longer silent.** A value of
+     * your own longer than 64 characters is written through as given - it is
+     * yours, and splitting or truncating it would invent a record you did not
+     * write - and `report.warnings` carries
+     * `DICOM_DEIDENT_METHOD_VALUE_OVER_LENGTH` to say so. Split it on `\` yourself
+     * if a strict receiver is in your path. The same code covers an over-long
+     * value the **source file** wrote and this run kept, which in the common case
+     * is this library's own 76-character text from a release before the default
+     * became multi-valued. The measurement is over **bytes**: a Value of 64 bytes
+     * or fewer can never carry more than 64 characters, so it cannot miss one that
+     * is genuinely over, but PS3.5 §6.2 specifies the bound in characters rather
+     * than bytes and excludes Code Extension escape sequences from the count, so it
+     * raises on any conformant Value whose bytes outnumber its counted characters.
      *
      * PS3.15 E.1.1 says this string is "inserted in or added to" the attribute, so
      * a value the incoming Data Set already carried is kept and this one is
@@ -3016,7 +3151,9 @@ interface DeidentifyOptions {
      * When the prior value **is** kept, `report.warnings` carries
      * `DICOM_DEIDENT_METHOD_PRIOR_RETAINED`: `(0012,0063)` is not in Table E.1-1, so
      * nothing in the run inspected or redacted those bytes, and a name a sender
-     * wrote there is in output stamped `(0012,0062) = YES`.
+     * wrote there is in output stamped `(0012,0062) = YES`. That code discloses the
+     * **retention** only; the **length** of what is written, from whatever source,
+     * is disclosed by `DICOM_DEIDENT_METHOD_VALUE_OVER_LENGTH` and by nothing else.
      */
     readonly deidentificationMethod?: string;
 }
@@ -3314,4 +3451,4 @@ interface UidRemapper {
  */
 declare function makeUidRemapper(root?: string, cache?: Map<string, string>): UidRemapper;
 
-export { type AppliedAction, CODING_SCHEME_OIDS, type CodedConcept, DEFAULT_UID_ROOT, DEIDENTIFY_ERROR_CODES, DEIDENTIFY_OPTIONS, Dataset, type DefineProfileOptions, type DeidentifiedAttribute, DeidentifyError, type DeidentifyErrorCode, type DeidentifyOption, type DeidentifyOptions, type DeidentifyReport, type DeidentifyResult, type DicomDate, type DicomDateTime, DicomParseError, type DicomParseWarning, type DicomPosition, DicomSerializeError, type DicomTime, type DicomValue, DicomValueError, index as Dictionary, Element, type EmbeddedAttributeFinding, FATAL_CODES, type FatalCode, type FileMeta, type FileMetaRawElement, type FrameFunctionalGroups, type ImageView, Item, type OnWarningCallback, type OtherPatientId, type ParseOptions, type PatientView, type PersonName, type PersonNameGroup, type PrivateTagDefinition, type Profile, ProfileDefinitionError, type ProfilePrivateTags, type RealWorldValueMap, SERIALIZE_ERROR_CODES, Sequence, type SerializeErrorCode, type SeriesView, type StudyView, type UidRemapper, type UnauditableSequenceFinding, type UndefinedVrFinding, VALUE_ERROR_CODES, VERSION, type ValueErrorCode, WARNING_CODES, type WarningCode, codingSchemeOid, decodeElementValue, decodeText, defineProfile, deidentify, isKnownCharsetTerm, makeUidRemapper, parseDate, parseDateTime, parseDicom, parsePersonName, parseSpecificCharacterSet, parseTime, profiles, readCode, resolveDecoderLabel, serializeDicom };
+export { type AppliedAction, CODING_SCHEME_OIDS, type CodedConcept, DEFAULT_UID_ROOT, DEIDENTIFY_ERROR_CODES, DEIDENTIFY_OPTIONS, Dataset, type DefineProfileOptions, type DeidentifiedAttribute, DeidentifyError, type DeidentifyErrorCode, type DeidentifyOption, type DeidentifyOptions, type DeidentifyReport, type DeidentifyResult, type DicomDate, type DicomDateTime, DicomParseError, type DicomParseWarning, type DicomPosition, DicomSerializeError, type DicomTime, type DicomValue, DicomValueError, index as Dictionary, Element, type EmbeddedAttributeFinding, FATAL_CODES, type FatalCode, type FileMeta, type FileMetaRawElement, type FrameFunctionalGroups, type ImageView, Item, OFFSET_FRAMES, type OffsetFrame, type OnWarningCallback, type OtherPatientId, type ParseOptions, type PatientView, type PersonName, type PersonNameGroup, type PrivateTagDefinition, type Profile, ProfileDefinitionError, type ProfilePrivateTags, type RealWorldValueMap, SERIALIZE_ERROR_CODES, Sequence, type SerializeErrorCode, type SeriesView, type StudyView, type UidRemapper, type UnauditableSequenceFinding, type UndefinedVrFinding, VALUE_ERROR_CODES, VERSION, type ValueErrorCode, WARNING_CODES, type WarningCode, codingSchemeOid, decodeElementValue, decodeText, defineProfile, deidentify, isKnownCharsetTerm, makeUidRemapper, parseDate, parseDateTime, parseDicom, parsePersonName, parseSpecificCharacterSet, parseTime, profiles, readCode, resolveDecoderLabel, serializeDicom };