@lincs.project/webannotation-schema 1.7.0 → 1.9.0

package/dist/index.js

@@ -52,6 +52,7 @@ __export(src_exports, {
   KeywordFolksnomyEntityType: () => KeywordFolksnomyEntityType,
   Link: () => Link,
   LinkEntityType: () => LinkEntityType,
+  Motivation: () => Motivation,
   Note: () => Note,
   NoteEntityType: () => NoteEntityType,
   Organization: () => Organization,
@@ -165,35 +166,51 @@ var schemaContext = {
     wikidata: "http://www.wikidata.org/entity/",
     crm: "http://www.cidoc-crm.org/cidoc-crm/",
     crmdig: "http://www.ics.forth.gr/isl/CRMdig/",
-    additionalType: {
+    citing: "edit:citing",
+    correcting: "edit:correcting",
+    "oa:identifying": {
+      type: "crm:E55_Type"
+    },
+    "oa:describing": {
+      type: "crm:E55_Type"
+    },
+    "oa:tagging": {
+      type: "crm:E55_Type"
+    },
+    "oa:classifying": {
+      type: "crm:E55_Type"
+    },
+    "oa:linking": {
+      type: "crm:E55_Type"
+    },
+    certainty: {
       "@type": "@id",
       "@id": "crm:P2_has_type"
     },
-    certainty: {
+    precision: {
       "@type": "@id",
       "@id": "crm:P2_has_type"
     },
     contributor: "dcterms:contributor",
-    description: "rdfs:comment",
     entityType: {
       "@type": "@id",
       "@id": "rdf:type"
     },
-    identifiedBy: "crm:P1_is_identified_by",
-    precision: {
+    additionalType: {
       "@type": "@id",
       "@id": "crm:P2_has_type"
     },
+    modeExistence: "edit:ModeExistence",
+    description: "rdfs:comment",
+    identifiedBy: "crm:P1_is_identified_by",
+    title: "crm:P190_has_symbolic_content",
+    usedSpecificObject: "crm:P16_used_specific_object",
     softwareVersion: "schema:softwareVersion",
     status: {
       "@type": "@id",
       "@id": "crm:P2_has_type"
     },
-    title: "crm:P190_has_symbolic_content",
-    usedSpecificObject: "crm:P16_used_specific_object",
     approved: "edit:statusApproved",
-    citing: "edit:citing",
-    correcting: "edit:correcting",
     draft: "edit:statusDraft",
     published: "edit:statusPublished"
   }
@@ -204,7 +221,7 @@ var import_zod = require("zod");
 var userIdDescription = "The IRI that identifies the agent (Creator or Contributor).";
 var User = import_zod.z.object({
   id: import_zod.z.string().url().describe(userIdDescription),
-  type: import_zod.z.tuple([import_zod.z.literal("foaf:Person"), import_zod.z.literal("crm:E21_Person")]).describe("The type of the Agent."),
+  type: import_zod.z.literal("crm:E21_Person").describe("The type of the Agent."),
   name: import_zod.z.string().min(1, { message: "Cannot be empty" }).describe("The name of the agent.")
 }).describe("Human Agent");
 var creatorSchema = {
@@ -212,15 +229,7 @@ var creatorSchema = {
   description: "Software Agent",
   properties: {
     id: { type: "string", format: "uri", description: userIdDescription },
-    type: {
-      type: "array",
-      minItems: 2,
-      maxItems: 2,
-      items: [
-        { type: "string", const: "foaf:Person" },
-        { type: "string", const: "crm:E21_Person" }
-      ]
-    },
+    type: { type: "string", const: "crm:E21_Person" },
     name: { type: "string", minLength: 1, description: "The name of the agent." }
   },
   required: ["id", "type", "name"]
@@ -254,6 +263,37 @@ var import_zod3 = require("zod");
 
 // src/v1/schema/definitions/body/common.ts
 var import_zod2 = require("zod");
+var ModeExistence = import_zod2.z.union([
+  import_zod2.z.literal("edit:modeReal").describe(
+    "An indication that an entity or thing, such as a person, place or text, is understood to be part of lived or historical existence."
+  ),
+  import_zod2.z.literal("edit:modeFictional").describe(
+    "An indication that an entity or a thing, such as a person, place or text, is invented or imagined."
+  ),
+  import_zod2.z.literal("edit:modeIdentifiable").describe(
+    "An indication that an entity or a thing is understood as both existing and imagined, for instance a character in a work of literature that corresponds to a historical person or a place represented under another name that can be identified as a real place."
+  )
+]).describe("An indication of the state of being of an entity or thing (OED).");
+var modeExistenceSchema = {
+  oneOf: [
+    {
+      type: "string",
+      const: "edit:modeReal",
+      description: "An indication that an entity or thing, such as a person, place or text, is understood to be part of lived or historical existence."
+    },
+    {
+      type: "string",
+      const: "edit:modeFictional",
+      description: "An indication that an entity or a thing, such as a person, place or text, is invented or imagined."
+    },
+    {
+      type: "string",
+      const: "edit:modeIdentifiable",
+      description: "An indication that an entity or a thing is understood as both existing and imagined, for instance a character in a work of literature that corresponds to a historical person or a place represented under another name that can be identified as a real place."
+    }
+  ],
+  description: "An indication of the state of being of an entity or thing (OED)."
+};
 var labelDescription = "The title or name of a linked resource or named entity.";
 var Label = import_zod2.z.string().min(1, { message: "The label cannot be empty" }).describe(labelDescription);
 var labelSchema = {
@@ -304,15 +344,13 @@ var citationSchema = {
 var import_zod4 = require("zod");
 var ConceptualObjectEntityType = import_zod4.z.union([
   import_zod4.z.literal("crm:E28_Conceptual_Object"),
-  import_zod4.z.tuple([
-    import_zod4.z.literal("crm:E28_Conceptual_Object"),
-    import_zod4.z.literal("wikidata:Q15831596").describe("Fictional Conceptual Object")
-  ])
+  import_zod4.z.tuple([import_zod4.z.literal("crm:E28_Conceptual_Object"), import_zod4.z.literal("wikidata:Q15831596")])
 ]);
 var ConceptualObject = import_zod4.z.object({
   id: import_zod4.z.string().url().describe(bodyIdDescription),
   entityType: ConceptualObjectEntityType,
   label: Label.optional(),
+  modeExistence: ModeExistence.optional(),
   description: Description.optional()
 }).describe("Conceptual Object");
 var conceptualObjectEntityTypeSchema = {
@@ -324,7 +362,7 @@ var conceptualObjectEntityTypeSchema = {
       maxItems: 2,
       items: [
         { type: "string", const: "crm:E28_Conceptual_Object" },
-        { type: "string", const: "wikidata:Q15831596", description: "Fictional Conceptual Object" }
+        { type: "string", const: "wikidata:Q15831596" }
       ]
     }
   ]
@@ -336,9 +374,32 @@ var conceptualObjectSchema = {
     id: { type: "string", format: "uri", description: bodyIdDescription },
     entityType: conceptualObjectEntityTypeSchema,
     label: { $ref: "defs.jsonld#/definitions/label" },
+    modeExistence: { ...modeExistenceSchema, nullable: true },
     description: { $ref: "defs.jsonld#/definitions/description" }
   },
-  required: ["id", "entityType"]
+  required: ["id", "entityType"],
+  allOf: [
+    {
+      if: {
+        type: "object",
+        properties: {
+          modeExistence: "edit:modeReal"
+        }
+      },
+      then: {
+        type: "object",
+        properties: {
+          entityType: "crm:E28_Conceptual_Object"
+        }
+      },
+      else: {
+        type: "object",
+        properties: {
+          entityType: ["crm:E28_Conceptual_Object", "wikidata:Q15831596"]
+        }
+      }
+    }
+  ]
 };
 
 // src/v1/schema/definitions/body/correction.ts
@@ -417,29 +478,27 @@ var dateSchema = {
 
 // src/v1/schema/definitions/body/event.ts
 var import_zod7 = require("zod");
-var EventEntityType = import_zod7.z.tuple([
-  import_zod7.z.literal("YET TO BE DEFINED EVENT CLASS"),
-  import_zod7.z.union([
-    import_zod7.z.literal("crm:E5_Event").describe("Real Event"),
-    import_zod7.z.literal("crm:E89_Propositional_Object").describe("Fictional Event")
-  ])
+var EventEntityType = import_zod7.z.union([
+  import_zod7.z.literal("crm:E5_Event"),
+  import_zod7.z.tuple([import_zod7.z.literal("crm:E5_Event"), import_zod7.z.literal("crm:E89_Propositional_Object")])
 ]);
 var Event = import_zod7.z.object({
   id: import_zod7.z.string().url().describe(bodyIdDescription),
   entityType: EventEntityType,
   label: Label.optional(),
+  modeExistence: ModeExistence.optional(),
   description: Description.optional()
 }).describe("Event");
 var eventEntityTypeSchema = {
-  type: "array",
-  minItems: 2,
-  maxItems: 2,
-  items: [
-    { type: "string", const: "YET TO BE DEFINED EVENT CLASS" },
+  oneOf: [
+    { type: "string", const: "crm:E5_Event" },
     {
-      oneOf: [
-        { type: "string", const: "crm:E5_Event", description: "Real Event" },
-        { type: "string", const: "crm:E89_Propositional_Object", description: "Fictional Event" }
+      type: "array",
+      minItems: 2,
+      maxItems: 2,
+      items: [
+        { type: "string", const: "crm:E5_Event" },
+        { type: "string", const: "crm:E89_Propositional_Object" }
       ]
     }
   ]
@@ -451,9 +510,32 @@ var eventSchema = {
     id: { type: "string", format: "uri", description: bodyIdDescription },
     entityType: eventEntityTypeSchema,
     label: { $ref: "defs.jsonld#/definitions/label" },
+    modeExistence: { ...modeExistenceSchema, nullable: true },
     description: { $ref: "defs.jsonld#/definitions/description" }
   },
-  required: ["id", "entityType"]
+  required: ["id", "entityType"],
+  allOf: [
+    {
+      if: {
+        type: "object",
+        properties: {
+          modeExistence: "edit:modeReal"
+        }
+      },
+      then: {
+        type: "object",
+        properties: {
+          entityType: "crm:E5_Event"
+        }
+      },
+      else: {
+        type: "object",
+        properties: {
+          entityType: ["crm:E5_Event", "crm:E89_Propositional_Object"]
+        }
+      }
+    }
+  ]
 };
 
 // src/v1/schema/definitions/body/keyword.ts
@@ -582,33 +664,27 @@ var noteSchema = {
 
 // src/v1/schema/definitions/body/organization.ts
 var import_zod11 = require("zod");
-var OrganizationEntityType = import_zod11.z.tuple([
-  import_zod11.z.literal("foaf:Organization"),
-  import_zod11.z.union([
-    import_zod11.z.literal("crm:E74_Group").describe("Real Organization"),
-    import_zod11.z.literal("crm:E89_Propositional_Object").describe("Fictional Organization")
-  ])
+var OrganizationEntityType = import_zod11.z.union([
+  import_zod11.z.literal("crm:E74_Group"),
+  import_zod11.z.tuple([import_zod11.z.literal("foaf:Organization"), import_zod11.z.literal("crm:E89_Propositional_Object")])
 ]);
 var Organization = import_zod11.z.object({
   id: import_zod11.z.string().url().describe(bodyIdDescription),
   entityType: OrganizationEntityType,
   label: Label.optional(),
+  modeExistence: ModeExistence.optional(),
   description: Description.optional()
 }).describe("Organization");
 var organizationEntityTypeSchema = {
-  type: "array",
-  minItems: 2,
-  maxItems: 2,
-  items: [
-    { type: "string", const: "foaf:Organization" },
+  oneOf: [
+    { type: "string", const: "crm:E74_Group" },
     {
-      oneOf: [
-        { type: "string", const: "crm:E74_Group", description: "Real Organization" },
-        {
-          type: "string",
-          const: "crm:E89_Propositional_Object",
-          description: "Fictional Organization"
-        }
+      type: "array",
+      minItems: 2,
+      maxItems: 2,
+      items: [
+        { type: "string", const: "foaf:Organization" },
+        { type: "string", const: "crm:E89_Propositional_Object" }
       ]
     }
   ]
@@ -620,36 +696,57 @@ var organizationSchema = {
     id: { type: "string", format: "uri", description: bodyIdDescription },
     entityType: organizationEntityTypeSchema,
     label: { $ref: "defs.jsonld#/definitions/label" },
+    modeExistence: { ...modeExistenceSchema, nullable: true },
     description: { $ref: "defs.jsonld#/definitions/description" }
   },
-  required: ["id", "entityType"]
+  required: ["id", "entityType"],
+  allOf: [
+    {
+      if: {
+        type: "object",
+        properties: {
+          modeExistence: "edit:modeReal"
+        }
+      },
+      then: {
+        type: "object",
+        properties: {
+          entityType: "crm:E74_Group"
+        }
+      },
+      else: {
+        type: "object",
+        properties: {
+          entityType: ["foaf:Organization", "crm:E89_Propositional_Object"]
+        }
+      }
+    }
+  ]
 };
 
 // src/v1/schema/definitions/body/person.ts
 var import_zod12 = require("zod");
-var PersonEntityType = import_zod12.z.tuple([
-  import_zod12.z.literal("foaf:Person"),
-  import_zod12.z.union([
-    import_zod12.z.literal("crm:E21_Person").describe("Real Person"),
-    import_zod12.z.literal("crm:E89_Propositional_Object").describe("Fictional Person")
-  ])
+var PersonEntityType = import_zod12.z.union([
+  import_zod12.z.literal("crm:E21_Person"),
+  import_zod12.z.tuple([import_zod12.z.literal("foaf:Person"), import_zod12.z.literal("crm:E89_Propositional_Object")])
 ]);
 var Person = import_zod12.z.object({
   id: import_zod12.z.string().url().describe(bodyIdDescription),
   entityType: PersonEntityType,
   label: Label.optional(),
+  modeExistence: ModeExistence.optional(),
   description: Description.optional()
 }).describe("Person");
 var personEntityTypeSchema = {
-  type: "array",
-  minItems: 2,
-  maxItems: 2,
-  items: [
-    { type: "string", const: "foaf:Person" },
+  oneOf: [
+    { type: "string", const: "crm:E21_Person" },
     {
-      oneOf: [
-        { type: "string", const: "crm:E21_Person", description: "Real Person" },
-        { type: "string", const: "crm:E89_Propositional_Object", description: "Fictional Person" }
+      type: "array",
+      minItems: 2,
+      maxItems: 2,
+      items: [
+        { type: "string", const: "foaf:Person" },
+        { type: "string", const: "crm:E89_Propositional_Object" }
       ]
     }
   ]
@@ -661,24 +758,45 @@ var personSchema = {
     id: { type: "string", format: "uri", description: bodyIdDescription },
     entityType: personEntityTypeSchema,
     label: { $ref: "defs.jsonld#/definitions/label" },
+    modeExistence: { ...modeExistenceSchema, nullable: true },
     description: { $ref: "defs.jsonld#/definitions/description" }
   },
-  required: ["id", "entityType"]
+  required: ["id", "entityType"],
+  allOf: [
+    {
+      if: {
+        type: "object",
+        properties: {
+          modeExistence: "edit:modeReal"
+        }
+      },
+      then: {
+        type: "object",
+        properties: {
+          entityType: "crm:E21_Person"
+        }
+      },
+      else: {
+        type: "object",
+        properties: {
+          entityType: ["foaf:Person", "crm:E89_Propositional_Object"]
+        }
+      }
+    }
+  ]
 };
 
 // src/v1/schema/definitions/body/physicalThing.ts
 var import_zod13 = require("zod");
 var PhysicalThingEntityType = import_zod13.z.union([
   import_zod13.z.literal("crm:E18_Physical_Thing"),
-  import_zod13.z.tuple([
-    import_zod13.z.literal("crm:E18_Physical_Thing"),
-    import_zod13.z.literal("wikidata:Q15831596").describe("Fictional Physical Thing")
-  ])
+  import_zod13.z.tuple([import_zod13.z.literal("crm:E18_Physical_Thing"), import_zod13.z.literal("wikidata:Q15831596")])
 ]);
 var PhysicalThing = import_zod13.z.object({
   id: import_zod13.z.string().url().describe(bodyIdDescription),
   entityType: PhysicalThingEntityType,
   label: Label.optional(),
+  modeExistence: ModeExistence.optional(),
   description: Description.optional()
 }).describe("Physical Thing");
 var physicalThingEntityTypeSchema = {
@@ -690,7 +808,7 @@ var physicalThingEntityTypeSchema = {
       maxItems: 2,
       items: [
         { type: "string", const: "crm:E18_Physical_Thing" },
-        { type: "string", const: "wikidata:Q15831596", description: "Fictional Physical Thing" }
+        { type: "string", const: "wikidata:Q15831596" }
       ]
     }
   ]
@@ -702,24 +820,45 @@ var physicalThingSchema = {
     id: { type: "string", format: "uri", description: bodyIdDescription },
     entityType: physicalThingEntityTypeSchema,
     label: { $ref: "defs.jsonld#/definitions/label" },
+    modeExistence: { ...modeExistenceSchema, nullable: true },
     description: { $ref: "defs.jsonld#/definitions/description" }
   },
-  required: ["id", "entityType"]
+  required: ["id", "entityType"],
+  allOf: [
+    {
+      if: {
+        type: "object",
+        properties: {
+          modeExistence: "edit:modeReal"
+        }
+      },
+      then: {
+        type: "object",
+        properties: {
+          entityType: "crm:E18_Physical_Thing"
+        }
+      },
+      else: {
+        type: "object",
+        properties: {
+          entityType: ["crm:E18_Physical_Thing", "wikidata:Q15831596"]
+        }
+      }
+    }
+  ]
 };
 
 // src/v1/schema/definitions/body/place.ts
 var import_zod14 = require("zod");
 var PlaceEntityType = import_zod14.z.union([
   import_zod14.z.literal("cwrc:place"),
-  import_zod14.z.tuple([
-    import_zod14.z.literal("cwrc:place"),
-    import_zod14.z.literal("crm:E89_Propositional_Object").describe("Fictional Place")
-  ])
+  import_zod14.z.tuple([import_zod14.z.literal("cwrc:place"), import_zod14.z.literal("crm:E89_Propositional_Object")])
 ]);
 var Place = import_zod14.z.object({
   id: import_zod14.z.string().url().describe(bodyIdDescription),
   entityType: PlaceEntityType,
   label: Label.optional(),
+  modeExistence: ModeExistence.optional(),
   description: Description.optional()
 }).describe("Place");
 var placeEntityTypeSchema = {
@@ -731,7 +870,7 @@ var placeEntityTypeSchema = {
       maxItems: 2,
       items: [
         { type: "string", const: "cwrc:place" },
-        { type: "string", const: "crm:E89_Propositional_Object", description: "Fictional Place" }
+        { type: "string", const: "crm:E89_Propositional_Object" }
       ]
     }
   ]
@@ -743,36 +882,57 @@ var placeSchema = {
     id: { type: "string", format: "uri", description: bodyIdDescription },
     entityType: placeEntityTypeSchema,
     label: { $ref: "defs.jsonld#/definitions/label" },
+    modeExistence: { ...modeExistenceSchema, nullable: true },
     description: { $ref: "defs.jsonld#/definitions/description" }
   },
-  required: ["id", "entityType"]
+  required: ["id", "entityType"],
+  allOf: [
+    {
+      if: {
+        type: "object",
+        properties: {
+          modeExistence: "edit:modeReal"
+        }
+      },
+      then: {
+        type: "object",
+        properties: {
+          entityType: "cwrc:place"
+        }
+      },
+      else: {
+        type: "object",
+        properties: {
+          entityType: ["cwrc:place", "crm:E89_Propositional_Object"]
+        }
+      }
+    }
+  ]
 };
 
 // src/v1/schema/definitions/body/work.ts
 var import_zod15 = require("zod");
-var WorkEntityType = import_zod15.z.tuple([
+var WorkEntityType = import_zod15.z.union([
   import_zod15.z.literal("crm:E89_Propositional_Object"),
-  import_zod15.z.union([
-    import_zod15.z.literal("frbroo:F1").describe("Real Work"),
-    import_zod15.z.literal("wikidata:Q15306849").describe("Fictional Work")
-  ])
+  import_zod15.z.tuple([import_zod15.z.literal("frbroo:F1"), import_zod15.z.literal("wikidata:Q15306849")])
 ]);
 var Work = import_zod15.z.object({
   id: import_zod15.z.string().url().describe(bodyIdDescription),
   entityType: WorkEntityType,
   label: Label.optional(),
+  modeExistence: ModeExistence.optional(),
   description: Description.optional()
 }).describe("Work");
 var workEntityTypeSchema = {
-  type: "array",
-  minItems: 2,
-  maxItems: 2,
-  items: [
+  oneOf: [
     { type: "string", const: "crm:E89_Propositional_Object" },
     {
-      oneOf: [
-        { type: "string", const: "frbroo:F1", description: "Real Work" },
-        { type: "string", const: "wikidata:Q15306849", description: "Fictional Work" }
+      type: "array",
+      minItems: 2,
+      maxItems: 2,
+      items: [
+        { type: "string", const: "frbroo:F1" },
+        { type: "string", const: "wikidata:Q15306849" }
       ]
     }
   ]
@@ -784,9 +944,32 @@ var workSchema = {
     id: { type: "string", format: "uri", description: bodyIdDescription },
     entityType: workEntityTypeSchema,
     label: { $ref: "defs.jsonld#/definitions/label" },
+    modeExistence: { ...modeExistenceSchema, nullable: true },
     description: { $ref: "defs.jsonld#/definitions/description" }
   },
-  required: ["id", "entityType"]
+  required: ["id", "entityType"],
+  allOf: [
+    {
+      if: {
+        type: "object",
+        properties: {
+          modeExistence: "edit:modeReal"
+        }
+      },
+      then: {
+        type: "object",
+        properties: {
+          entityType: "crm:E89_Propositional_Object"
+        }
+      },
+      else: {
+        type: "object",
+        properties: {
+          entityType: ["frbroo:F1", "wikidata:Q15306849"]
+        }
+      }
+    }
+  ]
 };
 
 // src/v1/schema/definitions/body/choice.ts
@@ -878,6 +1061,7 @@ var Body = import_zod17.z.object({
   additionalType: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.string().array()]).nullish().describe("Extra types that refines the body"),
   value: import_zod17.z.string().describe("The value of the body").optional(),
   label: Label.optional(),
+  modeExistence: ModeExistence.optional(),
   description: Description.optional()
 }).describe("Web Annotation Body");
 var bodySchema = {
@@ -892,6 +1076,7 @@ var bodySchema = {
     },
     value: { type: "string" },
     label: labelSchema,
+    modeExistence: modeExistenceSchema,
     description: descriptionSchema
   },
   required: ["id", "entityType"],
@@ -1486,69 +1671,40 @@ var definitionSchema = {
 };
 
 // src/v1/schema/root.ts
-var import_zod27 = require("zod");
-
-// src/v1/schema/definitions/motivation.ts
 var import_zod26 = require("zod");
-var MotivationInstance = import_zod26.z.union([
-  import_zod26.z.literal("identifying"),
-  import_zod26.z.literal("describing"),
-  import_zod26.z.literal("correcting"),
-  import_zod26.z.literal("tagging"),
-  import_zod26.z.literal("classifying"),
-  import_zod26.z.literal("linking"),
-  import_zod26.z.literal("citing")
-]);
-var MotivationType = import_zod26.z.object({
-  type: import_zod26.z.literal("crm:E55_Type")
-});
-var Motivation = import_zod26.z.record(MotivationInstance, MotivationType).describe("The relationship between an Annotation and a Motivation.");
-var motivationType = {
-  type: "object",
-  properties: {
-    type: { type: "string", const: "crm:E55_Type" }
-  },
-  required: ["type"]
-};
-var motivationSchema = {
-  type: "object",
-  description: "The relationship between an Annotation and a Motivation.",
-  properties: {
-    identifying: { ...motivationType, nullable: true },
-    describing: { ...motivationType, nullable: true },
-    correcting: { ...motivationType, nullable: true },
-    tagging: { ...motivationType, nullable: true },
-    classifying: { ...motivationType, nullable: true },
-    linking: { ...motivationType, nullable: true },
-    citing: { ...motivationType, nullable: true }
-  }
-};
-
-// src/v1/schema/root.ts
 var Status = ["edit:statusDraft", "edit:statusApproved", "edit:statusPublished"];
-var WebAnnotation = import_zod27.z.object({
-  "@context": import_zod27.z.tuple([
-    import_zod27.z.literal("http://www.w3.org/ns/anno.jsonld").describe("W3C Web Annotation Context."),
-    import_zod27.z.literal(contextUri).describe("LINCS Web Annotation Context.")
+var Motivation = [
+  "oa:identifying",
+  "oa:describing",
+  "correcting",
+  "oa:tagging",
+  "oa:classifying",
+  "oa:linking",
+  "citing"
+];
+var WebAnnotation = import_zod26.z.object({
+  "@context": import_zod26.z.tuple([
+    import_zod26.z.literal("http://www.w3.org/ns/anno.jsonld").describe("W3C Web Annotation Context."),
+    import_zod26.z.literal(contextUri).describe("LINCS Web Annotation Context.")
   ]).describe(
     "The context that determines the meaning of the JSON as an Annotation. The itens should point to a URI containing the defiintion used in this schema."
   ),
-  id: import_zod27.z.string().url().describe("The identity of the Annotation."),
-  type: import_zod27.z.tuple([import_zod27.z.literal("Annotation"), import_zod27.z.literal("crm:E33_Linguistic_Object")]).describe("The type of the Annotation."),
-  motivation: Motivation,
-  created: import_zod27.z.string().datetime().describe("The time at which the resource was created."),
-  modified: import_zod27.z.string().datetime().optional().describe("The time at which the resource was modified, after creation."),
+  id: import_zod26.z.string().url().describe("The identity of the Annotation."),
+  type: import_zod26.z.tuple([import_zod26.z.literal("Annotation"), import_zod26.z.literal("crm:E33_Linguistic_Object")]).describe("The type of the Annotation."),
+  motivation: import_zod26.z.enum(Motivation).describe("The relationship between an Annotation and a Motivation."),
+  created: import_zod26.z.string().datetime().describe("The time at which the resource was created."),
+  modified: import_zod26.z.string().datetime().optional().describe("The time at which the resource was modified, after creation."),
   creator: User.describe("The agent responsible for creating the resource.").optional(),
-  contributor: import_zod27.z.array(User.describe("The agents responsible for modifying the resource.")).nonempty().optional().describe("The agents responsible for modifying the resource."),
+  contributor: import_zod26.z.array(User.describe("The agents responsible for modifying the resource.")).nonempty().optional().describe("The agents responsible for modifying the resource."),
   generator: Software.describe(
     "The agent responsible for generating the serialization of the Annotation. "
   ),
   target: Target.describe("The relationship between an Annotation and its Target."),
-  body: import_zod27.z.union([BodyChoice, Body, import_zod27.z.array(Body)]).describe("The relationship between an Annotation and its Body."),
+  body: import_zod26.z.union([BodyChoice, Body, import_zod26.z.array(Body)]).describe("The relationship between an Annotation and its Body."),
   certainty: Certainty.optional(),
   precision: Precision.optional(),
-  label: import_zod27.z.string().min(1, { message: "The label cannot be empty" }).optional().describe("The descriptive label for the annotation"),
-  status: import_zod27.z.enum(Status).describe("The status of this annotation in a workflow.")
+  label: import_zod26.z.string().min(1, { message: "The label cannot be empty" }).optional().describe("The descriptive label for the annotation"),
+  status: import_zod26.z.enum(Status).describe("The status of this annotation in a workflow.").optional()
 }).describe("Web Annotation Root");
 var webAnnotationSchema = {
   $id: schemaId,
@@ -1580,7 +1736,11 @@ var webAnnotationSchema = {
       ],
       description: "The type of the Annotation."
     },
-    motivation: motivationSchema,
+    motivation: {
+      type: "string",
+      enum: Motivation,
+      description: "The relationship between an Annotation and a Motivation."
+    },
     created: {
       type: "string",
       format: "date-time",
@@ -1618,17 +1778,7 @@ var webAnnotationSchema = {
     label: { type: "string" },
     status: { type: "string", enum: Status }
   },
-  required: [
-    "@context",
-    "id",
-    "type",
-    "motivation",
-    "created",
-    "generator",
-    "target",
-    "body",
-    "status"
-  ],
+  required: ["@context", "id", "type", "motivation", "created", "generator", "target", "body"],
   additionalProperties: false,
   allOf: [
     {
@@ -1657,17 +1807,7 @@ var webAnnotationSchema = {
       then: {
         type: "object",
         properties: {
-          motivation: {
-            type: "object",
-            properties: {
-              identifying: {
-                type: "object",
-                properties: {
-                  type: { type: "string", const: "crm:E55_Type" }
-                }
-              }
-            }
-          }
+          motivation: { type: "string", const: "oa:identifying" }
         }
       },
       else: {
@@ -1685,17 +1825,7 @@ var webAnnotationSchema = {
         then: {
           type: "object",
           properties: {
-            motivation: {
-              type: "object",
-              properties: {
-                describing: {
-                  type: "object",
-                  properties: {
-                    type: { type: "string", const: "crm:E55_Type" }
-                  }
-                }
-              }
-            }
+            motivation: { type: "string", const: "oa:describing" }
           }
         },
         else: {
@@ -1713,17 +1843,7 @@ var webAnnotationSchema = {
           then: {
             type: "object",
             properties: {
-              motivation: {
-                type: "object",
-                properties: {
-                  correcting: {
-                    type: "object",
-                    properties: {
-                      type: { type: "string", const: "crm:E55_Type" }
-                    }
-                  }
-                }
-              }
+              motivation: { type: "string", const: "correcting" }
             }
           },
           else: {
@@ -1741,17 +1861,7 @@ var webAnnotationSchema = {
             then: {
               type: "object",
               properties: {
-                motivation: {
-                  type: "object",
-                  properties: {
-                    tagging: {
-                      type: "object",
-                      properties: {
-                        type: { type: "string", const: "crm:E55_Type" }
-                      }
-                    }
-                  }
-                }
+                motivation: { type: "string", const: "oa:tagging" }
               }
             },
             else: {
@@ -1769,17 +1879,7 @@ var webAnnotationSchema = {
               then: {
                 type: "object",
                 properties: {
-                  motivation: {
-                    type: "object",
-                    properties: {
-                      classifying: {
-                        type: "object",
-                        properties: {
-                          type: { type: "string", const: "crm:E55_Type" }
-                        }
-                      }
-                    }
-                  }
+                  motivation: { type: "string", const: "oa:classifying" }
                 }
               },
               else: {
@@ -1797,17 +1897,7 @@ var webAnnotationSchema = {
                 then: {
                   type: "object",
                   properties: {
-                    motivation: {
-                      type: "object",
-                      properties: {
-                        linking: {
-                          type: "object",
-                          properties: {
-                            type: { type: "string", const: "crm:E55_Type" }
-                          }
-                        }
-                      }
-                    }
+                    motivation: { type: "string", const: "oa:linking" }
                   }
                 },
                 else: {
@@ -1825,17 +1915,7 @@ var webAnnotationSchema = {
                   then: {
                     type: "object",
                     properties: {
-                      motivation: {
-                        type: "object",
-                        properties: {
-                          citing: {
-                            type: "object",
-                            properties: {
-                              type: { type: "string", const: "crm:E55_Type" }
-                            }
-                          }
-                        }
-                      }
+                      motivation: { type: "string", const: "citing" }
                     }
                   }
                 }
@@ -1854,18 +1934,18 @@ var import_ajv = __toESM(require("ajv"));
 var import_ajv_formats = __toESM(require("ajv-formats"));
 
 // src/v1/validator/types.ts
-var import_zod28 = require("zod");
-var ValidationError = import_zod28.z.object({
-  message: import_zod28.z.string(),
-  path: import_zod28.z.string(),
-  suggestion: import_zod28.z.string().optional(),
-  context: import_zod28.z.object({
-    errorType: import_zod28.z.string()
-  }).and(import_zod28.z.unknown())
+var import_zod27 = require("zod");
+var ValidationError = import_zod27.z.object({
+  message: import_zod27.z.string(),
+  path: import_zod27.z.string(),
+  suggestion: import_zod27.z.string().optional(),
+  context: import_zod27.z.object({
+    errorType: import_zod27.z.string()
+  }).and(import_zod27.z.unknown())
 });
-var ValidateResult = import_zod28.z.object({
-  valid: import_zod28.z.boolean(),
-  errors: import_zod28.z.array(ValidationError).optional()
+var ValidateResult = import_zod27.z.object({
+  valid: import_zod27.z.boolean(),
+  errors: import_zod27.z.array(ValidationError).optional()
 });
 
 // src/v1/validator/index.ts
@@ -1920,6 +2000,7 @@ __export(v1_exports, {
   KeywordFolksnomyEntityType: () => KeywordFolksnomyEntityType,
   Link: () => Link,
   LinkEntityType: () => LinkEntityType,
+  Motivation: () => Motivation,
   Note: () => Note,
   NoteEntityType: () => NoteEntityType,
   Organization: () => Organization,
@@ -2036,6 +2117,7 @@ __export(v1_exports, {
   KeywordFolksnomyEntityType,
   Link,
   LinkEntityType,
+  Motivation,
   Note,
   NoteEntityType,
   Organization,