@petrarca/sonnet-core 0.7.0 → 0.9.0

package/dist/schema/index.js

@@ -1,11 +1,11 @@
-import {
-  warnLog
-} from "../chunk-XAEHYRXC.js";
 import {
   FORM_ITEM_ID_FIELD,
   generateId,
   isEqual
 } from "../chunk-XCCOEUVC.js";
+import {
+  warnLog
+} from "../chunk-LOWDCP73.js";
 
 // src/schema/types.ts
 var WIDTH_TOKEN_REMS = {
@@ -41,18 +41,34 @@ function isNullableBoolean(property) {
   const hasNull = property.anyOf.some((s) => s.type === "null");
   return hasBoolean && hasNull;
 }
-function extractEnumValues(property) {
-  if (Array.isArray(property.enum) && property.enum.length > 0) {
-    return property.enum;
+var LIFTABLE_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "array"
+]);
+function liftNullableMember(property) {
+  const members = property.anyOf;
+  if (!Array.isArray(members) || members.length !== 2) return property;
+  const nonNull = members.filter((m) => m.type !== "null");
+  if (nonNull.length !== 1) return property;
+  const [member] = nonNull;
+  if (typeof member.type !== "string" || !LIFTABLE_TYPES.has(member.type)) {
+    return property;
   }
-  if (Array.isArray(property.anyOf)) {
-    for (const branch of property.anyOf) {
-      if (Array.isArray(branch.enum) && branch.enum.length > 0) {
-        return branch.enum;
-      }
-    }
-  }
-  return [];
+  return { ...member, ...property };
+}
+function extractEnumValues(property) {
+  const candidates = [
+    property.enum,
+    property.type === "array" ? property.items?.enum : void 0,
+    ...(property.anyOf ?? []).map((branch) => branch.enum)
+  ];
+  return candidates.find(isNonEmptyEnum) ?? [];
+}
+function isNonEmptyEnum(values) {
+  return Array.isArray(values) && values.length > 0;
 }
 function getFieldTitle(fieldName, property) {
   return property["x-ui-title"] || property.title || fieldName;
@@ -147,9 +163,31 @@ var ajv = new Ajv({
   strict: false,
   validateFormats: true,
   // Allow unknown keywords (for x-ui-widget, x-ui-title, etc.)
-  strictSchema: false
+  strictSchema: false,
+  // Enable $data references so a keyword can reference another field's value,
+  // e.g. { "const": { "$data": "1/password" } } for "must equal password".
+  // This is the declarative path for simple cross-field rules (see the
+  // custom-validation design); complex cross-field logic uses form validators.
+  $data: true
 });
 addFormats(ajv);
+var TIME_OF_DAY = /^([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d)(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})?$/i;
+function secondsOf(time) {
+  const m = TIME_OF_DAY.exec(time);
+  if (!m) return void 0;
+  return Number(m[1]) * 3600 + Number(m[2]) * 60 + Number(m[3] ?? 0);
+}
+ajv.addFormat("time", {
+  type: "string",
+  validate: (time) => TIME_OF_DAY.test(time),
+  // What formatMinimum / formatMaximum compare by.
+  compare: (a, b) => {
+    const x = secondsOf(a);
+    const y = secondsOf(b);
+    if (x === void 0 || y === void 0) return void 0;
+    return x === y ? 0 : x < y ? -1 : 1;
+  }
+});
 function resolveSchema(schema, formData) {
   if (!schema || typeof schema !== "object") {
     return schema;
@@ -335,25 +373,26 @@ function evaluateUiRule(rule, formData) {
 }
 
 // src/schema/schemaUtils.ts
+var isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isGroup = (p) => !!p.properties && p.default === void 0;
+function groupFilled(value, property) {
+  if (!isGroup(property) || value !== void 0 && !isPlainObject(value))
+    return void 0;
+  const filled = applySchemaDefaults(value ?? {}, property);
+  return value !== void 0 || Object.keys(filled).length > 0 ? filled : void 0;
+}
 function applySchemaDefaults(data, schema) {
   const result = { ...data };
   const properties = schema.properties ?? {};
   for (const [fieldName, property] of Object.entries(properties)) {
-    if (result[fieldName] === void 0 && property.default !== void 0) {
-      result[fieldName] = property.default;
-    }
+    const value = result[fieldName];
+    const filled = value === void 0 && property.default !== void 0 ? property.default : groupFilled(value, property);
+    if (filled !== void 0) result[fieldName] = filled;
   }
   return result;
 }
 function extractSchemaDefaults(schema) {
-  const defaults = {};
-  const properties = schema.properties ?? {};
-  for (const [fieldName, property] of Object.entries(properties)) {
-    if (property.default !== void 0) {
-      defaults[fieldName] = property.default;
-    }
-  }
-  return defaults;
+  return applySchemaDefaults({}, schema);
 }
 function generateJsonSchemaFromVariables(variables, existingSchema) {
   const existingProperties = existingSchema?.properties ?? {};
@@ -386,6 +425,268 @@ function toJsonSchema(schema) {
   });
 }
 
+// src/schema/coreTypes.ts
+var CORE_TYPES_BASE = "https://schemas.petrarca-labs.com/core/";
+var QUANTITY_TYPE_ID = `${CORE_TYPES_BASE}quantity/v1`;
+var UCUM_SYSTEM = "http://unitsofmeasure.org";
+var QUANTITY_DEFINITION = {
+  type: "object",
+  title: "Quantity",
+  properties: {
+    value: { type: "number", title: "Value" },
+    unit: { type: "string", title: "Unit", minLength: 1 },
+    system: { type: "string", title: "Unit system", format: "uri" },
+    comparator: {
+      type: "string",
+      title: "Comparator",
+      enum: ["<", "<=", ">=", ">"]
+    }
+  },
+  required: ["value", "unit"],
+  additionalProperties: false,
+  // Shown as a quantity wherever it is used: a number and its unit.
+  "x-ui-widget": "quantity"
+};
+var QUANTITY_TYPE = {
+  id: QUANTITY_TYPE_ID,
+  label: "Quantity",
+  definition: QUANTITY_DEFINITION
+};
+var CODING_TYPE_ID = `${CORE_TYPES_BASE}coding/v1`;
+function codingKey(c) {
+  return `${c.system ?? ""}|${c.code}`;
+}
+var CODING_DEFINITION = {
+  type: "object",
+  title: "Coded value",
+  properties: {
+    system: { type: "string", title: "Code system", minLength: 1 },
+    code: { type: "string", title: "Code", minLength: 1 },
+    version: { type: "string", title: "Version" },
+    display: { type: "string", title: "Label" }
+  },
+  required: ["system", "code"],
+  // Shown as a coded value wherever it is used: searched in its list.
+  "x-ui-widget": "coded-value"
+};
+var CODING_TYPE = {
+  id: CODING_TYPE_ID,
+  label: "Coded value",
+  definition: CODING_DEFINITION
+};
+var CODEABLE_CONCEPT_TYPE_ID = `${CORE_TYPES_BASE}codeable-concept/v1`;
+var { "x-ui-widget": _codingWidget, ...CODING_FIELDS } = CODING_DEFINITION;
+var CODEABLE_CONCEPT_DEFINITION = {
+  type: "object",
+  title: "Codeable concept",
+  properties: {
+    codings: {
+      type: "array",
+      title: "Codings",
+      items: {
+        ...CODING_FIELDS,
+        title: "Coding",
+        properties: {
+          ...CODING_FIELDS.properties,
+          userSelected: { type: "boolean", title: "Picked by a person" },
+          match: {
+            type: "string",
+            title: "Match",
+            enum: ["equivalent", "broader", "narrower"]
+          },
+          purpose: { ...CODING_FIELDS, title: "Purpose" }
+        }
+      }
+    },
+    text: { type: "string", title: "Text" }
+  },
+  // Shown as a codeable concept wherever it is used: a coded value per list.
+  "x-ui-widget": "codeable-concept"
+};
+var CODEABLE_CONCEPT_TYPE = {
+  id: CODEABLE_CONCEPT_TYPE_ID,
+  label: "Codeable concept",
+  definition: CODEABLE_CONCEPT_DEFINITION
+};
+var CORE_VALUE_TYPES = [
+  QUANTITY_TYPE,
+  CODING_TYPE,
+  CODEABLE_CONCEPT_TYPE
+];
+function valueTypeResolver(types) {
+  const byId = new Map(types.map((t) => [t.id, t.definition]));
+  return (ref) => byId.get(ref);
+}
+var resolveCore = valueTypeResolver(CORE_VALUE_TYPES);
+function coreType(ref) {
+  return resolveCore(ref);
+}
+function coreTypeOf(prop) {
+  return prop.$ref && resolveCore(prop.$ref) ? prop.$ref : void 0;
+}
+
+// src/schema/binding.ts
+function isAdditional(a) {
+  if (!a || typeof a !== "object") return false;
+  const { valueSet, system } = a;
+  return !!(valueSet || system);
+}
+function bindingOf(prop) {
+  const binding = prop["x-binding"];
+  if (!binding || typeof binding !== "object") return void 0;
+  const { valueSet, system, strength, additional, ...rest } = binding;
+  if (!valueSet && !system) return void 0;
+  const lists = Array.isArray(additional) ? additional.filter(isAdditional) : [];
+  return {
+    ...rest,
+    ...valueSet ? { valueSet } : {},
+    ...system ? { system } : {},
+    strength: strength === "extensible" ? "extensible" : "required",
+    ...lists.length ? { additional: lists } : {}
+  };
+}
+function bindingLists(binding) {
+  const { valueSet, system, version, title, additional = [] } = binding;
+  const first = {
+    ...valueSet ? { valueSet } : {},
+    ...system ? { system } : {},
+    ...version ? { version } : {},
+    ...title ? { title } : {}
+  };
+  return [first, ...additional];
+}
+var BAR = "|";
+function parseCodeToken(token, bound) {
+  const bar = token.lastIndexOf(BAR);
+  if (bar < 0) return { ...bound ? { system: bound } : {}, code: token };
+  return { system: token.slice(0, bar), code: token.slice(bar + 1) };
+}
+function codeToken(coding, bound) {
+  return coding.system && coding.system !== bound ? `${coding.system}${BAR}${coding.code}` : coding.code;
+}
+
+// src/schema/codeableConcept.ts
+function conceptOf(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function codingsByList(value, lists) {
+  const codings = conceptOf(value).codings ?? [];
+  const free = new Set(codings.map((_, i) => i));
+  const claim = (pick) => {
+    const i = [...free].find((j) => pick(codings[j]));
+    if (i === void 0) return void 0;
+    free.delete(i);
+    return codings[i];
+  };
+  const bySystem = lists.map(
+    (l) => l.system ? claim((c) => c.system === l.system) : void 0
+  );
+  const byList = lists.map(
+    (l, i) => l.system ? bySystem[i] : claim(() => true)
+  );
+  return { byList, others: [...free].map((i) => codings[i]) };
+}
+function listTitle(list) {
+  if (list.title) return list.title;
+  if (list.purpose) return list.purpose.display ?? list.purpose.code;
+  const id = list.system ?? list.valueSet ?? "";
+  const parts = id.replace(/^[a-z]+:\/\//i, "").split(/[/#:]/).filter(Boolean);
+  return parts.at(-1) ?? id;
+}
+function missingLists(prop, value) {
+  const binding = bindingOf(prop);
+  if (!binding?.additional?.some((l) => l.required)) return [];
+  if (!conceptOf(value).codings?.length) return [];
+  const lists = bindingLists(binding);
+  const { byList } = codingsByList(value, lists);
+  return lists.filter((l, i) => l.required && !byList[i]);
+}
+
+// src/schema/valueRef.ts
+function isPlainString(member) {
+  return Object.keys(member).length === 1 && member.type === "string";
+}
+function isPlainRef(member) {
+  return Object.keys(member).length === 1 && typeof member.$ref === "string";
+}
+function singleRefOf(prop) {
+  if (prop.$ref) return { ref: prop.$ref, orText: false };
+  const members = prop.anyOf;
+  if (!Array.isArray(members) || members.length !== 2) return void 0;
+  const [first, second] = members;
+  return isPlainRef(first) && isPlainString(second) ? { ref: first.$ref, orText: true } : void 0;
+}
+function itemRefOf(items) {
+  if (!items) return void 0;
+  const own = Object.keys(items);
+  const plain = own.length === 1 && (own[0] === "$ref" || own[0] === "anyOf");
+  return plain ? singleRefOf(items) : void 0;
+}
+function valueRefOf(prop) {
+  if (prop.type === "array") {
+    const item = itemRefOf(prop.items);
+    return item && { ...item, multiple: true };
+  }
+  const single = singleRefOf(prop);
+  return single && { ...single, multiple: false };
+}
+function singleKeywords(ref, orText) {
+  return orText ? { anyOf: [{ $ref: ref }, { type: "string" }] } : { $ref: ref };
+}
+function valueRefKeywords(ref, orText, multiple = false) {
+  const none = {
+    $ref: void 0,
+    anyOf: void 0,
+    type: void 0,
+    items: void 0
+  };
+  return multiple ? { ...none, type: "array", items: singleKeywords(ref, orText) } : { ...none, ...singleKeywords(ref, orText) };
+}
+
+// src/schema/unitRanges.ts
+function rangeEntry(unit, range) {
+  return {
+    if: { properties: { unit: { const: unit } }, required: ["unit"] },
+    then: {
+      properties: {
+        value: {
+          ...range.min !== void 0 ? { minimum: range.min } : {},
+          ...range.max !== void 0 ? { maximum: range.max } : {}
+        }
+      }
+    }
+  };
+}
+var numberOrNone = (v) => v === void 0 || typeof v === "number";
+function namedIn(entry) {
+  const value = entry.then?.properties?.value;
+  return {
+    unit: entry.if?.properties?.unit?.const,
+    min: value?.minimum,
+    max: value?.maximum
+  };
+}
+function readEntry(entry) {
+  const { unit, min, max } = namedIn(entry);
+  if (typeof unit !== "string" || !numberOrNone(min) || !numberOrNone(max))
+    return void 0;
+  const range = { min, max };
+  return isEqual(entry, rangeEntry(unit, range)) ? [unit, range] : void 0;
+}
+function unitRangesOf(prop) {
+  const ranges = {};
+  for (const entry of prop.allOf ?? []) {
+    const read = readEntry(entry);
+    if (!read) return void 0;
+    ranges[read[0]] = read[1];
+  }
+  return ranges;
+}
+function unitRangesKeywords(ranges) {
+  const entries = Object.entries(ranges).filter(([, r]) => r.min !== void 0 || r.max !== void 0).map(([unit, r]) => rangeEntry(unit, r));
+  return { allOf: entries.length ? entries : void 0 };
+}
+
 // src/schema/resolveRefs.ts
 function extractDefName(ref) {
   const match = ref.match(/^#\/(\$defs|definitions)\/(.+)$/);
@@ -397,6 +698,17 @@ function inDocumentResolver(defs) {
     return name ? defs[name] : void 0;
   };
 }
+function withOverrides(target, overrides) {
+  const merged = { ...target, ...overrides };
+  if (target.properties && overrides.properties) {
+    merged.properties = { ...target.properties };
+    for (const [key, prop] of Object.entries(overrides.properties))
+      merged.properties[key] = { ...target.properties[key], ...prop };
+  }
+  if (target.required && overrides.required)
+    merged.required = [.../* @__PURE__ */ new Set([...target.required, ...overrides.required])];
+  return merged;
+}
 function resolveRef(node, resolve, seen) {
   const ref = node.$ref;
   const resolved = resolve(ref);
@@ -406,7 +718,7 @@ function resolveRef(node, resolve, seen) {
   const overrides = Object.fromEntries(
     Object.entries(node).filter(([k]) => k !== "$ref")
   );
-  const merged = Object.keys(overrides).length > 0 ? { ...resolved, ...overrides } : resolved;
+  const merged = Object.keys(overrides).length > 0 ? withOverrides(resolved, overrides) : resolved;
   const result = resolveNode(merged, resolve, seen);
   seen.delete(ref);
   return result;
@@ -455,9 +767,8 @@ function resolveNode(node, resolve, seen) {
 }
 function resolveRefs(schema, resolve) {
   const defs = schema.$defs ?? schema.definitions ?? {};
-  if (!resolve && Object.keys(defs).length === 0) return schema;
-  const fallback = inDocumentResolver(defs);
-  const resolver = resolve ? (ref) => resolve(ref) ?? fallback(ref) : fallback;
+  const inDocument = inDocumentResolver(defs);
+  const resolver = (ref) => resolve?.(ref) ?? coreType(ref) ?? inDocument(ref);
   const seen = /* @__PURE__ */ new Set();
   const resolved = resolveNode(
     schema,
@@ -467,6 +778,76 @@ function resolveRefs(schema, resolve) {
   return resolved;
 }
 
+// src/schema/contentValidation.ts
+var OWNED_BY_VALIDATE_FORM_DATA = /* @__PURE__ */ new Set([
+  "required",
+  "minItems",
+  "maxItems"
+]);
+var WRAPPERS = /* @__PURE__ */ new Set(["if"]);
+function unescapePointerToken(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function labelForPointer(schema, pointer) {
+  if (pointer === "") return "";
+  const tokens = pointer.split("/").slice(1).map(unescapePointerToken);
+  const parts = [];
+  let node = schema;
+  for (const token of tokens) {
+    if (/^\d+$/.test(token)) {
+      if (parts.length > 0) {
+        parts[parts.length - 1] = `${parts[parts.length - 1]}[${Number(token) + 1}]`;
+      }
+      node = node?.items;
+      continue;
+    }
+    const props = node?.properties;
+    const child = props?.[token];
+    parts.push(child ? getFieldTitle(token, child) : token);
+    node = child;
+  }
+  return parts.join(" > ");
+}
+var FORMAT_RANGE = {
+  formatMinimum: "or later",
+  formatExclusiveMinimum: "later",
+  formatMaximum: "or earlier",
+  formatExclusiveMaximum: "earlier"
+};
+function messageFor(label, err) {
+  const what = label || "Value";
+  const range = FORMAT_RANGE[err.keyword];
+  const limit = err.params.limit;
+  if (range && limit !== void 0) {
+    const prefix = err.keyword.includes("Exclusive") ? `${range} than` : "";
+    return prefix ? `${what} must be ${prefix} ${String(limit)}` : `${what} must be ${String(limit)} ${range}`;
+  }
+  return `${what} ${err.message ?? "is invalid"}`;
+}
+function validateContentConstraints(schema, data) {
+  let validate;
+  try {
+    validate = ajv.compile(schema);
+  } catch {
+    return [];
+  }
+  if (validate(data)) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const err of validate.errors ?? []) {
+    if (OWNED_BY_VALIDATE_FORM_DATA.has(err.keyword) || WRAPPERS.has(err.keyword))
+      continue;
+    const pointer = err.instancePath;
+    const label = labelForPointer(schema, pointer);
+    const message = messageFor(label, err);
+    const key = `${pointer}\0${message}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ pointer, message });
+  }
+  return out;
+}
+
 // src/schema/validateFormData.ts
 function escapePointerToken(token) {
   return token.replace(/~/g, "~0").replace(/\//g, "~1");
@@ -474,7 +855,7 @@ function escapePointerToken(token) {
 function isEmpty(value) {
   return value === void 0 || value === null || value === "";
 }
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function childContext(parent, fieldName, property) {
@@ -507,7 +888,7 @@ function validateArray(property, value, ctx, out) {
   const itemProperties = property.items.properties;
   const itemSchema = property.items;
   for (let i = 0; i < value.length; i++) {
-    if (isPlainObject(value[i])) {
+    if (isPlainObject2(value[i])) {
       validateObject(
         itemProperties,
         itemSchema,
@@ -519,13 +900,18 @@ function validateArray(property, value, ctx, out) {
   }
 }
 function isNestedObject(property, value) {
-  return property.type === "object" && !!property.properties && isPlainObject(value);
+  return property.type === "object" && !!property.properties && isPlainObject2(value);
 }
 function validateField(property, value, required, ctx, out) {
   if (required && isEmpty(value)) {
     out.push({ pointer: ctx.pointer, message: `${ctx.label} is required` });
     return;
   }
+  for (const list of missingLists(property, value))
+    out.push({
+      pointer: ctx.pointer,
+      message: `${ctx.label} needs a code of ${listTitle(list)}`
+    });
   if (isNestedObject(property, value)) {
     validateObject(property.properties, property, value, ctx, out);
     return;
@@ -557,6 +943,11 @@ function validateFormData(schema, data) {
     { label: "", pointer: "" },
     fieldErrors
   );
+  const structurallyFlagged = new Set(fieldErrors.map((e) => e.pointer));
+  for (const err of validateContentConstraints(schema, data)) {
+    if (structurallyFlagged.has(err.pointer)) continue;
+    fieldErrors.push(err);
+  }
   return {
     errors: fieldErrors.map((e) => e.message),
     fieldErrors,
@@ -564,6 +955,34 @@ function validateFormData(schema, data) {
   };
 }
 
+// src/schema/mergeFieldErrors.ts
+function pointerRoot(pointer) {
+  const token = pointer.split("/")[1] ?? "";
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function mergeFieldErrors(...sources) {
+  const out = [];
+  const claimedFields = /* @__PURE__ */ new Set();
+  const seenFormMessages = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    for (const err of source) {
+      if (err.pointer === "") {
+        if (seenFormMessages.has(err.message)) continue;
+        seenFormMessages.add(err.message);
+        out.push(err);
+        continue;
+      }
+      const root = pointerRoot(err.pointer);
+      if (claimedFields.has(root)) continue;
+      out.push(err);
+    }
+    for (const err of source) {
+      if (err.pointer !== "") claimedFields.add(pointerRoot(err.pointer));
+    }
+  }
+  return out;
+}
+
 // src/schema/diffFormData.ts
 function areBothPlainObjects(a, b) {
   return a !== null && b !== null && typeof a === "object" && typeof b === "object" && !Array.isArray(a) && !Array.isArray(b);
@@ -708,14 +1127,14 @@ function diffFormData(original, updated) {
 }
 
 // src/schema/ensureFormItemIds.ts
-function isPlainObject2(v) {
+function isPlainObject3(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function isObjectArray2(property) {
   return property.type === "array" && !!property.items?.properties;
 }
 function stampItem(item, itemSchema) {
-  if (!isPlainObject2(item)) return item;
+  if (!isPlainObject3(item)) return item;
   const withChildren = stampObject(item, itemSchema.properties ?? {});
   return FORM_ITEM_ID_FIELD in withChildren ? withChildren : { ...withChildren, [FORM_ITEM_ID_FIELD]: generateId() };
 }
@@ -723,7 +1142,7 @@ function stampValue(value, property) {
   if (isObjectArray2(property) && Array.isArray(value)) {
     return value.map((item) => stampItem(item, property.items));
   }
-  if (property.type === "object" && property.properties && isPlainObject2(value)) {
+  if (property.type === "object" && property.properties && isPlainObject3(value)) {
     return stampObject(value, property.properties);
   }
   return value;
@@ -744,10 +1163,43 @@ function stampObject(data, properties) {
 function ensureFormItemIds(data, schema) {
   return stampObject(data, getSchemaProperties(schema));
 }
+function stripFormItemIds(data) {
+  const result = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (key === FORM_ITEM_ID_FIELD) continue;
+    if (Array.isArray(value)) {
+      result[key] = value.map(
+        (item) => isPlainObject3(item) ? stripFormItemIds(item) : item
+      );
+    } else if (isPlainObject3(value)) {
+      result[key] = stripFormItemIds(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
 export {
+  CODEABLE_CONCEPT_TYPE,
+  CODEABLE_CONCEPT_TYPE_ID,
+  CODING_TYPE,
+  CODING_TYPE_ID,
+  CORE_TYPES_BASE,
+  CORE_VALUE_TYPES,
+  QUANTITY_TYPE,
+  QUANTITY_TYPE_ID,
+  UCUM_SYSTEM,
   WIDTH_TOKEN_REMS,
   ajv,
   applySchemaDefaults,
+  bindingLists,
+  bindingOf,
+  codeToken,
+  codingKey,
+  codingsByList,
+  conceptOf,
+  coreType,
+  coreTypeOf,
   diffFormData,
   ensureFormItemIds,
   evaluateUiRule,
@@ -775,11 +1227,23 @@ export {
   isFieldRequired,
   isNullableBoolean,
   isOneOf,
+  liftNullableMember,
+  listTitle,
   matchesConst,
+  mergeFieldErrors,
+  missingLists,
+  parseCodeToken,
   resolveRefs,
   resolveSchema,
+  stripFormItemIds,
   toJsonSchema,
+  unitRangesKeywords,
+  unitRangesOf,
+  validateContentConstraints,
   validateFormData,
-  validateSchema
+  validateSchema,
+  valueRefKeywords,
+  valueRefOf,
+  valueTypeResolver
 };
 //# sourceMappingURL=index.js.map