@conform-ed/qti-xml 0.0.16

package/src/serialize-document.ts

@@ -0,0 +1,89 @@
+/**
+ * Universal QTI serialization dispatch: given a (version, schema-selection-key) and a
+ * normalized document, emit the spec-valid XML instance against the matching binding.
+ * The inverse of normalizeQtiDocument — delegating to the per-binding serializers
+ * (ASI, manifest, results, usage data, PNP), each gated by its own export round trip.
+ */
+
+import {
+  serializeQtiAssessmentItem,
+  serializeQtiAssessmentSection,
+  serializeQtiAssessmentStimulus,
+  serializeQtiAssessmentTest,
+  serializeQtiOutcomeDeclarationDocument,
+  serializeQtiOutcomeProcessingDocument,
+  serializeQtiResponseProcessingDocument,
+} from "./serialize-asi";
+import { serializeQtiManifest, serializeQtiMetadata } from "./serialize-manifest";
+import { serializeQtiAccessForAllPnp, serializeQtiAccessForAllPnpRecords } from "./serialize-pnp";
+import { serializeQtiAssessmentResult } from "./serialize-result";
+import { serializeQtiUsageData } from "./serialize-usage-data";
+import type { QtiSchemaSelectionKey, QtiVersion } from "./types";
+
+/** Roots with a serializer registered (the export-conformant direction). */
+export function isSerializationImplemented(version: QtiVersion, key: QtiSchemaSelectionKey): boolean {
+  if (version === "2.2") {
+    // The v2.2 usage data binding is structurally identical to the v3 one.
+    return key === "qtiUsageDataDocument";
+  }
+  switch (key) {
+    case "qtiAssessmentItemDocument":
+    case "qtiAssessmentTestDocument":
+    case "qtiAssessmentStimulusDocument":
+    case "qtiAssessmentSectionDocument":
+    case "qtiResponseProcessingDocument":
+    case "qtiOutcomeDeclarationDocument":
+    case "qtiOutcomeProcessingDocument":
+    case "qtiMetadataDocument":
+    case "qtiManifestDocument":
+    case "qtiAssessmentResultDocument":
+    case "qtiUsageDataDocument":
+    case "qtiAccessForAllPnpDocument":
+    case "qtiAccessForAllPnpRecordsDocument":
+      return true;
+    default:
+      return false;
+  }
+}
+
+export function serializeQtiDocument(version: QtiVersion, key: QtiSchemaSelectionKey, document: unknown): string {
+  if (version === "2.2") {
+    if (key === "qtiUsageDataDocument") {
+      return serializeQtiUsageData(document as never);
+    }
+    throw new Error(`Serialization is not implemented for ${version} ${key}.`);
+  }
+
+  switch (key) {
+    case "qtiAssessmentItemDocument":
+      return serializeQtiAssessmentItem(document);
+    case "qtiAssessmentTestDocument":
+      return serializeQtiAssessmentTest(document);
+    case "qtiAssessmentStimulusDocument":
+      return serializeQtiAssessmentStimulus(document);
+    case "qtiAssessmentSectionDocument":
+      return serializeQtiAssessmentSection(document);
+    case "qtiResponseProcessingDocument":
+      return serializeQtiResponseProcessingDocument(document);
+    case "qtiOutcomeDeclarationDocument":
+      return serializeQtiOutcomeDeclarationDocument(document);
+    case "qtiOutcomeProcessingDocument":
+      return serializeQtiOutcomeProcessingDocument(document);
+    case "qtiMetadataDocument":
+      return serializeQtiMetadata(document);
+    case "qtiManifestDocument":
+      return serializeQtiManifest(document);
+    case "qtiAssessmentResultDocument":
+      return serializeQtiAssessmentResult(document as never);
+    case "qtiUsageDataDocument":
+      return serializeQtiUsageData(document as never);
+    case "qtiAccessForAllPnpDocument":
+      return serializeQtiAccessForAllPnp(document as never);
+    case "qtiAccessForAllPnpRecordsDocument":
+      return serializeQtiAccessForAllPnpRecords(document as never);
+    default:
+      // Exhaustive for v3: `key` is `never` here, so every binding the normalizer
+      // reads has a writer. A future key lands as a compile error on this line.
+      throw new Error(`Serialization is not implemented for ${version} ${String(key)}.`);
+  }
+}

package/src/serialize-manifest.ts

@@ -0,0 +1,215 @@
+/**
+ * QTI 3 content-package manifest + qtiMetadata XML serialization — the export
+ * direction of the packaging binding (imscp_v1p1) and the metadata binding
+ * (imsqti_metadata_v3p0). Inverse of normalizeQti301Manifest / mapV3QtiMetadata;
+ * IEEE LOM rides through as a structurally preserved foreign-XML node. Gated by the
+ * corpus model round trip.
+ */
+
+import { XmlWriter, type AttributeValue } from "./xml-writer";
+
+const manifestNamespace = "http://www.imsglobal.org/xsd/qti/qtiv3p0/imscp_v1p1";
+const metadataNamespace = "http://www.imsglobal.org/xsd/imsqti_metadata_v3p0";
+
+type Node = Record<string, unknown>;
+type Attrs = ReadonlyArray<readonly [string, AttributeValue]>;
+
+function asNode(value: unknown): Node {
+  return (value ?? {}) as Node;
+}
+
+function str(node: Node, key: string): string | undefined {
+  const value = node[key];
+  return typeof value === "string" ? value : undefined;
+}
+
+function nodes(node: Node, key: string): Node[] {
+  const value = node[key];
+  return Array.isArray(value) ? value.map((entry) => asNode(entry)) : [];
+}
+
+function texts(node: Node, key: string): string[] {
+  const value = node[key];
+  return Array.isArray(value) ? value.map((entry) => String(entry)) : [];
+}
+
+function boolText(node: Node, key: string): string | undefined {
+  const value = node[key];
+  return typeof value === "boolean" ? String(value) : undefined;
+}
+
+/** A foreign-XML node (the preserved LOM): redeclare its namespace and recurse. */
+function writeForeignNode(writer: XmlWriter, node: Node, ambient: string): void {
+  const name = str(node, "name") ?? "span";
+  const namespace = str(node, "namespace");
+  const attributes: Array<readonly [string, AttributeValue]> = Object.entries(
+    (node["attributes"] ?? {}) as Record<string, string>,
+  );
+
+  let childAmbient = ambient;
+  if (namespace !== undefined && namespace !== ambient) {
+    attributes.push(["xmlns", namespace]);
+    childAmbient = namespace;
+  }
+
+  const children = node["children"];
+  if (Array.isArray(children) && children.length) {
+    writer.element(name, attributes, () => {
+      for (const child of children) {
+        if (typeof child === "string") {
+          writer.text(child);
+        } else {
+          writeForeignNode(writer, asNode(child), childAmbient);
+        }
+      }
+    });
+    return;
+  }
+
+  const value = str(node, "value");
+  if (value !== undefined) {
+    writer.element(name, attributes, value);
+    return;
+  }
+
+  writer.element(name, attributes);
+}
+
+/** The qtiMetadata camelCase binding, shared by manifests and standalone documents. */
+function writeQtiMetadataBody(writer: XmlWriter, metadata: Node): void {
+  const itemTemplate = boolText(metadata, "itemTemplate");
+  if (itemTemplate !== undefined) {
+    writer.element("itemTemplate", [], itemTemplate);
+  }
+  const timeDependent = boolText(metadata, "timeDependent");
+  if (timeDependent !== undefined) {
+    writer.element("timeDependent", [], timeDependent);
+  }
+  const composite = boolText(metadata, "composite");
+  if (composite !== undefined) {
+    writer.element("composite", [], composite);
+  }
+  for (const interactionType of texts(metadata, "interactionType")) {
+    writer.element("interactionType", [], interactionType);
+  }
+  const pciContext = metadata["portableCustomInteractionContext"];
+  if (pciContext) {
+    const context = asNode(pciContext);
+    writer.element("portableCustomInteractionContext", [], () => {
+      const customTypeIdentifier = str(context, "customTypeIdentifier");
+      if (customTypeIdentifier !== undefined) {
+        writer.element("customTypeIdentifier", [], customTypeIdentifier);
+      }
+      const interactionKind = str(context, "interactionKind");
+      if (interactionKind !== undefined) {
+        writer.element("interactionKind", [], interactionKind);
+      }
+    });
+  }
+  const feedbackType = str(metadata, "feedbackType");
+  if (feedbackType !== undefined) {
+    writer.element("feedbackType", [], feedbackType);
+  }
+  const solutionAvailable = boolText(metadata, "solutionAvailable");
+  if (solutionAvailable !== undefined) {
+    writer.element("solutionAvailable", [], solutionAvailable);
+  }
+  for (const scoringMode of texts(metadata, "scoringMode")) {
+    writer.element("scoringMode", [], scoringMode);
+  }
+  const toolName = str(metadata, "toolName");
+  if (toolName !== undefined) {
+    writer.element("toolName", [], toolName);
+  }
+  const toolVersion = str(metadata, "toolVersion");
+  if (toolVersion !== undefined) {
+    writer.element("toolVersion", [], toolVersion);
+  }
+  const toolVendor = str(metadata, "toolVendor");
+  if (toolVendor !== undefined) {
+    writer.element("toolVendor", [], toolVendor);
+  }
+}
+
+/** The qtiMetadata + LOM pair carried by manifest and resource metadata. */
+function writeResourceMetadataBody(writer: XmlWriter, metadata: Node, ambient: string): void {
+  const qtiMetadata = metadata["qtiMetadata"];
+  if (qtiMetadata) {
+    writer.element("qtiMetadata", [], () => writeQtiMetadataBody(writer, asNode(qtiMetadata)));
+  }
+  const lom = metadata["lom"];
+  if (lom) {
+    writeForeignNode(writer, asNode(lom), ambient);
+  }
+}
+
+/** Serialize a standalone qtiMetadata document. */
+export function serializeQtiMetadata(document: unknown): string {
+  const metadata = asNode(asNode(document)["qtiMetadata"]);
+  const writer = new XmlWriter();
+  writer.line('<?xml version="1.0" encoding="UTF-8"?>');
+
+  writer.element(
+    "qtiMetadata",
+    [
+      ["xmlns", metadataNamespace],
+      ["xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance"],
+    ],
+    () => writeQtiMetadataBody(writer, metadata),
+  );
+
+  return writer.toString();
+}
+
+/** Serialize a QTI 3 content-package manifest. */
+export function serializeQtiManifest(document: unknown): string {
+  const manifest = asNode(asNode(document)["manifest"]);
+  const metadata = asNode(manifest["metadata"]);
+  const writer = new XmlWriter();
+  writer.line('<?xml version="1.0" encoding="UTF-8"?>');
+
+  const rootAttributes: Attrs = [
+    ["xmlns", manifestNamespace],
+    ["xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance"],
+    ["identifier", str(manifest, "identifier")],
+  ];
+
+  writer.element("manifest", rootAttributes, () => {
+    writer.element("metadata", [], () => {
+      writer.element("schema", [], str(metadata, "schema") ?? "");
+      writer.element("schemaversion", [], str(metadata, "schemaVersion") ?? "");
+      writeResourceMetadataBody(writer, metadata, manifestNamespace);
+    });
+
+    writer.element("organizations", []);
+
+    writer.element("resources", [], () => {
+      for (const resource of nodes(manifest, "resources")) {
+        writer.element(
+          "resource",
+          [
+            ["identifier", str(resource, "identifier")],
+            ["type", str(resource, "type")],
+            ["href", str(resource, "href")],
+          ],
+          () => {
+            const resourceMetadata = resource["metadata"];
+            if (resourceMetadata) {
+              writer.element("metadata", [], () =>
+                writeResourceMetadataBody(writer, asNode(resourceMetadata), manifestNamespace),
+              );
+            }
+            for (const file of nodes(resource, "files")) {
+              writer.element("file", [["href", str(file, "href")]]);
+            }
+            for (const dependency of nodes(resource, "dependencies")) {
+              writer.element("dependency", [["identifierref", str(dependency, "identifierRef")]]);
+            }
+          },
+        );
+      }
+    });
+  });
+
+  return writer.toString();
+}

package/src/serialize-pnp.ts

@@ -0,0 +1,385 @@
+/**
+ * AfA PNP (QTI 3.0 profile) XML serialization (imsqtiv3p0_afa3p0pnp_v1p0) — the
+ * export direction of the candidate-preferences binding, the exact inverse of the
+ * import normalizer; gated in tests by the round trip through our own parser,
+ * normalizer, and strict contracts schema.
+ */
+
+import type {
+  QtiAccessForAllPnp,
+  QtiAccessForAllPnpDocument,
+  QtiAccessForAllPnpRecordsDocument,
+  QtiPnpFeatureSet,
+  QtiPnpReplaceAccessMode,
+} from "@conform-ed/contracts/qti/v3_0_1";
+
+import { XmlWriter, type AttributeValue } from "./xml-writer";
+
+const pnpNamespace = "http://www.imsglobal.org/xsd/qti/qtiv3p0/imsafa3p0pnp_v1p0";
+const pnpSchemaLocation = `${pnpNamespace} https://purl.imsglobal.org/spec/qti/v3p0/schema/xsd/imsqtiv3p0_afa3p0pnp_v1p0.xsd`;
+
+function writeReplaceModes(writer: XmlWriter, view: QtiPnpReplaceAccessMode | undefined): void {
+  for (const mode of view?.replaceAccessModes ?? []) {
+    writer.element(`replace-access-mode-${mode}`, []);
+  }
+}
+
+/** A ReplacesAccessMode container: empty element, or replace-mode children. */
+function replaceModeElement(
+  writer: XmlWriter,
+  name: string,
+  view: QtiPnpReplaceAccessMode | undefined,
+  attributes: ReadonlyArray<readonly [string, AttributeValue]> = [],
+  body?: () => void,
+): void {
+  if (!view) {
+    return;
+  }
+
+  const hasChildren = (view.replaceAccessModes?.length ?? 0) > 0 || body !== undefined;
+
+  if (!hasChildren) {
+    writer.element(name, attributes);
+    return;
+  }
+
+  writer.element(name, attributes, () => {
+    writeReplaceModes(writer, view);
+    body?.();
+  });
+}
+
+function featureSetElement(writer: XmlWriter, name: string, view: QtiPnpFeatureSet | undefined): void {
+  if (!view) {
+    return;
+  }
+
+  if (!view.features?.length) {
+    writer.element(name, []);
+    return;
+  }
+
+  writer.element(name, [], () => {
+    for (const feature of view.features ?? []) {
+      writer.element(feature, []);
+    }
+  });
+}
+
+function writePnpBody(writer: XmlWriter, pnp: QtiAccessForAllPnp): void {
+  for (const hazard of pnp.hazardAvoidance ?? []) {
+    writer.element("hazard-avoidance", [], hazard);
+  }
+
+  if (pnp.inputRequirements !== undefined) {
+    writer.element("input-requirements", [], pnp.inputRequirements);
+  }
+
+  for (const language of pnp.languageOfInterface ?? []) {
+    replaceModeElement(writer, "language-of-interface", language, [["xml:lang", language.xmlLang]]);
+  }
+
+  replaceModeElement(writer, "linguistic-guidance", pnp.linguisticGuidance);
+  replaceModeElement(writer, "keyword-emphasis", pnp.keywordEmphasis);
+  replaceModeElement(
+    writer,
+    "keyword-translation",
+    pnp.keywordTranslation,
+    pnp.keywordTranslation ? [["xml:lang", pnp.keywordTranslation.xmlLang]] : [],
+  );
+  replaceModeElement(writer, "simplified-language-portions", pnp.simplifiedLanguagePortions);
+  replaceModeElement(writer, "simplified-graphics", pnp.simplifiedGraphics);
+  replaceModeElement(
+    writer,
+    "item-translation",
+    pnp.itemTranslation,
+    pnp.itemTranslation ? [["xml:lang", pnp.itemTranslation.xmlLang]] : [],
+  );
+  replaceModeElement(
+    writer,
+    "sign-language",
+    pnp.signLanguage,
+    pnp.signLanguage ? [["xml:lang", pnp.signLanguage.xmlLang]] : [],
+  );
+  replaceModeElement(writer, "encouragement", pnp.encouragement);
+
+  const time = pnp.additionalTestingTime;
+  if (time) {
+    replaceModeElement(writer, "additional-testing-time", time, [], () => {
+      if (time.timeMultiplier !== undefined) {
+        writer.element("time-multiplier", [], String(time.timeMultiplier));
+      }
+      if (time.fixedMinutes !== undefined) {
+        writer.element("fixed-minutes", [], String(time.fixedMinutes));
+      }
+      if (time.unlimited === true) {
+        writer.element("unlimited", []);
+      }
+    });
+  }
+
+  replaceModeElement(
+    writer,
+    "line-reader",
+    pnp.lineReader,
+    pnp.lineReader ? [["highlight-color", pnp.lineReader.highlightColor]] : [],
+  );
+  replaceModeElement(
+    writer,
+    "invert-display-polarity",
+    pnp.invertDisplayPolarity,
+    pnp.invertDisplayPolarity
+      ? [
+          ["foreground", pnp.invertDisplayPolarity.foreground],
+          ["background", pnp.invertDisplayPolarity.background],
+        ]
+      : [],
+  );
+
+  const magnification = pnp.magnification;
+  if (magnification) {
+    replaceModeElement(writer, "magnification", magnification, [], () => {
+      if (magnification.allContent) {
+        writer.element("all-content", [["zoom-amount", magnification.allContent.zoomAmount]]);
+      }
+      if (magnification.text) {
+        writer.element("text", [["zoom-amount", magnification.text.zoomAmount]]);
+      }
+      if (magnification.nonText) {
+        writer.element("non-text", [["zoom-amount", magnification.nonText.zoomAmount]]);
+      }
+    });
+  }
+
+  const spoken = pnp.spoken;
+  if (spoken) {
+    replaceModeElement(writer, "spoken", spoken, [], () => {
+      if (spoken.readingType !== undefined) {
+        writer.element("reading-type", [], spoken.readingType);
+      }
+      for (const restriction of spoken.restrictionTypes ?? []) {
+        writer.element("restriction-type", [], restriction);
+      }
+      if (spoken.speechRate !== undefined) {
+        writer.element("speech-rate", [], String(spoken.speechRate));
+      }
+      if (spoken.pitch !== undefined) {
+        writer.element("pitch", [], String(spoken.pitch));
+      }
+      if (spoken.volume !== undefined) {
+        writer.element("volume", [], String(spoken.volume));
+      }
+      if (spoken.linkIndication !== undefined) {
+        writer.element("link-indication", [], spoken.linkIndication);
+      }
+      if (spoken.typingEcho !== undefined) {
+        writer.element("typing-echo", [], spoken.typingEcho);
+      }
+    });
+  }
+
+  replaceModeElement(writer, "tactile", pnp.tactile);
+
+  const braille = pnp.braille;
+  if (braille) {
+    const hasChildren =
+      braille.deliveryMode !== undefined ||
+      braille.grade !== undefined ||
+      braille.brailleType !== undefined ||
+      braille.mathType !== undefined;
+
+    replaceModeElement(
+      writer,
+      "braille",
+      braille,
+      [["xml:lang", braille.xmlLang]],
+      hasChildren
+        ? () => {
+            if (braille.deliveryMode !== undefined) {
+              writer.element("delivery-mode", [], braille.deliveryMode);
+            }
+            if (braille.grade !== undefined) {
+              writer.element("grade", [], braille.grade);
+            }
+            if (braille.brailleType !== undefined) {
+              writer.element("braille-type", [], braille.brailleType);
+            }
+            if (braille.mathType !== undefined) {
+              writer.element("math-type", [], braille.mathType);
+            }
+          }
+        : undefined,
+    );
+  }
+
+  replaceModeElement(writer, "answer-masking", pnp.answerMasking);
+  replaceModeElement(writer, "keyboard-directions", pnp.keyboardDirections);
+  replaceModeElement(writer, "additional-directions", pnp.additionalDirections);
+  replaceModeElement(
+    writer,
+    "long-description",
+    pnp.longDescription,
+    pnp.longDescription ? [["hide-visually", pnp.longDescription.hideVisually]] : [],
+  );
+  replaceModeElement(writer, "captions", pnp.captions);
+
+  const environment = pnp.environment;
+  if (environment) {
+    const hasChildren =
+      environment.description !== undefined ||
+      environment.medical !== undefined ||
+      environment.software !== undefined ||
+      environment.hardware !== undefined ||
+      environment.breaks !== undefined;
+
+    replaceModeElement(
+      writer,
+      "environment",
+      environment,
+      [],
+      hasChildren
+        ? () => {
+            if (environment.description !== undefined) {
+              writer.element("description", [], environment.description);
+            }
+            if (environment.medical !== undefined) {
+              writer.element("medical", [], environment.medical);
+            }
+            if (environment.software !== undefined) {
+              writer.element("software", [], environment.software);
+            }
+            if (environment.hardware !== undefined) {
+              writer.element("hardware", [], environment.hardware);
+            }
+            if (environment.breaks !== undefined) {
+              writer.element("breaks", [], String(environment.breaks));
+            }
+          }
+        : undefined,
+    );
+  }
+
+  replaceModeElement(writer, "transcript", pnp.transcript);
+  replaceModeElement(writer, "alternative-text", pnp.alternativeText);
+  replaceModeElement(writer, "audio-description", pnp.audioDescription);
+  replaceModeElement(writer, "high-contrast", pnp.highContrast);
+  replaceModeElement(writer, "layout-single-column", pnp.layoutSingleColumn);
+
+  const textAppearance = pnp.textAppearance;
+  if (textAppearance) {
+    replaceModeElement(writer, "text-appearance", textAppearance, [], () => {
+      if (textAppearance.backgroundColor !== undefined) {
+        writer.element("background-color", [], textAppearance.backgroundColor);
+      }
+      if (textAppearance.fontColor !== undefined) {
+        writer.element("font-color", [], textAppearance.fontColor);
+      }
+      if (textAppearance.fontSize !== undefined) {
+        writer.element("font-size", [], String(textAppearance.fontSize));
+      }
+      if (textAppearance.fontFace) {
+        writer.element("font-face", [], () => {
+          for (const fontName of textAppearance.fontFace?.fontName ?? []) {
+            writer.element("font-name", [], fontName);
+          }
+          if (textAppearance.fontFace?.genericFontFace !== undefined) {
+            writer.element("generic-font-face", [], textAppearance.fontFace.genericFontFace);
+          }
+        });
+      }
+      if (textAppearance.lineSpacing !== undefined) {
+        writer.element("line-spacing", [], String(textAppearance.lineSpacing));
+      }
+      if (textAppearance.lineHeight !== undefined) {
+        writer.element("line-height", [], String(textAppearance.lineHeight));
+      }
+      if (textAppearance.letterSpacing !== undefined) {
+        writer.element("letter-spacing", [], String(textAppearance.letterSpacing));
+      }
+      if (textAppearance.uniformFontSizing === true) {
+        writer.element("uniform-font-sizing", []);
+      }
+      if (textAppearance.wordSpacing !== undefined) {
+        writer.element("word-spacing", [], String(textAppearance.wordSpacing));
+      }
+      if (textAppearance.wordWrapping === true) {
+        writer.element("word-wrapping", []);
+      }
+    });
+  }
+
+  if (pnp.calculatorOnScreen) {
+    writer.element("calculator-on-screen", [["calculator-type", pnp.calculatorOnScreen.calculatorType]]);
+  }
+
+  const onScreenFlags: ReadonlyArray<readonly [string, boolean | undefined]> = [
+    ["dictionary-on-screen", pnp.dictionaryOnScreen],
+    ["glossary-on-screen", pnp.glossaryOnScreen],
+    ["thesaurus-on-screen", pnp.thesaurusOnScreen],
+    ["homophone-checker-on-screen", pnp.homophoneCheckerOnScreen],
+    ["note-taking-on-screen", pnp.noteTakingOnScreen],
+    ["visual-organizer-on-screen", pnp.visualOrganizerOnScreen],
+    ["outliner-on-screen", pnp.outlinerOnScreen],
+    ["peer-interaction-on-screen", pnp.peerInteractionOnScreen],
+    ["spell-checker-on-screen", pnp.spellCheckerOnScreen],
+  ];
+  for (const [name, enabled] of onScreenFlags) {
+    if (enabled === true) {
+      writer.element(name, []);
+    }
+  }
+
+  featureSetElement(writer, "activate-at-initialization-set", pnp.activateAtInitializationSet);
+  featureSetElement(writer, "activate-as-option-set", pnp.activateAsOptionSet);
+  featureSetElement(writer, "prohibit-set", pnp.prohibitSet);
+}
+
+/** Serialize a candidate-preferences document against the official QTI 3 profile binding. */
+export function serializeQtiAccessForAllPnp(document: QtiAccessForAllPnpDocument): string {
+  const writer = new XmlWriter();
+
+  writer.line('<?xml version="1.0" encoding="UTF-8"?>');
+  writer.element(
+    "access-for-all-pnp",
+    [
+      ["xmlns", pnpNamespace],
+      ["xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance"],
+      ["xsi:schemaLocation", pnpSchemaLocation],
+    ],
+    () => writePnpBody(writer, document.accessForAllPnp),
+  );
+
+  return writer.toString();
+}
+
+/** Serialize a person-keyed PNP records document. */
+export function serializeQtiAccessForAllPnpRecords(document: QtiAccessForAllPnpRecordsDocument): string {
+  const writer = new XmlWriter();
+
+  writer.line('<?xml version="1.0" encoding="UTF-8"?>');
+  writer.element(
+    "access-for-all-pnp-records",
+    [
+      ["xmlns", pnpNamespace],
+      ["xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance"],
+      ["xsi:schemaLocation", pnpSchemaLocation],
+    ],
+    () => {
+      for (const record of document.accessForAllPnpRecords.records) {
+        writer.element("access-for-all-pnp-record", [], () => {
+          writer.element(
+            "person-sourced-id",
+            [["source-system", record.personSourcedId.sourceSystem]],
+            record.personSourcedId.value,
+          );
+          for (const appointment of record.appointmentId ?? []) {
+            writer.element("appointment-id", [], appointment);
+          }
+          writer.element("access-for-all-pnp", [], () => writePnpBody(writer, record.accessForAllPnp));
+        });
+      }
+    },
+  );
+
+  return writer.toString();
+}