@disclosureos/records 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/experimental/v2/index.js

@@ -126,9 +126,9 @@ function parsePrimitiveRecord(input) {
         unchecked.add(ref2);
         continue;
       }
-      const target2 = assertions.get(ref2.slice("assertion:".length));
-      if (!target2) issues.push({ code: "REF.LOCAL_RESOLUTION", stage: "semantic", pointer: `/${field}/sourceRefs/${index}`, message: "Local assertion does not exist." });
-      else if (target2.field !== field) issues.push({ code: "REF.FIELD_MISMATCH", stage: "semantic", pointer: `/${field}/sourceRefs/${index}`, message: "Assertion concerns a different field." });
+      const target3 = assertions.get(ref2.slice("assertion:".length));
+      if (!target3) issues.push({ code: "REF.LOCAL_RESOLUTION", stage: "semantic", pointer: `/${field}/sourceRefs/${index}`, message: "Local assertion does not exist." });
+      else if (target3.field !== field) issues.push({ code: "REF.FIELD_MISMATCH", stage: "semantic", pointer: `/${field}/sourceRefs/${index}`, message: "Assertion concerns a different field." });
     }
     const selection = value.selection;
     if (!selection) continue;
@@ -141,9 +141,9 @@ function parsePrimitiveRecord(input) {
     for (const [index, ref2] of selection.consideredAssertionRefs.entries()) {
       if (refs.has(ref2)) issues.push({ code: "REF.UNIQUE_ID", stage: "semantic", pointer: `${path}/consideredAssertionRefs/${index}`, message: "Considered assertion is repeated." });
       refs.add(ref2);
-      const target2 = assertions.get(ref2.slice("assertion:".length));
-      if (!target2) issues.push({ code: "REF.LOCAL_RESOLUTION", stage: "semantic", pointer: `${path}/consideredAssertionRefs/${index}`, message: "Considered assertion does not exist." });
-      else if (target2.field !== field) issues.push({ code: "REF.FIELD_MISMATCH", stage: "semantic", pointer: `${path}/consideredAssertionRefs/${index}`, message: "Considered assertion concerns a different field." });
+      const target3 = assertions.get(ref2.slice("assertion:".length));
+      if (!target3) issues.push({ code: "REF.LOCAL_RESOLUTION", stage: "semantic", pointer: `${path}/consideredAssertionRefs/${index}`, message: "Considered assertion does not exist." });
+      else if (target3.field !== field) issues.push({ code: "REF.FIELD_MISMATCH", stage: "semantic", pointer: `${path}/consideredAssertionRefs/${index}`, message: "Considered assertion concerns a different field." });
     }
     const selected = assertions.get(selection.assertionRef.slice("assertion:".length));
     if (!selected) issues.push({ code: "REF.LOCAL_RESOLUTION", stage: "semantic", pointer: `${path}/assertionRef`, message: "Selected assertion does not exist." });
@@ -383,9 +383,9 @@ function parseExperimentalObservation(input) {
     resolve(value.assertionRef, `${selectionPath}/assertionRef`, owner);
     if (!value.consideredAssertionRefs.includes(value.assertionRef)) problem("SELECTION.INPUTS", `${selectionPath}/assertionRef`, "Selected assertion must be among considered inputs.");
     if (!refs.includes(value.assertionRef)) problem("SELECTION.SOURCE_REF", `${path}/sourceRefs`, "Field must cite the selected assertion.");
-    const target2 = assertions.get(key(value.assertionRef));
-    if (target2 && !matchesField(value.assertionRef, field, measurementId)) problem("REF.FIELD_MISMATCH", `${selectionPath}/assertionRef`, "Selected assertion concerns a different field or measurement.");
-    else if (target2 && JSON.stringify(target2.value) !== JSON.stringify(selectedValue)) problem("SELECTION.VALUE_MISMATCH", `${path}/value`, "Selection must copy the cited assertion value exactly; processing is declared separately.");
+    const target3 = assertions.get(key(value.assertionRef));
+    if (target3 && !matchesField(value.assertionRef, field, measurementId)) problem("REF.FIELD_MISMATCH", `${selectionPath}/assertionRef`, "Selected assertion concerns a different field or measurement.");
+    else if (target3 && JSON.stringify(target3.value) !== JSON.stringify(selectedValue)) problem("SELECTION.VALUE_MISMATCH", `${path}/value`, "Selection must copy the cited assertion value exactly; processing is declared separately.");
   }
   instant(data.createdAt, "/createdAt");
   instant(data.updatedAt, "/updatedAt");
@@ -457,10 +457,10 @@ function parseExperimentalObservation(input) {
   }
   if (queue.length !== graph.size) problem("PROCESS.CYCLE", "/processing", "Local processing/provenance dependencies contain a cycle.");
   const checks = { structural: "passed", semantic: issues.length ? "failed" : "passed", profile: "not_checked", external: "not_checked" };
-  const uncheckedRefs = [...sources.keys()].map((id5) => `source:${id5}`).concat(
-    [...products.keys()].map((id5) => `product:${id5}`),
-    [...methods.keys()].map((id5) => `method:${id5}`),
-    [...frames.keys()].map((id5) => `frame:${id5}`)
+  const uncheckedRefs = [...sources.keys()].map((id7) => `source:${id7}`).concat(
+    [...products.keys()].map((id7) => `product:${id7}`),
+    [...methods.keys()].map((id7) => `method:${id7}`),
+    [...frames.keys()].map((id7) => `frame:${id7}`)
   );
   return issues.length ? { success: false, issues, checks, uncheckedRefs } : { success: true, data, issues, checks, uncheckedRefs };
 }
@@ -561,9 +561,9 @@ function parseExperimentalClaimHistory(input) {
     if (!available.has(ref2)) problem("REF.LOCAL_RESOLUTION", path, `Undeclared local reference: ${ref2}`);
     else if (owner && claims.has(ref2)) graph.get(owner)?.add(ref2);
   }
-  function refs(values2, path, owner) {
+  function refs(values3, path, owner) {
     const seen = /* @__PURE__ */ new Set();
-    for (const [i, ref2] of values2.entries()) {
+    for (const [i, ref2] of values3.entries()) {
       if (seen.has(ref2)) problem("REF.UNIQUE_ID", `${path}/${i}`, "Reference is repeated.");
       seen.add(ref2);
       resolve(ref2, `${path}/${i}`, owner);
@@ -1438,8 +1438,8 @@ function observationContextJsonSchema() {
 }
 
 // src/experimental/v2/context.ts
-function contextAssertions(entity2) {
-  return Object.entries(entity2.fields).flatMap(
+function contextAssertions(entity3) {
+  return Object.entries(entity3.fields).flatMap(
     ([field, assertions]) => (assertions ?? []).map((assertion) => ({
       field,
       assertion
@@ -1453,7 +1453,7 @@ function parseObservationContext(input) {
     rulesetVersion: "0.1.0"
   };
   const issues = [];
-  const error = (code, pointer5, message) => issues.push({ code, stage: "semantic", pointer: pointer5, message });
+  const error = (code, pointer6, message) => issues.push({ code, stage: "semantic", pointer: pointer6, message });
   if (!parsed.success)
     return {
       success: false,
@@ -1475,12 +1475,12 @@ function parseObservationContext(input) {
   const data = parsed.data;
   const entities = /* @__PURE__ */ new Map();
   const relativeGraph = /* @__PURE__ */ new Map();
-  for (const [i, entity2] of data.entities.entries()) {
-    const key2 = `${entity2.kind}:${entity2.id}`;
+  for (const [i, entity3] of data.entities.entries()) {
+    const key2 = `${entity3.kind}:${entity3.id}`;
     if (entities.has(key2))
       error("REF.UNIQUE_ID", `/entities/${i}/id`, "Duplicate entity identity.");
-    entities.set(key2, entity2);
-    if (entity2.kind === "temporal") relativeGraph.set(entity2.id, /* @__PURE__ */ new Set());
+    entities.set(key2, entity3);
+    if (entity3.kind === "temporal") relativeGraph.set(entity3.id, /* @__PURE__ */ new Set());
   }
   function time(value, path) {
     const found = [];
@@ -1493,9 +1493,9 @@ function parseObservationContext(input) {
   );
   const unchecked = /* @__PURE__ */ new Set([data.observationRef.sha256]);
   if (data.acquisitionRef) unchecked.add(data.acquisitionRef.sha256);
-  for (const [i, entity2] of data.entities.entries()) {
+  for (const [i, entity3] of data.entities.entries()) {
     const path = `/entities/${i}`;
-    const assertions = contextAssertions(entity2);
+    const assertions = contextAssertions(entity3);
     const ids = /* @__PURE__ */ new Set();
     for (const { field, assertion } of assertions) {
       const p = `${path}/fields/${field}`;
@@ -1528,8 +1528,8 @@ function parseObservationContext(input) {
           "Context entity reference does not resolve."
         );
       if (field === "placeIds") {
-        for (const id5 of content.value)
-          if (!entities.has(`place:${id5}`))
+        for (const id7 of content.value)
+          if (!entities.has(`place:${id7}`))
             error(
               "REF.LOCAL_RESOLUTION",
               p,
@@ -1552,7 +1552,7 @@ function parseObservationContext(input) {
             p,
             "Relative date anchor does not resolve."
           );
-        relativeGraph.get(entity2.id)?.add(relative2.anchorTemporalId);
+        relativeGraph.get(entity3.id)?.add(relative2.anchorTemporalId);
         if (relative2.relation === "during" && relative2.offset)
           error(
             "TIME.RELATIVE_OFFSET",
@@ -1608,7 +1608,7 @@ function parseObservationContext(input) {
       }
     }
     const selectedFields = /* @__PURE__ */ new Set();
-    for (const selection of entity2.selections ?? []) {
+    for (const selection of entity3.selections ?? []) {
       const p = `${path}/selections`;
       if (selectedFields.has(selection.field))
         error(
@@ -1625,9 +1625,9 @@ function parseObservationContext(input) {
         );
       if (new Set(selection.consideredAssertionIds).size !== selection.consideredAssertionIds.length)
         error("REF.UNIQUE_ID", p, "Considered assertions are repeated.");
-      for (const id5 of selection.consideredAssertionIds)
+      for (const id7 of selection.consideredAssertionIds)
         if (!assertions.some(
-          (a) => a.field === selection.field && a.assertion.id === id5
+          (a) => a.field === selection.field && a.assertion.id === id7
         ))
           error(
             "REF.FIELD_MISMATCH",
@@ -1661,7 +1661,7 @@ function parseObservationContext(input) {
       unchecked.add(selection.methodRef);
     }
     const measurements = /* @__PURE__ */ new Set();
-    for (const link of entity2.measurements ?? []) {
+    for (const link of entity3.measurements ?? []) {
       if (measurements.has(link.id))
         error(
           "REF.UNIQUE_ID",
@@ -1882,9 +1882,9 @@ function parseContextClaimHistory(input) {
       );
     else if (owner && claims.has(ref2)) graph.get(owner)?.add(ref2);
   }
-  function refs(values2, path, owner) {
+  function refs(values3, path, owner) {
     const seen = /* @__PURE__ */ new Set();
-    for (const [i, ref2] of values2.entries()) {
+    for (const [i, ref2] of values3.entries()) {
       if (seen.has(ref2))
         problem("REF.UNIQUE_ID", `${path}/${i}`, "Reference is repeated.");
       seen.add(ref2);
@@ -2041,7 +2041,880 @@ function parseContextClaimHistory(input) {
     )
   };
 }
+var WitnessCategorySchema = z.enum([
+  "military_pilot",
+  "military_aircrew",
+  "military_ground",
+  "military_naval",
+  "military_radar_operator",
+  "military_other",
+  "commercial_pilot",
+  "commercial_aircrew",
+  "private_pilot",
+  "air_traffic_controller",
+  "aviation_other",
+  "government_official",
+  "elected_official",
+  "intelligence_officer",
+  "law_enforcement",
+  "scientist",
+  "astronomer",
+  "meteorologist",
+  "engineer",
+  "medical_professional",
+  "maritime",
+  "civilian",
+  "civilian_group",
+  "anonymous",
+  "unknown"
+]).describe("Professional/role category of a witness.");
+var CredibilityFactorSchema = z.enum([
+  "professional_training",
+  "official_capacity",
+  "sworn_statement",
+  "contemporaneous_record",
+  "corroborating_witnesses",
+  "corroborating_evidence",
+  "consistent_account",
+  "no_apparent_motive",
+  "reputation_risk",
+  "security_clearance"
+]).describe("A factor strengthening witness credibility.");
+var CredibilityDetractorSchema = z.enum([
+  "anonymous",
+  "inconsistent_account",
+  "delayed_report",
+  "known_fabricator",
+  "financial_motive",
+  "single_witness",
+  "impaired_state",
+  "recovered_memory"
+]).describe("A factor weakening witness credibility.");
+var WitnessCredibilitySchema = z.object({
+  // The former `CredibilityRating` was byte-identical to the qualitative
+  // `ConfidenceLevel`; it is now the single shared scale (DRY #1).
+  rating: ConfidenceLevelSchema.optional(),
+  factors: z.array(CredibilityFactorSchema).optional(),
+  detractors: z.array(CredibilityDetractorSchema).optional(),
+  isProfessionalObserver: z.boolean().optional().describe("Whether the witness is a trained observer (pilot, astronomer, military)."),
+  hasAviationExperience: z.boolean().optional().describe("Whether the witness has aviation experience."),
+  hasMilitaryExperience: z.boolean().optional().describe("Whether the witness has military experience."),
+  hasScientificBackground: z.boolean().optional().describe("Whether the witness has a scientific background."),
+  hasPriorUAPKnowledge: z.boolean().optional().describe("Whether the witness had prior knowledge of or interest in UAP before the observation."),
+  wasSkepticPrior: z.boolean().optional().describe("Whether the witness was a skeptic before the observation."),
+  underOathTestimony: z.boolean().optional().describe("Whether the testimony was given under oath."),
+  polygraphAdministered: z.boolean().optional().describe("Whether a polygraph was administered."),
+  polygraphPassed: z.boolean().optional().describe("Whether the witness passed the polygraph."),
+  consistentTestimony: z.boolean().optional().describe("Whether the account has remained consistent across retellings."),
+  willingToBeIdentified: z.boolean().optional().describe("Whether the witness is willing to be publicly identified."),
+  notes: z.string().optional().describe("Free-text context about the credibility assessment.")
+}).meta({ id: "WitnessCredibility" }).describe("Structured assessment of a witness's credibility (rating, factors, detractors).");
+
+// src/extensions/testimony/witness.ts
+var SecurityClearanceSchema = z.enum(["none", "confidential", "secret", "top_secret", "sci", "unknown"]).describe("Security clearance level held by a witness.");
+var WitnessSchema = z.object({
+  witnessId: z.string().describe("Stable unique identifier for this witness."),
+  category: WitnessCategorySchema,
+  anonymous: z.boolean().describe("Whether the witness\u2019s identity is withheld."),
+  publicName: z.string().optional().describe("Witness\u2019s name as publicly known, when not anonymous."),
+  pseudonym: z.string().optional().describe("Pseudonym used when the witness is anonymous."),
+  role: z.string().optional().describe('Witness\u2019s role at the time (e.g. "F/A-18F pilot", "radar operator").'),
+  organization: z.string().optional().describe("Organization the witness belonged to at the time."),
+  experienceYears: z.number().optional().describe("Years of relevant professional experience."),
+  securityClearance: SecurityClearanceSchema.optional(),
+  credibility: WitnessCredibilitySchema.optional(),
+  statementSummary: z.string().optional().describe("Brief summary of what the witness reported."),
+  interviewAvailable: z.boolean().optional().describe("Whether a recorded interview with the witness exists."),
+  writtenReportAvailable: z.boolean().optional().describe("Whether a written report from the witness exists.")
+}).meta({ id: "Witness" }).describe("A person who reported or corroborated an observation.");
+var TemporalCertaintySchema = z.enum(["exact", "approximate", "estimated", "unknown"]).describe("Confidence in a date or time value \u2014 the single certainty scale for all temporal values.");
+var ChainOfCustodySchema = z.enum([
+  "verified",
+  "partial",
+  "unverified",
+  "government_held",
+  "private_held",
+  "lost",
+  "destroyed",
+  "classified",
+  "unknown"
+]).describe("Custody status of an evidence item.");
+var CustodyActionSchema = z.enum([
+  "creation",
+  "collection",
+  "transfer",
+  "storage",
+  "analysis",
+  "release",
+  "classification",
+  "destruction",
+  "loss",
+  "recovery",
+  "other"
+]).describe("An action recorded in a chain-of-custody entry.");
+var CustodyEntrySchema = z.object({
+  entryId: z.string().describe("Stable unique identifier for this custody entry."),
+  date: z.string().describe("When the custody event occurred (ISO date)."),
+  action: CustodyActionSchema,
+  from: z.string().optional().describe("Party that held the evidence before this event."),
+  to: z.string().optional().describe("Party that held the evidence after this event."),
+  location: z.string().optional().describe("Where the custody event took place."),
+  reference: z.string().optional().describe("Document or record substantiating the event (e.g. transfer receipt, log entry)."),
+  notes: z.string().optional().describe("Free-text context about the event.")
+}).meta({ id: "CustodyEntry" }).describe("A single custody event for an evidence item.");
+z.object({
+  evidenceId: z.string().describe("Identifier of the evidence item this custody history belongs to."),
+  status: ChainOfCustodySchema,
+  entries: z.array(CustodyEntrySchema)
+}).meta({ id: "ChainOfCustodyRecord" }).describe("The full custody history for a piece of evidence.");
+
+// src/extensions/testimony/statement.ts
+var TestimonyContextSchema = z.enum([
+  "sworn_affidavit",
+  "congressional_testimony",
+  "deposition",
+  "official_interview",
+  "written_statement",
+  "recorded_interview",
+  "informal_account",
+  "anonymous_tip",
+  "whistleblower_disclosure"
+]).describe("The setting in which testimony was given.");
+var TestimonyDateSchema = z.object({
+  date: z.string().describe("When the testimony was given (ISO date)."),
+  certainty: TemporalCertaintySchema
+}).meta({ id: "TestimonyDate" }).describe("When testimony was given, with its certainty.");
+z.object({
+  statementId: z.string().describe('Stable id, addressable by a claim `evidenceRef` ("testimony:<statementId>").'),
+  witness: WitnessSchema,
+  context: TestimonyContextSchema,
+  date: TestimonyDateSchema,
+  content: z.string().optional().describe("Full text of the statement, when available."),
+  summary: z.string().optional().describe("Brief summary of what the statement asserts."),
+  sourceDocument: SourceReferenceSchema.optional(),
+  chainOfCustody: ChainOfCustodySchema.optional(),
+  additionalEvidenceIds: z.array(z.string()).optional().describe("Ids of other evidence items the statement references or supports.")
+}).meta({ id: "TestimonyStatement" }).describe("A single witness statement, its context, and supporting documentation.");
+
+// src/experimental/v2/research-entities-schema.ts
+var text6 = z.string().min(1).regex(/\S/);
+var id5 = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var sourceRef3 = z.string().regex(/^(source|product):[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var provenance3 = SourceProvenanceSchema.extend({ sourceRef: sourceRef3 });
+var RESEARCH_ENTITIES_SCHEMA_ID = "urn:disclosureos:experimental:research-entities:0.1.0";
+function values2(schema) {
+  return z.array(
+    z.strictObject({
+      id: id5.describe(
+        "Assertion identity within this entity, independent of array order."
+      ),
+      content: z.union([
+        z.strictObject({
+          state: z.literal("known"),
+          value: schema,
+          provenance: provenance3,
+          originalWording: text6.optional()
+        }),
+        z.strictObject({
+          state: z.literal("approximate"),
+          value: schema,
+          precision: text6,
+          provenance: provenance3,
+          originalWording: text6.optional()
+        }),
+        z.strictObject({
+          state: z.literal("unknown"),
+          reason: z.enum(["not_recorded", "not_collected", "unavailable"])
+        }),
+        z.strictObject({ state: z.literal("redacted"), reason: text6 }),
+        z.strictObject({
+          state: z.literal("unmapped"),
+          originalWording: text6,
+          provenance: provenance3
+        })
+      ])
+    })
+  ).min(1).optional();
+}
+var timeContextReference = ContextReferenceSchema.extend({
+  target: z.union([
+    ContextTargetSchema.options[0],
+    ContextTargetSchema.options[5]
+  ])
+}).describe(
+  "Temporal or event context for a qualification, not an arbitrary object attribute."
+);
+var relevantTime = z.union([
+  z.strictObject({ kind: z.literal("calendar"), value: EventTimeValueSchema }),
+  z.strictObject({
+    kind: z.literal("context"),
+    reference: timeContextReference
+  }),
+  z.strictObject({ kind: z.literal("unknown"), reason: text6 })
+]);
+var qualification = (value) => z.strictObject({ value, relevantTime });
+var ResearchWitnessFields = {
+  publicIdentity: values2(
+    z.discriminatedUnion("kind", [
+      z.strictObject({ kind: z.literal("public_name"), display: text6 }),
+      z.strictObject({ kind: z.literal("pseudonym"), display: text6 }),
+      z.strictObject({ kind: z.literal("withheld"), display: text6 })
+    ])
+  ),
+  anonymous: values2(z.boolean()),
+  willingToBeIdentified: values2(z.boolean()),
+  category: values2(qualification(WitnessCategorySchema)),
+  role: values2(qualification(text6)),
+  organization: values2(qualification(text6)),
+  experienceYears: values2(qualification(z.number().min(0))),
+  securityClearance: values2(qualification(SecurityClearanceSchema)),
+  isProfessionalObserver: values2(qualification(z.boolean())),
+  hasAviationExperience: values2(qualification(z.boolean())),
+  hasMilitaryExperience: values2(qualification(z.boolean())),
+  hasScientificBackground: values2(qualification(z.boolean())),
+  hasPriorUAPKnowledge: values2(qualification(z.boolean())),
+  wasSkepticPrior: values2(qualification(z.boolean())),
+  description: values2(text6)
+};
+var ResearchAccountFields = {
+  speakerWitnessIds: values2(z.array(id5).min(1)),
+  recorder: values2(text6),
+  context: values2(TestimonyContextSchema),
+  recordedTime: values2(EventTimeValueSchema),
+  dateCertainty: values2(
+    z.enum(["exact", "approximate", "estimated", "unknown"])
+  ),
+  eventContext: values2(ContextReferenceSchema),
+  content: values2(text6),
+  summary: values2(z.strictObject({ text: text6, summarizedBy: text6 })),
+  sourceDocument: values2(sourceRef3),
+  interviewAvailable: values2(z.boolean()),
+  writtenReportAvailable: values2(z.boolean()),
+  underOath: values2(z.boolean()),
+  custodyStatus: values2(ChainOfCustodySchema),
+  supportRefs: values2(z.array(sourceRef3).min(1))
+};
+var ResearchProcedureFields = {
+  procedureType: values2(z.literal("polygraph")),
+  witnessId: values2(id5),
+  accountId: values2(id5),
+  administered: values2(z.boolean()),
+  passed: values2(z.boolean()),
+  performedAt: values2(EventTimeValueSchema),
+  context: values2(text6),
+  sourceDocument: values2(sourceRef3)
+};
+var ResearchWitnessGroupFields = {
+  witnessIds: values2(z.array(id5).min(1)),
+  reportedCount: values2(z.number().int().min(0)),
+  categories: values2(z.array(WitnessCategorySchema).min(1)),
+  militaryWitnesses: values2(z.boolean()),
+  aviationWitnesses: values2(z.boolean()),
+  professionalObservers: values2(z.boolean()),
+  descriptions: values2(z.array(text6).min(1))
+};
+for (const fields of [
+  ResearchWitnessFields,
+  ResearchAccountFields,
+  ResearchProcedureFields,
+  ResearchWitnessGroupFields
+])
+  for (const [key2, schema] of Object.entries(fields))
+    fields[key2] = schema.describe(
+      `Sourced ${key2.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase()} assertions. Alternatives and unknowns are retained; supplied does not mean verified.`
+    );
+function entity2(kind, fields) {
+  return z.strictObject({
+    kind: z.literal(kind),
+    id: id5,
+    fields: z.strictObject(fields)
+  });
+}
+var ResearchEntitySchema = z.discriminatedUnion("kind", [
+  entity2("witness", ResearchWitnessFields),
+  entity2("account", ResearchAccountFields),
+  entity2("procedure", ResearchProcedureFields),
+  entity2("witness_group", ResearchWitnessGroupFields)
+]);
+var ResearchEntitiesSchema = z.strictObject({
+  kind: z.literal("research_entities"),
+  schemaVersion: z.literal("0.1.0"),
+  id: id5,
+  observationRef: ObservationSnapshotRefSchema,
+  contextRefs: z.array(
+    DocumentSnapshotRefSchema.extend({
+      schemaId: z.literal(OBSERVATION_CONTEXT_SCHEMA_ID)
+    })
+  ),
+  recordedAt: instantString,
+  recordedBy: text6,
+  entities: z.array(ResearchEntitySchema).min(1)
+}).describe(
+  "Public witness, account, procedure and aggregate declarations. Private identity mappings and contact fields belong outside this exchange document. No consent or credibility is inferred."
+);
+function target2(kind, fields) {
+  return z.strictObject({
+    kind: z.literal(kind),
+    id: id5,
+    field: z.enum(Object.keys(fields)).optional()
+  });
+}
+var ResearchEntityTargetSchema = z.discriminatedUnion("kind", [
+  target2("witness", ResearchWitnessFields),
+  target2("account", ResearchAccountFields),
+  target2("procedure", ResearchProcedureFields),
+  target2("witness_group", ResearchWitnessGroupFields)
+]);
+var ResearchEntityReferenceSchema = z.strictObject({
+  document: DocumentSnapshotRefSchema.extend({
+    schemaId: z.literal(RESEARCH_ENTITIES_SCHEMA_ID)
+  }),
+  target: ResearchEntityTargetSchema
+});
+var ResearchEntityAssertionReferenceSchema = ResearchEntityReferenceSchema.extend({ assertionId: id5 });
+function researchEntitiesJsonSchema() {
+  return {
+    ...z.toJSONSchema(ResearchEntitiesSchema, {
+      target: "draft-2020-12",
+      reused: "ref"
+    }),
+    $id: RESEARCH_ENTITIES_SCHEMA_ID
+  };
+}
+
+// src/experimental/v2/research-entities.ts
+function researchEntityAssertions(entity3) {
+  return Object.entries(entity3.fields).flatMap(
+    ([field, list]) => (list ?? []).map((assertion) => ({
+      field,
+      assertion
+    }))
+  );
+}
+function researchEntityContextReferences(entity3) {
+  return researchEntityAssertions(entity3).flatMap(({ field, assertion }) => {
+    const value = assertion.content.value;
+    if (field === "eventContext" && value)
+      return [value];
+    return value?.relevantTime?.kind === "context" ? [value.relevantTime.reference] : [];
+  });
+}
+function parseResearchEntities(input) {
+  const parsed = ResearchEntitiesSchema.safeParse(input);
+  const contract = {
+    schemaId: RESEARCH_ENTITIES_SCHEMA_ID,
+    rulesetVersion: "0.1.0"
+  };
+  if (!parsed.success)
+    return {
+      success: false,
+      contract,
+      checks: {
+        structural: "failed",
+        semantic: "not_checked",
+        profile: "not_checked",
+        external: "not_checked"
+      },
+      uncheckedRefs: [],
+      issues: parsed.error.issues.map((i) => ({
+        code: "STRUCT.VALUE",
+        stage: "structural",
+        pointer: "/" + i.path.join("/"),
+        message: i.message
+      }))
+    };
+  const data = parsed.data, issues = [];
+  const problem = (code, pointer6, message) => issues.push({ code, stage: "semantic", pointer: pointer6, message });
+  const snapshots = new Set(data.contextRefs.map((r) => JSON.stringify(r)));
+  if (snapshots.size !== data.contextRefs.length)
+    problem(
+      "REF.UNIQUE_ID",
+      "/contextRefs",
+      "Context snapshot references repeat."
+    );
+  const unchecked = /* @__PURE__ */ new Set([
+    data.observationRef.sha256,
+    ...data.contextRefs.map((r) => r.sha256)
+  ]);
+  const identities = /* @__PURE__ */ new Set();
+  for (const [i, e] of data.entities.entries()) {
+    const key2 = `${e.kind}:${e.id}`;
+    if (identities.has(key2))
+      problem(
+        "REF.UNIQUE_ID",
+        `/entities/${i}/id`,
+        "Entity identity repeats within its kind."
+      );
+    identities.add(key2);
+  }
+  function time(v, p) {
+    const found = [];
+    checkTime(v, p, found);
+    found.forEach((i) => problem(i.code, i.pointer, i.message));
+  }
+  time(
+    { kind: "instant", value: data.recordedAt},
+    "/recordedAt"
+  );
+  for (const [i, e] of data.entities.entries()) {
+    const ep = `/entities/${i}`, ids = /* @__PURE__ */ new Set();
+    for (const { field, assertion: a } of researchEntityAssertions(e)) {
+      const p = `${ep}/fields/${field}`;
+      if (ids.has(a.id))
+        problem("REF.UNIQUE_ID", p, "Assertion IDs repeat within this entity.");
+      ids.add(a.id);
+      const prov = a.content.provenance;
+      if (prov) {
+        unchecked.add(prov.sourceRef);
+        if (prov.locator?.kind === "time_range" && prov.locator.endSeconds < prov.locator.startSeconds)
+          problem("TIME.INTERVAL", p, "Source locator end precedes its start.");
+      }
+      const value = a.content.value;
+      if (value === void 0) continue;
+      if (field === "recordedTime" || field === "performedAt")
+        time(value, p);
+      const relevant = value.relevantTime;
+      if (relevant?.kind === "calendar") time(relevant.value, p);
+      const targetKind = field === "speakerWitnessIds" || field === "witnessIds" || field === "witnessId" ? "witness" : field === "accountId" ? "account" : void 0;
+      if (targetKind) {
+        const refs = Array.isArray(value) ? value : [value];
+        if (new Set(refs).size !== refs.length)
+          problem("REF.UNIQUE_ID", p, "Typed local links repeat.");
+        for (const id7 of refs)
+          if (!identities.has(`${targetKind}:${id7}`))
+            problem("REF.ENTITY", p, "Typed local entity does not exist.");
+      }
+      if (field === "sourceDocument") unchecked.add(value);
+      if (field === "supportRefs") {
+        const refs = value;
+        if (new Set(refs).size !== refs.length)
+          problem("REF.UNIQUE_ID", p, "Support references repeat.");
+        refs.forEach((r) => unchecked.add(r));
+      }
+    }
+    for (const ref2 of researchEntityContextReferences(e))
+      if (!snapshots.has(JSON.stringify(ref2.document)))
+        problem(
+          "REF.LOCAL_RESOLUTION",
+          ep,
+          "Context reference must select a declared snapshot."
+        );
+  }
+  const validation = {
+    contract,
+    issues,
+    uncheckedRefs: [...unchecked],
+    checks: {
+      structural: "passed",
+      semantic: issues.length ? "failed" : "passed",
+      profile: "not_checked",
+      external: "not_checked"
+    }
+  };
+  return issues.length ? { ...validation, success: false } : { ...validation, success: true, data };
+}
+var text7 = z.string().min(1).regex(/\S/, "must contain non-whitespace text");
+var id6 = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var claimRef3 = z.string().regex(/^claim:[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/);
+var inputRef3 = z.string().regex(
+  /^(?:claim|source|product|assertion|measurement):[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/
+);
+var ResearchClaimSubjectSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("observation") }),
+  z.strictObject({
+    kind: z.literal("entity"),
+    reference: ResearchEntityReferenceSchema
+  }),
+  z.strictObject({
+    kind: z.literal("context"),
+    reference: ContextReferenceSchema
+  }),
+  z.strictObject({ kind: z.literal("measurement"), measurementId: id6 })
+]);
+var WitnessReviewSchema = z.strictObject({
+  rating: ConfidenceLevelSchema.optional(),
+  factors: z.array(CredibilityFactorSchema).optional().describe(
+    "Reviewer-selected factor labels; no built-in weighting or validation of their truth."
+  ),
+  detractors: z.array(CredibilityDetractorSchema).optional().describe(
+    "Retained vocabulary for attributable reviews. Anonymity never adds a penalty automatically."
+  ),
+  consistentTestimony: z.enum(["consistent", "inconsistent", "unknown"]).optional(),
+  multipleIndependent: z.enum(["independent", "not_independent", "unknown"]).optional(),
+  notes: text7.optional()
+}).describe(
+  "Attributable interpretation, separate from sourced qualifications; requires explicit inputs."
+);
+var common3 = {
+  id: id6,
+  recordedAt: instantString,
+  topic: text7,
+  subject: ResearchClaimSubjectSchema,
+  supersedes: z.array(claimRef3).min(1).optional()
+};
+var ResearchSourceStatementSchema = z.strictObject({
+  ...common3,
+  kind: z.literal("source_assertion"),
+  text: text7,
+  reportedLevel: text7.optional(),
+  provenance: ObservationAssertionSchema.options[0].shape.provenance
+});
+var assessment3 = {
+  ...common3,
+  kind: z.literal("assessment"),
+  inputRefs: z.array(inputRef3),
+  contextInputRefs: z.array(ContextAssertionReferenceSchema).optional(),
+  entityInputRefs: z.array(ResearchEntityAssertionReferenceSchema).optional(),
+  rationale: text7
+};
+var ResearchUnassessedClaimSchema = z.strictObject({
+  ...assessment3,
+  status: z.literal("unassessed")
+});
+var ResearchAssessedClaimSchema = z.strictObject({
+  ...assessment3,
+  status: z.literal("assessed"),
+  outcome: z.enum(["reported", "confirmed", "absent", "inconclusive"]),
+  evaluatedBy: text7,
+  evaluatedAt: instantString,
+  methodRef: z.string().regex(/^method:[A-Za-z0-9][A-Za-z0-9._-]*(?![\s\S])/),
+  methodVersion: text7,
+  confidence: z.number().min(0).max(1).optional(),
+  witnessReview: WitnessReviewSchema.optional()
+});
+var ResearchHistoricalClaimSchema = z.union([
+  ResearchSourceStatementSchema,
+  ResearchUnassessedClaimSchema,
+  ResearchAssessedClaimSchema
+]);
+var RESEARCH_CLAIM_HISTORY_SCHEMA_ID = "urn:disclosureos:experimental:claim-history:0.3.0";
+var RESEARCH_CLAIM_HISTORY_RULESET_VERSION = "0.3.0";
+var ResearchClaimHistorySchema = z.strictObject({
+  kind: z.literal("claim_history"),
+  schemaVersion: z.literal("0.3.0"),
+  id: id6,
+  contextRefs: z.array(
+    DocumentSnapshotRefSchema.extend({
+      schemaId: z.literal(OBSERVATION_CONTEXT_SCHEMA_ID)
+    })
+  ),
+  entityRefs: z.array(
+    DocumentSnapshotRefSchema.extend({
+      schemaId: z.literal(RESEARCH_ENTITIES_SCHEMA_ID)
+    })
+  ),
+  observation: ExperimentalObservationSchema,
+  claims: z.array(ResearchHistoricalClaimSchema),
+  extensions: ExperimentalObservationSchema.shape.extensions
+});
+function researchClaimHistoryJsonSchema() {
+  return {
+    ...z.toJSONSchema(ResearchClaimHistorySchema, {
+      target: "draft-2020-12",
+      reused: "ref"
+    }),
+    $id: RESEARCH_CLAIM_HISTORY_SCHEMA_ID
+  };
+}
+
+// src/experimental/v2/research-claim-history.ts
+var point3 = (value) => ({
+  kind: "instant",
+  value,
+  timeScale: "UTC"
+});
+var pointer5 = (path) => path.map((p) => `/${String(p).replace(/~/g, "~0").replace(/\//g, "~1")}`).join("");
+function parseResearchClaimHistory(input) {
+  const contract = {
+    kind: "claim_history",
+    schemaId: RESEARCH_CLAIM_HISTORY_SCHEMA_ID,
+    rulesetVersion: RESEARCH_CLAIM_HISTORY_RULESET_VERSION
+  };
+  const parsed = ResearchClaimHistorySchema.safeParse(input);
+  if (!parsed.success)
+    return {
+      success: false,
+      contract,
+      checks: {
+        structural: "failed",
+        semantic: "not_checked",
+        profile: "not_checked",
+        external: "not_checked"
+      },
+      uncheckedRefs: [],
+      issues: parsed.error.issues.map((issue) => ({
+        code: "STRUCT.VALUE",
+        stage: "structural",
+        severity: "error",
+        pointer: pointer5(issue.path),
+        message: issue.message
+      }))
+    };
+  const data = parsed.data;
+  const observationResult = parseExperimentalObservation(data.observation);
+  const issues = observationResult.issues.map(
+    (issue) => ({ ...issue, pointer: `/observation${issue.pointer}` })
+  );
+  const problem = (code, path, message) => issues.push({
+    code,
+    stage: "semantic",
+    severity: "error",
+    pointer: path,
+    message
+  });
+  const claims = /* @__PURE__ */ new Map();
+  const graph = /* @__PURE__ */ new Map();
+  const superseded = /* @__PURE__ */ new Set();
+  const sources = new Map(
+    data.observation.sources.map((item) => [`source:${item.id}`, item])
+  );
+  const products = new Map(
+    data.observation.products.map((item) => [`product:${item.id}`, item])
+  );
+  const methods = new Map(
+    data.observation.methods.map((item) => [`method:${item.id}`, item])
+  );
+  const measurements = new Set(
+    data.observation.measurements.map((item) => `measurement:${item.id}`)
+  );
+  const available = /* @__PURE__ */ new Set([
+    ...sources.keys(),
+    ...products.keys(),
+    ...measurements,
+    ...data.observation.assertions.map((item) => `assertion:${item.id}`)
+  ]);
+  for (const [i, claim] of data.claims.entries()) {
+    const ref2 = `claim:${claim.id}`;
+    if (claims.has(ref2))
+      problem(
+        "REF.UNIQUE_ID",
+        `/claims/${i}/id`,
+        "Duplicate claim ID; each revision must have its own ID."
+      );
+    else {
+      claims.set(ref2, claim);
+      graph.set(ref2, /* @__PURE__ */ new Set());
+      available.add(ref2);
+    }
+  }
+  function instant(value, path) {
+    const local = [];
+    checkTime(point3(value), path, local);
+    for (const issue of local)
+      problem(issue.code, issue.pointer, issue.message);
+  }
+  function resolve(ref2, path, owner) {
+    if (!available.has(ref2))
+      problem(
+        "REF.LOCAL_RESOLUTION",
+        path,
+        `Undeclared local reference: ${ref2}`
+      );
+    else if (owner && claims.has(ref2)) graph.get(owner)?.add(ref2);
+  }
+  function refs(values3, path, owner) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const [i, ref2] of values3.entries()) {
+      if (seen.has(ref2))
+        problem("REF.UNIQUE_ID", `${path}/${i}`, "Reference is repeated.");
+      seen.add(ref2);
+      resolve(ref2, `${path}/${i}`, owner);
+    }
+  }
+  const snapshots = new Set(data.contextRefs.map((r) => JSON.stringify(r)));
+  if (snapshots.size !== data.contextRefs.length)
+    problem(
+      "REF.UNIQUE_ID",
+      "/contextRefs",
+      "Context snapshot references repeat."
+    );
+  for (const [i, claim] of data.claims.entries()) {
+    const contextRefs = [
+      ...claim.subject.kind === "context" ? [claim.subject.reference] : [],
+      ...claim.kind === "assessment" ? claim.contextInputRefs ?? [] : []
+    ];
+    for (const ref2 of contextRefs)
+      if (!snapshots.has(JSON.stringify(ref2.document)))
+        problem(
+          "REF.LOCAL_RESOLUTION",
+          `/claims/${i}`,
+          "Context reference must select a declared snapshot."
+        );
+    if (claim.kind === "assessment" && new Set((claim.contextInputRefs ?? []).map((r) => JSON.stringify(r))).size !== (claim.contextInputRefs ?? []).length)
+      problem(
+        "REF.UNIQUE_ID",
+        `/claims/${i}/contextInputRefs`,
+        "Context inputs repeat."
+      );
+  }
+  const entitySnapshots = new Set(
+    data.entityRefs.map((r) => JSON.stringify(r))
+  );
+  if (entitySnapshots.size !== data.entityRefs.length)
+    problem("REF.UNIQUE_ID", "/entityRefs", "Entity snapshots repeat.");
+  for (const [i, claim] of data.claims.entries()) {
+    const refs2 = [
+      ...claim.subject.kind === "entity" ? [claim.subject.reference] : [],
+      ...claim.kind === "assessment" ? claim.entityInputRefs ?? [] : []
+    ];
+    for (const ref2 of refs2)
+      if (!entitySnapshots.has(JSON.stringify(ref2.document)))
+        problem(
+          "REF.LOCAL_RESOLUTION",
+          `/claims/${i}`,
+          "Entity reference must select a declared snapshot."
+        );
+    if (claim.kind === "assessment") {
+      if (new Set((claim.entityInputRefs ?? []).map((r) => JSON.stringify(r))).size !== (claim.entityInputRefs ?? []).length)
+        problem(
+          "REF.UNIQUE_ID",
+          `/claims/${i}/entityInputRefs`,
+          "Entity inputs repeat."
+        );
+      if (claim.status === "assessed" && claim.witnessReview) {
+        if (claim.subject.kind !== "entity" || !["witness", "account", "witness_group", "procedure"].includes(
+          claim.subject.reference.target.kind
+        ))
+          problem(
+            "CLAIM.SUPERSESSION_SCOPE",
+            `/claims/${i}/witnessReview`,
+            "Witness review requires a typed research-entity subject."
+          );
+        if (claim.inputRefs.length + (claim.entityInputRefs?.length ?? 0) + (claim.contextInputRefs?.length ?? 0) === 0)
+          problem(
+            "REF.LOCAL_RESOLUTION",
+            `/claims/${i}/witnessReview`,
+            "Witness review requires explicit inputs."
+          );
+      }
+    }
+  }
+  for (const [i, claim] of data.claims.entries()) {
+    const path = `/claims/${i}`;
+    const owner = `claim:${claim.id}`;
+    instant(claim.recordedAt, `${path}/recordedAt`);
+    if (claim.subject.kind === "measurement")
+      resolve(
+        `measurement:${claim.subject.measurementId}`,
+        `${path}/subject/measurementId`
+      );
+    if (claim.supersedes) {
+      refs(claim.supersedes, `${path}/supersedes`, owner);
+      for (const [j, ref2] of claim.supersedes.entries()) {
+        const previous = claims.get(ref2);
+        if (!previous) continue;
+        superseded.add(ref2);
+        if (previous.kind !== claim.kind || previous.topic !== claim.topic || JSON.stringify(previous.subject) !== JSON.stringify(claim.subject)) {
+          problem(
+            "CLAIM.SUPERSESSION_SCOPE",
+            `${path}/supersedes/${j}`,
+            "A revision must retain the claim kind, topic, and subject. Record a different claim separately."
+          );
+        }
+        if (previous.kind === "assessment" && previous.status === "assessed" && claim.kind === "assessment" && (claim.status !== "assessed" || previous.evaluatedBy !== claim.evaluatedBy)) {
+          problem(
+            "CLAIM.REVISION_ATTRIBUTION",
+            `${path}/supersedes/${j}`,
+            "An assessed revision must retain its evaluator; other evaluators record independent assessments."
+          );
+        }
+        if (comparePoints(point3(previous.recordedAt), point3(claim.recordedAt)) > 0) {
+          problem(
+            "CLAIM.REVISION_ORDER",
+            `${path}/recordedAt`,
+            "A revision cannot be recorded before the statement it supersedes."
+          );
+        }
+      }
+    }
+    if (claim.kind === "source_assertion") {
+      resolve(claim.provenance.sourceRef, `${path}/provenance/sourceRef`);
+      const source = sources.get(claim.provenance.sourceRef) ?? products.get(claim.provenance.sourceRef);
+      if (source?.digest && claim.provenance.sourceDigest && source.digest.value !== claim.provenance.sourceDigest.value) {
+        problem(
+          "SOURCE.DIGEST_MISMATCH",
+          `${path}/provenance/sourceDigest`,
+          "Digest differs from the inventory declaration; neither is verified against bytes."
+        );
+      }
+      const locator = claim.provenance.locator;
+      if (locator?.kind === "time_range" && locator.endSeconds < locator.startSeconds)
+        problem(
+          "TIME.INTERVAL",
+          `${path}/provenance/locator/endSeconds`,
+          "Locator end precedes its start."
+        );
+    } else {
+      refs(claim.inputRefs, `${path}/inputRefs`, owner);
+      if (claim.status === "assessed") {
+        instant(claim.evaluatedAt, `${path}/evaluatedAt`);
+        if (comparePoints(point3(claim.evaluatedAt), point3(claim.recordedAt)) > 0)
+          problem(
+            "CLAIM.EVALUATION_ORDER",
+            `${path}/evaluatedAt`,
+            "Evaluation cannot occur after the assessment was recorded."
+          );
+        const method = methods.get(claim.methodRef);
+        if (!method)
+          problem(
+            "REF.LOCAL_RESOLUTION",
+            `${path}/methodRef`,
+            "Assessment method is not declared in the Observation inventory."
+          );
+        else if (method.version !== claim.methodVersion)
+          problem(
+            "METHOD.VERSION_MISMATCH",
+            `${path}/methodVersion`,
+            "Assessment method version differs from its inventory declaration."
+          );
+      }
+    }
+  }
+  const indegrees = new Map([...graph.keys()].map((ref2) => [ref2, 0]));
+  for (const edges of graph.values())
+    for (const ref2 of edges) indegrees.set(ref2, indegrees.get(ref2) + 1);
+  const queue = [...indegrees].filter(([, degree]) => degree === 0).map(([ref2]) => ref2);
+  for (let i = 0; i < queue.length; i++)
+    for (const ref2 of graph.get(queue[i]) ?? []) {
+      const degree = indegrees.get(ref2) - 1;
+      indegrees.set(ref2, degree);
+      if (degree === 0) queue.push(ref2);
+    }
+  if (queue.length !== graph.size)
+    problem(
+      "CLAIM.DEPENDENCY_CYCLE",
+      "/claims",
+      "Claim inputs and supersession must form an acyclic history."
+    );
+  const validation = {
+    contract,
+    issues,
+    uncheckedRefs: [
+      ...data.contextRefs.map((r) => r.sha256),
+      ...data.entityRefs.map((r) => r.sha256),
+      ...observationResult.uncheckedRefs,
+      ...data.claims.flatMap((c) => [
+        ...c.subject.kind === "context" ? [c.subject.reference.document.sha256] : [],
+        ...c.kind === "assessment" ? (c.contextInputRefs ?? []).map((r) => r.document.sha256) : []
+      ])
+    ],
+    checks: {
+      structural: "passed",
+      semantic: issues.length ? "failed" : "passed",
+      profile: "not_checked",
+      external: "not_checked"
+    }
+  };
+  return issues.length ? { ...validation, success: false } : {
+    ...validation,
+    success: true,
+    data,
+    currentClaimRefs: [...claims.keys()].filter(
+      (ref2) => !superseded.has(ref2)
+    )
+  };
+}
 
-export { AssessedClaimSchema, CLAIM_HISTORY_RULESET_VERSION, CONTEXT_CLAIM_HISTORY_RULESET_VERSION, CONTEXT_CLAIM_HISTORY_SCHEMA_ID, ClaimSubjectSchema, ContextAssertionReferenceSchema, ContextAssessedClaimSchema, ContextClaimHistorySchema, ContextClaimSubjectSchema, ContextCollectionFields, ContextEntitySchema, ContextEnvironmentFields, ContextEventFields, ContextHistoricalClaimSchema, ContextMeasurementLinkSchema, ContextObjectFields, ContextPlaceFields, ContextPlatformFields, ContextReferenceSchema, ContextSourceStatementSchema, ContextTargetSchema, ContextTemporalFields, ContextUnassessedClaimSchema, DocumentSnapshotRefSchema, EXPERIMENTAL_CLAIM_HISTORY_SCHEMA_ID, EXPERIMENTAL_OBSERVATION_SCHEMA_ID, EventTimeIntervalSchema, EventTimePointSchema, EventTimeSchema, EventTimeValueSchema, ExperimentalClaimHistorySchema, ExperimentalObservationSchema, FramedPositionSchema, HistoricalClaimSchema, MeasuredQuantitySchema, OBSERVATION_CONTEXT_SCHEMA_ID, ObservationAssertionSchema, ObservationContextSchema, ObservationMeasurementSchema, ObservationMethodSchema, ObservationPositionSchema, ObservationProductSchema, ObservationSnapshotRefSchema, ObservationSourceSchema, ObservationTimeSchema, PRIMITIVES_SCHEMA_ID, PositionSchema, PositionValueSchema, PrimitiveRecordSchema, ProcessingActivitySchema, QuantitativeUncertaintySchema, ReferenceFrameSchema, SourceProvenanceSchema, SourceStatementSchema, UnassessedClaimSchema, ValueAssertionSchema, ValueSelectionSchema, compareUtcInstants, contextAssertions, contextClaimHistoryJsonSchema, experimentalClaimHistoryJsonSchema, experimentalObservationJsonSchema, observationContextJsonSchema, parseContextClaimHistory, parseExperimentalClaimHistory, parseExperimentalObservation, parseObservationContext, parsePrimitiveRecord, primitivesJsonSchema };
+export { AssessedClaimSchema, CLAIM_HISTORY_RULESET_VERSION, CONTEXT_CLAIM_HISTORY_RULESET_VERSION, CONTEXT_CLAIM_HISTORY_SCHEMA_ID, ClaimSubjectSchema, ContextAssertionReferenceSchema, ContextAssessedClaimSchema, ContextClaimHistorySchema, ContextClaimSubjectSchema, ContextCollectionFields, ContextEntitySchema, ContextEnvironmentFields, ContextEventFields, ContextHistoricalClaimSchema, ContextMeasurementLinkSchema, ContextObjectFields, ContextPlaceFields, ContextPlatformFields, ContextReferenceSchema, ContextSourceStatementSchema, ContextTargetSchema, ContextTemporalFields, ContextUnassessedClaimSchema, DocumentSnapshotRefSchema, EXPERIMENTAL_CLAIM_HISTORY_SCHEMA_ID, EXPERIMENTAL_OBSERVATION_SCHEMA_ID, EventTimeIntervalSchema, EventTimePointSchema, EventTimeSchema, EventTimeValueSchema, ExperimentalClaimHistorySchema, ExperimentalObservationSchema, FramedPositionSchema, HistoricalClaimSchema, MeasuredQuantitySchema, OBSERVATION_CONTEXT_SCHEMA_ID, ObservationAssertionSchema, ObservationContextSchema, ObservationMeasurementSchema, ObservationMethodSchema, ObservationPositionSchema, ObservationProductSchema, ObservationSnapshotRefSchema, ObservationSourceSchema, ObservationTimeSchema, PRIMITIVES_SCHEMA_ID, PositionSchema, PositionValueSchema, PrimitiveRecordSchema, ProcessingActivitySchema, QuantitativeUncertaintySchema, RESEARCH_CLAIM_HISTORY_RULESET_VERSION, RESEARCH_CLAIM_HISTORY_SCHEMA_ID, RESEARCH_ENTITIES_SCHEMA_ID, ReferenceFrameSchema, ResearchAccountFields, ResearchAssessedClaimSchema, ResearchClaimHistorySchema, ResearchClaimSubjectSchema, ResearchEntitiesSchema, ResearchEntityAssertionReferenceSchema, ResearchEntityReferenceSchema, ResearchEntitySchema, ResearchEntityTargetSchema, ResearchHistoricalClaimSchema, ResearchProcedureFields, ResearchSourceStatementSchema, ResearchUnassessedClaimSchema, ResearchWitnessFields, ResearchWitnessGroupFields, SourceProvenanceSchema, SourceStatementSchema, UnassessedClaimSchema, ValueAssertionSchema, ValueSelectionSchema, WitnessReviewSchema, compareUtcInstants, contextAssertions, contextClaimHistoryJsonSchema, experimentalClaimHistoryJsonSchema, experimentalObservationJsonSchema, observationContextJsonSchema, parseContextClaimHistory, parseExperimentalClaimHistory, parseExperimentalObservation, parseObservationContext, parsePrimitiveRecord, parseResearchClaimHistory, parseResearchEntities, primitivesJsonSchema, researchClaimHistoryJsonSchema, researchEntitiesJsonSchema, researchEntityAssertions, researchEntityContextReferences };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map