@lincs.project/webannotation-schema 1.13.0 → 1.14.0

package/dist/index.js

@@ -32,42 +32,32 @@ var src_exports = {};
 __export(src_exports, {
   Body: () => Body,
   BodyChoice: () => BodyChoice,
-  BodyEntityType: () => BodyEntityType,
   Certainty: () => Certainty,
+  CertaintySchema: () => CertaintySchema,
   Citation: () => Citation,
-  CitationEntityType: () => CitationEntityType,
   ConceptualObject: () => ConceptualObject,
-  ConceptualObjectEntityType: () => ConceptualObjectEntityType,
   Correction: () => Correction,
-  CorrectionEntityType: () => CorrectionEntityType,
+  CssSelector: () => CssSelector,
+  CssSelectorExtended: () => CssSelectorExtended,
   DATE_RANGE_PATTERN: () => DATE_RANGE_PATTERN,
   Date: () => Date,
-  DateEntityType: () => DateEntityType,
   Description: () => Description,
   Event: () => Event,
-  EventEntityType: () => EventEntityType,
   Group: () => Group,
   Keyword: () => Keyword,
-  KeywordEntityType: () => KeywordEntityType,
   KeywordFolksnomy: () => KeywordFolksnomy,
-  KeywordFolksnomyEntityType: () => KeywordFolksnomyEntityType,
   Label: () => Label,
   Link: () => Link,
-  LinkEntityType: () => LinkEntityType,
   ModeExistence: () => ModeExistence,
   Motivation: () => Motivation,
+  MotivationSchema: () => MotivationSchema,
   Note: () => Note,
-  NoteEntityType: () => NoteEntityType,
   Organization: () => Organization,
-  OrganizationEntityType: () => OrganizationEntityType,
   Person: () => Person,
-  PersonEntityType: () => PersonEntityType,
   PhysicalThing: () => PhysicalThing,
-  PhysicalThingEntityType: () => PhysicalThingEntityType,
   Place: () => Place,
-  PlaceEntityType: () => PlaceEntityType,
   Precision: () => Precision,
-  Quality: () => Quality,
+  PrecisionSchema: () => PrecisionSchema,
   RangeSelector: () => RangeSelector,
   Selector: () => Selector,
   Software: () => Software,
@@ -77,59 +67,60 @@ __export(src_exports, {
   TextPositionSelectorExtended: () => TextPositionSelectorExtended,
   TextQuoteSelector: () => TextQuoteSelector,
   TextQuoteSelectorExtended: () => TextQuoteSelectorExtended,
+  TypeBody: () => TypeBody,
+  TypeCitation: () => TypeCitation,
+  TypeConceptualObject: () => TypeConceptualObject,
+  TypeCorrection: () => TypeCorrection,
+  TypeDate: () => TypeDate,
+  TypeEvent: () => TypeEvent,
+  TypeKeyword: () => TypeKeyword,
+  TypeKeywordFolksnomy: () => TypeKeywordFolksnomy,
+  TypeLink: () => TypeLink,
+  TypeNote: () => TypeNote,
+  TypeOrganization: () => TypeOrganization,
+  TypePerson: () => TypePerson,
+  TypePhysicalThing: () => TypePhysicalThing,
+  TypePlace: () => TypePlace,
+  TypeWork: () => TypeWork,
   User: () => User,
   VERSION: () => VERSION,
   ValidateResult: () => ValidateResult,
   ValidationError: () => ValidationError,
   WebAnnotation: () => WebAnnotation,
   Work: () => Work,
-  WorkEntityType: () => WorkEntityType,
   XpathSelector: () => XpathSelector,
   XpathSelectorExtended: () => XpathSelectorExtended,
   ajv: () => ajv,
   bodyChoiceSchema: () => bodyChoiceSchema,
-  bodyEntityTypeSchema: () => bodyEntityTypeSchema,
   bodyIdDescription: () => bodyIdDescription,
   bodySchema: () => bodySchema,
-  certaintySchema: () => certaintySchema,
-  citationEntityTypeSchema: () => citationEntityTypeSchema,
   citationSchema: () => citationSchema,
-  conceptualObjectEntityTypeSchema: () => conceptualObjectEntityTypeSchema,
   conceptualObjectSchema: () => conceptualObjectSchema,
   contextUri: () => contextUri,
-  correctionEntityTypeSchema: () => correctionEntityTypeSchema,
   correctionSchema: () => correctionSchema,
-  dateEntityTypeSchema: () => dateEntityTypeSchema,
+  cssSelectorExtendedSchema: () => cssSelectorExtendedSchema,
+  cssSelectorSchema: () => cssSelectorSchema,
   dateSchema: () => dateSchema,
   definitionSchema: () => definitionSchema,
   defsId: () => defsId,
   descriptionSchema: () => descriptionSchema,
-  eventEntityTypeSchema: () => eventEntityTypeSchema,
   eventSchema: () => eventSchema,
   formatSchema: () => formatSchema,
   groupSchema: () => groupSchema,
   isIdentifiedBy: () => isIdentifiedBy,
   isIndentifyBySchema: () => isIndentifyBySchema,
-  keywordEntityTypeSchema: () => keywordEntityTypeSchema,
-  keywordFolksnomyEntityTypeSchema: () => keywordFolksnomyEntityTypeSchema,
   keywordFolksnomySchema: () => keywordFolksnomySchema,
   keywordSchema: () => keywordSchema,
   labelSchema: () => labelSchema,
   languageSchema: () => languageSchema,
-  linkEntityTypeSchema: () => linkEntityTypeSchema,
   linkSchema: () => linkSchema,
   modeExistenceSchema: () => modeExistenceSchema,
-  noteEntityTypeSchema: () => noteEntityTypeSchema,
   noteSchema: () => noteSchema,
-  organizationEntityTypeSchema: () => organizationEntityTypeSchema,
   organizationSchema: () => organizationSchema,
-  personEntityTypeSchema: () => personEntityTypeSchema,
+  p2HasTypeSchema: () => p2HasTypeSchema,
   personSchema: () => personSchema,
-  physicalThingEntityTypeSchema: () => physicalThingEntityTypeSchema,
   physicalThingSchema: () => physicalThingSchema,
-  placeEntityTypeSchema: () => placeEntityTypeSchema,
   placeSchema: () => placeSchema,
-  precisionSchema: () => precisionSchema,
   rangeSelectorSchema: () => rangeSelectorSchema,
   schemaContext: () => schemaContext,
   schemaId: () => schemaId,
@@ -143,12 +134,26 @@ __export(src_exports, {
   textPositionSelectorSchema: () => textPositionSelectorSchema,
   textQuoteSelectorExtendedSchema: () => textQuoteSelectorExtendedSchema,
   textQuoteSelectorSchema: () => textQuoteSelectorSchema,
+  typeBodySchema: () => typeBodySchema,
+  typeCitationSchema: () => typeCitationSchema,
+  typeConceptualObjectSchema: () => typeConceptualObjectSchema,
+  typeCorrectionSchema: () => typeCorrectionSchema,
+  typeDateSchema: () => typeDateSchema,
+  typeEventSchema: () => typeEventSchema,
+  typeKeywordFolksnomy: () => typeKeywordFolksnomy,
+  typeKeywordSchema: () => typeKeywordSchema,
+  typeLinkSchema: () => typeLinkSchema,
+  typeNoteSchema: () => typeNoteSchema,
+  typeOrganizationSchema: () => typeOrganizationSchema,
+  typePersonSchema: () => typePersonSchema,
+  typePhysicalThingSchema: () => typePhysicalThingSchema,
+  typePlaceSchema: () => typePlaceSchema,
+  typeWorkSchema: () => typeWorkSchema,
   userSchema: () => userSchema,
   v1: () => v1_exports,
   validate: () => validate,
   validator: () => validator,
   webAnnotationSchema: () => webAnnotationSchema,
-  workEntityTypeSchema: () => workEntityTypeSchema,
   workSchema: () => workSchema,
   xpathSelectorExtendedSchema: () => xpathSelectorExtendedSchema,
   xpathSelectorSchema: () => xpathSelectorSchema
@@ -170,6 +175,7 @@ var schemaContext = {
     crmdig: "http://www.ics.forth.gr/isl/CRMdig/",
     cwrc: "http://id.lincsproject.ca/cwrc/",
     edit: "http://id.lincsproject.ca/edit/",
+    event: "http://id.lincsproject.ca/event",
     fabio: "https://purl.org/spar/fabio/",
     frbroo: "http://iflastandards.info/ns/fr/frbr/frbroo/",
     wikidata: "http://www.wikidata.org/entity/",
@@ -190,27 +196,7 @@ var schemaContext = {
     "oa:linking": {
       type: "crm:E55_Type"
     },
-    certainty: {
-      "@type": "@id",
-      "@id": "http://temp.lincsproject.ca/certainty"
-    },
-    precision: {
-      "@type": "@id",
-      "@id": "http://temp.lincsproject.ca/precision"
-    },
     contributor: "dcterms:contributor",
-    entityType: {
-      "@type": "@id",
-      "@id": "rdf:type"
-    },
-    additionalType: {
-      "@type": "@id",
-      "@id": "crm:P2_has_type"
-    },
-    modeExistence: {
-      "@type": "@id",
-      "@id": "edit:ModeExistence"
-    },
     description: "rdfs:comment",
     title: "crm:P190_has_symbolic_content",
     softwareVersion: "schema:softwareVersion"
@@ -222,8 +208,20 @@ var import_zod = require("zod");
 var User = import_zod.z.object({
   id: import_zod.z.string().url(),
   type: import_zod.z.literal("crm:E21_Person"),
-  name: import_zod.z.string().min(1, { message: "Cannot be empty" }).describe(`The person's name.`)
+  name: import_zod.z.string().min(1).describe(`The person's name.`)
 }).describe("Human Agent");
+var Group = import_zod.z.object({
+  id: import_zod.z.string().url(),
+  type: import_zod.z.literal("crm:E74_Group"),
+  name: import_zod.z.string().min(1).describe(`The group's name.`)
+}).describe("Group Agent");
+var Software = import_zod.z.object({
+  id: import_zod.z.string().url(),
+  type: import_zod.z.tuple([import_zod.z.literal("Software"), import_zod.z.literal("crm:E73_Information_Object")]),
+  P16_used_specific_object: import_zod.z.string().url().optional().describe("The URI that identifies the agent (software)"),
+  name: import_zod.z.string().min(1).describe(`The software's name.`),
+  softwareVersion: import_zod.z.string().optional().describe("The software version.")
+}).describe("Software Agent");
 var userSchema = {
   type: "object",
   description: "User Agent",
@@ -234,11 +232,6 @@ var userSchema = {
   },
   required: ["id", "type", "name"]
 };
-var Group = import_zod.z.object({
-  id: import_zod.z.string().url(),
-  type: import_zod.z.literal("crm:E74_Group"),
-  name: import_zod.z.string().min(1).describe(`The group's name.`)
-}).describe("Group Agent");
 var groupSchema = {
   type: "object",
   description: "Group Agent",
@@ -249,13 +242,6 @@ var groupSchema = {
   },
   required: ["id", "type", "name"]
 };
-var Software = import_zod.z.object({
-  id: import_zod.z.string().url(),
-  type: import_zod.z.tuple([import_zod.z.literal("Software"), import_zod.z.literal("crm:E73_Information_Object")]),
-  P16_used_specific_object: import_zod.z.string().url().optional().describe("The URI that identifies the agent (software)"),
-  name: import_zod.z.string().min(1).describe(`The software's name.`),
-  softwareVersion: import_zod.z.string().optional().describe("The software version.")
-}).describe("Software Agent");
 var softwareSchema = {
   type: "object",
   description: "Software Agent",
@@ -285,37 +271,6 @@ 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 = {
@@ -329,19 +284,40 @@ var descriptionSchema = {
   type: "string",
   description: descriptionDescription
 };
+var modeExistenceDescription = "An indication of the state of being of an entity or thing (OED).";
+var modeExistenceRealDescription = "An indication that an entity or thing, such as a person, place or text, is understood to be part of lived or historical existence.";
+var modeExistenceFictionalDescription = "An indication that an entity or a thing, such as a person, place or text, is invented or imagined.";
+var modeExistenceFictionalizedDescription = "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.";
+var ModeExistence = import_zod2.z.union([
+  import_zod2.z.literal("edit:modeReal").describe(modeExistenceRealDescription),
+  import_zod2.z.literal("edit:modeFictional").describe(modeExistenceFictionalDescription),
+  import_zod2.z.literal("edit:Fictionalized").describe(modeExistenceFictionalizedDescription)
+]).describe(modeExistenceDescription);
+var modeExistenceSchema = {
+  oneOf: [
+    { type: "string", const: "edit:modeReal", description: modeExistenceRealDescription },
+    { type: "string", const: "edit:modeFictional", description: modeExistenceFictionalDescription },
+    {
+      type: "string",
+      const: "edit:modeFictionalized",
+      description: modeExistenceFictionalizedDescription
+    }
+  ],
+  description: modeExistenceDescription
+};
 
 // src/v1/schema/definitions/body/citation.ts
-var CitationEntityType = import_zod3.z.tuple([
+var TypeCitation = import_zod3.z.tuple([
   import_zod3.z.literal("cito:Citation"),
   import_zod3.z.literal("crm:E73_Information_Object")
 ]);
 var Citation = import_zod3.z.object({
   id: import_zod3.z.string().url().describe(bodyIdDescription),
-  entityType: CitationEntityType,
+  type: TypeCitation,
   label: Label.optional(),
   description: Description.optional()
 }).describe("Citation");
-var citationEntityTypeSchema = {
+var typeCitationSchema = {
   type: "array",
   minItems: 2,
   maxItems: 2,
@@ -352,109 +328,74 @@ var citationEntityTypeSchema = {
 };
 var citationSchema = {
   type: "object",
-  description: "A citation entity",
+  description: "Citation",
   properties: {
     id: { type: "string", format: "uri", description: bodyIdDescription },
-    entityType: citationEntityTypeSchema,
+    type: typeCitationSchema,
     label: { $ref: "defs.jsonld#/definitions/label" },
     description: { $ref: "defs.jsonld#/definitions/description" }
   },
-  required: ["id", "entityType"]
+  required: ["id", "type"]
 };
 
 // src/v1/schema/definitions/body/conceptualObject.ts
 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")])
-]);
+var TypeConceptualObject = import_zod4.z.literal("crm:E28_Conceptual_Object");
 var ConceptualObject = import_zod4.z.object({
   id: import_zod4.z.string().url().describe(bodyIdDescription),
-  entityType: ConceptualObjectEntityType,
+  type: TypeConceptualObject,
   label: Label.optional(),
-  modeExistence: ModeExistence.optional(),
+  P2_has_type: import_zod4.z.array(import_zod4.z.string()).optional(),
   description: Description.optional()
 }).describe("Conceptual Object");
-var conceptualObjectEntityTypeSchema = {
-  oneOf: [
-    { type: "string", const: "crm:E28_Conceptual_Object" },
-    {
-      type: "array",
-      minItems: 2,
-      maxItems: 2,
-      items: [
-        { type: "string", const: "crm:E28_Conceptual_Object" },
-        { type: "string", const: "wikidata:Q15831596" }
-      ]
-    }
-  ]
+var typeConceptualObjectSchema = {
+  type: "string",
+  const: "crm:E28_Conceptual_Object"
 };
 var conceptualObjectSchema = {
   type: "object",
-  description: "A conceptual object entity",
+  description: "Conceptual Object",
   properties: {
     id: { type: "string", format: "uri", description: bodyIdDescription },
-    entityType: conceptualObjectEntityTypeSchema,
+    type: typeConceptualObjectSchema,
     label: { $ref: "defs.jsonld#/definitions/label" },
-    modeExistence: { ...modeExistenceSchema, nullable: true },
+    P2_has_type: { type: "array", items: { type: "string" } },
     description: { $ref: "defs.jsonld#/definitions/description" }
   },
-  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"]
-        }
-      }
-    }
-  ]
+  required: ["id", "type"]
 };
 
 // src/v1/schema/definitions/body/correction.ts
 var import_zod5 = require("zod");
-var CorrectionEntityType = import_zod5.z.tuple([
+var TypeCorrection = import_zod5.z.tuple([
+  import_zod5.z.literal("TextualBody"),
   import_zod5.z.literal("fabio:Correction"),
   import_zod5.z.literal("crm:E33_Linguistic_Object")
 ]);
 var Correction = import_zod5.z.object({
   id: import_zod5.z.string().url().describe(bodyIdDescription),
-  type: import_zod5.z.literal("TextualBody"),
-  entityType: CorrectionEntityType,
+  type: TypeCorrection,
   value: import_zod5.z.string().describe("The correction.")
 }).describe("Correction");
-var correctionEntityTypeSchema = {
+var typeCorrectionSchema = {
   type: "array",
-  minItems: 2,
-  maxItems: 2,
+  minItems: 3,
+  maxItems: 3,
   items: [
+    { type: "string", const: "TextualBody" },
     { type: "string", const: "fabio:Correction" },
     { type: "string", const: "crm:E33_Linguistic_Object" }
   ]
 };
 var correctionSchema = {
   type: "object",
-  description: "A correction entity",
+  description: "Correction",
   properties: {
     id: { type: "string", format: "uri", description: bodyIdDescription },
-    type: { type: "string", const: "TextualBody" },
-    entityType: correctionEntityTypeSchema,
+    type: typeCorrectionSchema,
     value: { type: "string" }
   },
-  required: ["id", "type", "entityType", "value"]
+  required: ["id", "type", "value"]
   // errorMessage: {
   //   properties: {
   //     type: 'must be exacty "TextualBody"',
@@ -465,53 +406,51 @@ var correctionSchema = {
 // src/v1/schema/definitions/body/date.ts
 var import_zod6 = require("zod");
 var DATE_RANGE_PATTERN = "^(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2}(?:.\\d*)?)((-(\\d{2}):(\\d{2})|Z)?)\\/(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2}(?:.\\d*)?)((-(\\d{2}):(\\d{2})|Z)?)$";
-var DateEntityType = import_zod6.z.tuple([import_zod6.z.literal("xsd:date"), import_zod6.z.literal("crm:E52_Time-Span")]);
+var TypeDate = import_zod6.z.tuple([
+  import_zod6.z.literal("TextualBody"),
+  import_zod6.z.literal("xsd:date"),
+  import_zod6.z.literal("crm:E52_Time-Span")
+]);
 var Date = import_zod6.z.object({
   id: import_zod6.z.string().url().describe(bodyIdDescription),
-  type: import_zod6.z.literal("TextualBody"),
-  entityType: DateEntityType,
-  value: import_zod6.z.string().regex(new RegExp(DATE_RANGE_PATTERN)).describe("The date time.")
+  type: TypeDate,
+  value: import_zod6.z.string().regex(new RegExp(DATE_RANGE_PATTERN))
 }).describe("Date");
-var dateEntityTypeSchema = {
+var typeDateSchema = {
   type: "array",
-  minItems: 2,
-  maxItems: 2,
+  minItems: 3,
+  maxItems: 3,
   items: [
+    { type: "string", const: "TextualBody" },
     { type: "string", const: "xsd:date" },
     { type: "string", const: "crm:E52_Time-Span" }
   ]
 };
 var dateSchema = {
   type: "object",
-  description: "A date entity",
+  description: "Date",
   properties: {
     id: { type: "string", format: "uri", description: bodyIdDescription },
-    type: { type: "string", const: "TextualBody" },
-    entityType: dateEntityTypeSchema,
+    type: typeDateSchema,
     value: { type: "string", pattern: DATE_RANGE_PATTERN }
   },
-  required: ["id", "type", "entityType", "value"]
-  // errorMessage: {
-  //   properties: {
-  //     type: 'must be exacty "TextualBody"',
-  //   },
-  // },
+  required: ["id", "type", "value"]
 };
 
 // src/v1/schema/definitions/body/event.ts
 var import_zod7 = require("zod");
-var EventEntityType = import_zod7.z.union([
+var TypeEvent = 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")])
+  import_zod7.z.tuple([import_zod7.z.literal("event: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,
+  type: TypeEvent,
   label: Label.optional(),
-  modeExistence: ModeExistence.optional(),
+  P2_has_type: import_zod7.z.tuple([ModeExistence]).rest(import_zod7.z.string().optional()).optional(),
   description: Description.optional()
 }).describe("Event");
-var eventEntityTypeSchema = {
+var typeEventSchema = {
   oneOf: [
     { type: "string", const: "crm:E5_Event" },
     {
@@ -519,7 +458,7 @@ var eventEntityTypeSchema = {
       minItems: 2,
       maxItems: 2,
       items: [
-        { type: "string", const: "crm:E5_Event" },
+        { type: "string", const: "event:Event" },
         { type: "string", const: "crm:E89_Propositional_Object" }
       ]
     }
@@ -527,33 +466,39 @@ var eventEntityTypeSchema = {
 };
 var eventSchema = {
   type: "object",
-  description: "An event entity",
+  description: "Event",
   properties: {
     id: { type: "string", format: "uri", description: bodyIdDescription },
-    entityType: eventEntityTypeSchema,
+    type: typeEventSchema,
     label: { $ref: "defs.jsonld#/definitions/label" },
-    modeExistence: { ...modeExistenceSchema, nullable: true },
+    P2_has_type: {
+      type: "array",
+      items: [{ ...modeExistenceSchema }],
+      minItems: 1,
+      maxItems: 100,
+      additionalItems: { type: "string", nullable: true }
+    },
     description: { $ref: "defs.jsonld#/definitions/description" }
   },
-  required: ["id", "entityType"],
+  required: ["id", "type"],
   allOf: [
     {
       if: {
         type: "object",
         properties: {
-          modeExistence: "edit:modeReal"
+          P2_has_type: ["edit:modeReal"]
         }
       },
       then: {
         type: "object",
         properties: {
-          entityType: "crm:E5_Event"
+          type: "crm:E5_Event"
         }
       },
       else: {
         type: "object",
         properties: {
-          entityType: ["crm:E5_Event", "crm:E89_Propositional_Object"]
+          type: ["event:Event", "crm:E89_Propositional_Object"]
         }
       }
     }
@@ -562,17 +507,27 @@ var eventSchema = {
 
 // src/v1/schema/definitions/body/keyword.ts
 var import_zod8 = require("zod");
-var KeywordEntityType = import_zod8.z.tuple([
+var TypeKeyword = import_zod8.z.tuple([
   import_zod8.z.literal("crm:E55_Type"),
   import_zod8.z.literal("crmdig:D1_Digital_Object")
 ]);
 var Keyword = import_zod8.z.object({
   id: import_zod8.z.string().url().describe(bodyIdDescription),
-  entityType: KeywordEntityType,
+  type: TypeKeyword,
   label: Label.optional(),
   description: Description.optional()
 }).describe("Keyword");
-var keywordEntityTypeSchema = {
+var TypeKeywordFolksnomy = import_zod8.z.tuple([
+  import_zod8.z.literal("TextualBody"),
+  import_zod8.z.literal("crm:E55_Type"),
+  import_zod8.z.literal("crm:E33_Linguistic_Object")
+]);
+var KeywordFolksnomy = import_zod8.z.object({
+  id: import_zod8.z.string().url().describe(bodyIdDescription),
+  type: TypeKeywordFolksnomy,
+  value: import_zod8.z.string().describe("The keyword.")
+}).describe("Keyword");
+var typeKeywordSchema = {
   type: "array",
   minItems: 2,
   maxItems: 2,
@@ -583,44 +538,34 @@ var keywordEntityTypeSchema = {
 };
 var keywordSchema = {
   type: "object",
-  description: "A keyword entity",
+  description: "Keyword",
   properties: {
     id: { type: "string", format: "uri", description: bodyIdDescription },
-    entityType: keywordEntityTypeSchema,
+    type: typeKeywordSchema,
     label: { $ref: "defs.jsonld#/definitions/label" },
     description: { $ref: "defs.jsonld#/definitions/description" }
   },
-  required: ["id", "entityType"]
+  required: ["id", "type"]
 };
-var KeywordFolksnomyEntityType = import_zod8.z.tuple([
-  import_zod8.z.literal("crm:E55_Type"),
-  import_zod8.z.literal("crm:E33_Linguistic_Object")
-]);
-var KeywordFolksnomy = import_zod8.z.object({
-  id: import_zod8.z.string().url().describe(bodyIdDescription),
-  type: import_zod8.z.literal("TextualBody"),
-  entityType: KeywordFolksnomyEntityType,
-  value: import_zod8.z.string().describe("The keyword.")
-}).describe("Keyword");
-var keywordFolksnomyEntityTypeSchema = {
+var typeKeywordFolksnomy = {
   type: "array",
-  minItems: 2,
-  maxItems: 2,
+  minItems: 3,
+  maxItems: 3,
   items: [
+    { type: "string", const: "TextualBody" },
     { type: "string", const: "crm:E55_Type" },
     { type: "string", const: "crm:E33_Linguistic_Object" }
   ]
 };
 var keywordFolksnomySchema = {
   type: "object",
-  description: "A keyword entity",
+  description: "keyword - Folksonomy",
   properties: {
     id: { type: "string", format: "uri", description: bodyIdDescription },
-    type: { type: "string", const: "TextualBody" },
-    entityType: keywordFolksnomyEntityTypeSchema,
+    type: typeKeywordFolksnomy,
     value: { type: "string" }
   },
-  required: ["id", "type", "entityType", "value"]
+  required: ["id", "type", "value"]
   // errorMessage: {
   //   properties: {
   //     type: 'must be exacty "TextualBody"',
@@ -631,73 +576,69 @@ var keywordFolksnomySchema = {
 // src/v1/schema/definitions/body/link.ts
 var import_zod9 = require("zod");
 var idDescription = "The link URL.";
-var LinkEntityType = import_zod9.z.literal("crmdig:D1_Digital_Object");
+var TypeLink = import_zod9.z.literal("crmdig:D1_Digital_Object");
 var Link = import_zod9.z.object({
   id: import_zod9.z.string().url().describe(idDescription),
-  entityType: LinkEntityType
+  type: TypeLink
 }).describe("A link to a webpage");
-var linkEntityTypeSchema = {
+var typeLinkSchema = {
   type: "string",
   const: "crmdig:D1_Digital_Object"
 };
 var linkSchema = {
   type: "object",
-  description: "A link entity",
+  description: "Link",
   properties: {
     id: { type: "string", format: "uri", description: idDescription },
-    entityType: linkEntityTypeSchema
+    type: typeLinkSchema
   },
-  required: ["id", "entityType"]
+  required: ["id", "type"]
 };
 
 // src/v1/schema/definitions/body/note.ts
 var import_zod10 = require("zod");
-var NoteEntityType = import_zod10.z.literal("crm:E33_Linguistic_Object");
+var TypeNote = import_zod10.z.tuple([import_zod10.z.literal("TextualBody"), import_zod10.z.literal("crm:E33_Linguistic_Object")]);
 var Note = import_zod10.z.object({
   id: import_zod10.z.string().url().describe(bodyIdDescription),
-  type: import_zod10.z.literal("TextualBody"),
-  entityType: NoteEntityType,
-  additionalType: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.string().array()]).optional().describe("Extra types that refines the note"),
-  value: import_zod10.z.string().describe("The note.")
+  type: TypeNote,
+  value: import_zod10.z.string(),
+  P2_has_type: import_zod10.z.array(import_zod10.z.string()).optional()
 }).describe("Note");
-var noteEntityTypeSchema = {
-  type: "string",
-  const: "crm:E33_Linguistic_Object"
+var typeNoteSchema = {
+  type: "array",
+  minItems: 2,
+  maxItems: 2,
+  items: [
+    { type: "string", const: "TextualBody" },
+    { type: "string", const: "crm:E33_Linguistic_Object" }
+  ]
 };
 var noteSchema = {
   type: "object",
-  description: "A note entity",
+  description: "Note",
   properties: {
     id: { type: "string", format: "uri", description: bodyIdDescription },
-    type: { type: "string", const: "TextualBody" },
-    entityType: noteEntityTypeSchema,
-    additionalType: {
-      oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
-    },
-    value: { type: "string" }
+    type: typeNoteSchema,
+    value: { type: "string" },
+    P2_has_type: { type: "array", items: { type: "string" } }
   },
-  required: ["id", "type", "entityType", "value"]
-  // errorMessage: {
-  //   properties: {
-  //     type: 'must be exacty "TextualBody"',
-  //   },
-  // },
+  required: ["id", "type", "value"]
 };
 
 // src/v1/schema/definitions/body/organization.ts
 var import_zod11 = require("zod");
-var OrganizationEntityType = import_zod11.z.union([
+var TypeOrganization = 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,
+  type: TypeOrganization,
   label: Label.optional(),
-  modeExistence: ModeExistence.optional(),
+  P2_has_type: import_zod11.z.tuple([ModeExistence]).rest(import_zod11.z.string().optional()).optional(),
   description: Description.optional()
 }).describe("Organization");
-var organizationEntityTypeSchema = {
+var typeOrganizationSchema = {
   oneOf: [
     { type: "string", const: "crm:E74_Group" },
     {
@@ -713,33 +654,39 @@ var organizationEntityTypeSchema = {
 };
 var organizationSchema = {
   type: "object",
-  description: "A organization entity",
+  description: "Organization",
   properties: {
     id: { type: "string", format: "uri", description: bodyIdDescription },
-    entityType: organizationEntityTypeSchema,
+    type: typeOrganizationSchema,
     label: { $ref: "defs.jsonld#/definitions/label" },
-    modeExistence: { ...modeExistenceSchema, nullable: true },
+    P2_has_type: {
+      type: "array",
+      items: [{ ...modeExistenceSchema }],
+      minItems: 1,
+      maxItems: 100,
+      additionalItems: { type: "string", nullable: true }
+    },
     description: { $ref: "defs.jsonld#/definitions/description" }
   },
-  required: ["id", "entityType"],
+  required: ["id", "type"],
   allOf: [
     {
       if: {
         type: "object",
         properties: {
-          modeExistence: "edit:modeReal"
+          P2_has_type: ["edit:modeReal"]
         }
       },
       then: {
         type: "object",
         properties: {
-          entityType: "crm:E74_Group"
+          type: "crm:E74_Group"
         }
       },
       else: {
         type: "object",
         properties: {
-          entityType: ["foaf:Organization", "crm:E89_Propositional_Object"]
+          type: ["foaf:Organization", "crm:E89_Propositional_Object"]
         }
       }
     }
@@ -748,18 +695,18 @@ var organizationSchema = {
 
 // src/v1/schema/definitions/body/person.ts
 var import_zod12 = require("zod");
-var PersonEntityType = import_zod12.z.union([
+var TypePerson = 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,
+  type: TypePerson,
   label: Label.optional(),
-  modeExistence: ModeExistence.optional(),
+  P2_has_type: import_zod12.z.tuple([ModeExistence]).rest(import_zod12.z.string().optional()).optional(),
   description: Description.optional()
 }).describe("Person");
-var personEntityTypeSchema = {
+var typePersonSchema = {
   oneOf: [
     { type: "string", const: "crm:E21_Person" },
     {
@@ -775,33 +722,39 @@ var personEntityTypeSchema = {
 };
 var personSchema = {
   type: "object",
-  description: "A person entity",
+  description: "Person",
   properties: {
     id: { type: "string", format: "uri", description: bodyIdDescription },
-    entityType: personEntityTypeSchema,
+    type: typePersonSchema,
     label: { $ref: "defs.jsonld#/definitions/label" },
-    modeExistence: { ...modeExistenceSchema, nullable: true },
+    P2_has_type: {
+      type: "array",
+      items: [{ ...modeExistenceSchema }],
+      minItems: 1,
+      maxItems: 1,
+      additionalItems: { type: "string", nullable: true }
+    },
     description: { $ref: "defs.jsonld#/definitions/description" }
   },
-  required: ["id", "entityType"],
+  required: ["id", "type"],
   allOf: [
     {
       if: {
         type: "object",
         properties: {
-          modeExistence: "edit:modeReal"
+          P2_has_type: ["edit:modeReal"]
         }
       },
       then: {
         type: "object",
         properties: {
-          entityType: "crm:E21_Person"
+          type: "crm:E21_Person"
         }
       },
       else: {
         type: "object",
         properties: {
-          entityType: ["foaf:Person", "crm:E89_Propositional_Object"]
+          type: ["foaf:Person", "crm:E89_Propositional_Object"]
         }
       }
     }
@@ -810,18 +763,18 @@ var personSchema = {
 
 // src/v1/schema/definitions/body/physicalThing.ts
 var import_zod13 = require("zod");
-var PhysicalThingEntityType = import_zod13.z.union([
+var TypePhysicalThing = 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")])
 ]);
 var PhysicalThing = import_zod13.z.object({
   id: import_zod13.z.string().url().describe(bodyIdDescription),
-  entityType: PhysicalThingEntityType,
+  type: TypePhysicalThing,
   label: Label.optional(),
-  modeExistence: ModeExistence.optional(),
+  P2_has_type: import_zod13.z.tuple([ModeExistence]).rest(import_zod13.z.string().optional()).optional(),
   description: Description.optional()
 }).describe("Physical Thing");
-var physicalThingEntityTypeSchema = {
+var typePhysicalThingSchema = {
   oneOf: [
     { type: "string", const: "crm:E18_Physical_Thing" },
     {
@@ -837,33 +790,39 @@ var physicalThingEntityTypeSchema = {
 };
 var physicalThingSchema = {
   type: "object",
-  description: "A physical thing entity",
+  description: "Physical Thing",
   properties: {
     id: { type: "string", format: "uri", description: bodyIdDescription },
-    entityType: physicalThingEntityTypeSchema,
+    type: typePhysicalThingSchema,
     label: { $ref: "defs.jsonld#/definitions/label" },
-    modeExistence: { ...modeExistenceSchema, nullable: true },
+    P2_has_type: {
+      type: "array",
+      items: [{ ...modeExistenceSchema }],
+      minItems: 1,
+      maxItems: 100,
+      additionalItems: { type: "string", nullable: true }
+    },
     description: { $ref: "defs.jsonld#/definitions/description" }
   },
-  required: ["id", "entityType"],
+  required: ["id", "type"],
   allOf: [
     {
       if: {
         type: "object",
         properties: {
-          modeExistence: "edit:modeReal"
+          P2_has_type: ["edit:modeReal"]
         }
       },
       then: {
         type: "object",
         properties: {
-          entityType: "crm:E18_Physical_Thing"
+          type: "crm:E18_Physical_Thing"
         }
       },
       else: {
         type: "object",
         properties: {
-          entityType: ["crm:E18_Physical_Thing", "wikidata:Q15831596"]
+          type: ["crm:E18_Physical_Thing", "wikidata:Q15831596"]
         }
       }
     }
@@ -872,18 +831,18 @@ var physicalThingSchema = {
 
 // src/v1/schema/definitions/body/place.ts
 var import_zod14 = require("zod");
-var PlaceEntityType = import_zod14.z.union([
+var TypePlace = import_zod14.z.union([
   import_zod14.z.literal("crm:E53_Place"),
   import_zod14.z.tuple([import_zod14.z.literal("biography:fictionalPlace"), import_zod14.z.literal("crm:E89_Propositional_Object")])
 ]);
 var Place = import_zod14.z.object({
   id: import_zod14.z.string().url().describe(bodyIdDescription),
-  entityType: PlaceEntityType,
+  type: TypePlace,
   label: Label.optional(),
-  modeExistence: ModeExistence.optional(),
+  P2_has_type: import_zod14.z.tuple([ModeExistence]).rest(import_zod14.z.string().optional()).optional(),
   description: Description.optional()
 }).describe("Place");
-var placeEntityTypeSchema = {
+var typePlaceSchema = {
   oneOf: [
     { type: "string", const: "crm:E53_Place" },
     {
@@ -899,33 +858,39 @@ var placeEntityTypeSchema = {
 };
 var placeSchema = {
   type: "object",
-  description: "A place entity",
+  description: "Place",
   properties: {
     id: { type: "string", format: "uri", description: bodyIdDescription },
-    entityType: placeEntityTypeSchema,
+    type: typePlaceSchema,
     label: { $ref: "defs.jsonld#/definitions/label" },
-    modeExistence: { ...modeExistenceSchema, nullable: true },
+    P2_has_type: {
+      type: "array",
+      items: [{ ...modeExistenceSchema }],
+      minItems: 1,
+      maxItems: 100,
+      additionalItems: { type: "string", nullable: true }
+    },
     description: { $ref: "defs.jsonld#/definitions/description" }
   },
-  required: ["id", "entityType"],
+  required: ["id", "type"],
   allOf: [
     {
       if: {
         type: "object",
         properties: {
-          modeExistence: "edit:modeReal"
+          P2_has_type: ["edit:modeReal"]
         }
       },
       then: {
         type: "object",
         properties: {
-          entityType: "crm:E53_Place"
+          type: "crm:E53_Place"
         }
       },
       else: {
         type: "object",
         properties: {
-          entityType: ["biography:fictionalPlace", "crm:E89_Propositional_Object"]
+          type: ["biography:fictionalPlace", "crm:E89_Propositional_Object"]
         }
       }
     }
@@ -934,18 +899,18 @@ var placeSchema = {
 
 // src/v1/schema/definitions/body/work.ts
 var import_zod15 = require("zod");
-var WorkEntityType = import_zod15.z.union([
+var TypeWork = import_zod15.z.union([
   import_zod15.z.literal("frbroo:F1"),
   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,
+  type: TypeWork,
   label: Label.optional(),
-  modeExistence: ModeExistence.optional(),
+  P2_has_type: import_zod15.z.tuple([ModeExistence]).rest(import_zod15.z.string().optional()).optional(),
   description: Description.optional()
 }).describe("Work");
-var workEntityTypeSchema = {
+var typeWorkSchema = {
   oneOf: [
     { type: "string", const: "frbroo:F1" },
     {
@@ -961,33 +926,39 @@ var workEntityTypeSchema = {
 };
 var workSchema = {
   type: "object",
-  description: "A work entity",
+  description: "Work",
   properties: {
     id: { type: "string", format: "uri", description: bodyIdDescription },
-    entityType: workEntityTypeSchema,
+    type: typeWorkSchema,
     label: { $ref: "defs.jsonld#/definitions/label" },
-    modeExistence: { ...modeExistenceSchema, nullable: true },
+    P2_has_type: {
+      type: "array",
+      items: [{ ...modeExistenceSchema }],
+      minItems: 1,
+      maxItems: 100,
+      additionalItems: { type: "string", nullable: true }
+    },
     description: { $ref: "defs.jsonld#/definitions/description" }
   },
-  required: ["id", "entityType"],
+  required: ["id", "type"],
   allOf: [
     {
       if: {
         type: "object",
         properties: {
-          modeExistence: "edit:modeReal"
+          P2_has_type: ["edit:modeReal"]
         }
       },
       then: {
         type: "object",
         properties: {
-          entityType: "crm:E89_Propositional_Object"
+          type: "crm:E89_Propositional_Object"
         }
       },
       else: {
         type: "object",
         properties: {
-          entityType: ["frbroo:F1", "wikidata:Q15306849"]
+          type: ["frbroo:F1", "wikidata:Q15306849"]
         }
       }
     }
@@ -1000,8 +971,6 @@ var bodyIdDescription2 = "The IRI that identifies the Body resource.";
 var BodyChoice = import_zod16.z.object({
   id: import_zod16.z.string().url().describe(bodyIdDescription2),
   type: import_zod16.z.literal("Choice"),
-  entityType: BodyEntityType,
-  label: Label.optional(),
   items: import_zod16.z.array(Body)
 });
 var bodyChoiceSchema = {
@@ -1010,165 +979,103 @@ var bodyChoiceSchema = {
   properties: {
     id: { type: "string", format: "uri", description: bodyIdDescription2 },
     type: { type: "string", const: "Choice" },
-    entityType: {
-      oneOf: [
-        personEntityTypeSchema,
-        placeEntityTypeSchema,
-        organizationEntityTypeSchema,
-        workEntityTypeSchema,
-        physicalThingEntityTypeSchema,
-        conceptualObjectEntityTypeSchema,
-        citationEntityTypeSchema,
-        dateEntityTypeSchema,
-        noteEntityTypeSchema,
-        correctionEntityTypeSchema,
-        keywordEntityTypeSchema,
-        keywordFolksnomyEntityTypeSchema,
-        linkEntityTypeSchema,
-        eventEntityTypeSchema
-      ]
-    },
-    label: labelSchema,
     items: {
       type: "array",
-      // items: bodySchema,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
       items: { $ref: "defs.jsonld#/definitions/body" }
     }
   },
-  required: ["id", "type", "entityType", "items"],
+  required: ["id", "type", "items"],
   additionalProperties: false
 };
 
 // src/v1/schema/definitions/body/index.ts
 var bodyIdDescription = "The IRI that identifies the Body resource.";
-var BodyEntityType = import_zod17.z.union([
-  PersonEntityType,
-  PlaceEntityType,
-  OrganizationEntityType,
-  WorkEntityType,
-  PhysicalThingEntityType,
-  ConceptualObjectEntityType,
-  CitationEntityType,
-  DateEntityType,
-  NoteEntityType,
-  CorrectionEntityType,
-  KeywordEntityType,
-  KeywordFolksnomyEntityType,
-  LinkEntityType,
-  EventEntityType
+var TypeBody = import_zod17.z.union([
+  TypePerson,
+  TypePlace,
+  TypeOrganization,
+  TypeWork,
+  TypePhysicalThing,
+  TypeConceptualObject,
+  TypeCitation,
+  TypeDate,
+  TypeNote,
+  TypeCorrection,
+  TypeKeyword,
+  TypeKeywordFolksnomy,
+  TypeLink,
+  TypeEvent
 ]);
-var bodyEntityTypeSchema = {
-  oneOf: [
-    personEntityTypeSchema,
-    placeEntityTypeSchema,
-    organizationEntityTypeSchema,
-    workEntityTypeSchema,
-    physicalThingEntityTypeSchema,
-    conceptualObjectEntityTypeSchema,
-    citationEntityTypeSchema,
-    dateEntityTypeSchema,
-    noteEntityTypeSchema,
-    correctionEntityTypeSchema,
-    keywordEntityTypeSchema,
-    keywordFolksnomyEntityTypeSchema,
-    linkEntityTypeSchema,
-    eventEntityTypeSchema
-  ]
-};
 var Body = import_zod17.z.object({
   id: import_zod17.z.string().url().describe(bodyIdDescription),
-  type: import_zod17.z.literal("TextualBody").optional(),
-  entityType: BodyEntityType,
-  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(),
+  type: TypeBody,
+  value: import_zod17.z.string().optional(),
   label: Label.optional(),
-  modeExistence: ModeExistence.optional(),
+  P2_has_type: import_zod17.z.array(import_zod17.z.string()).optional(),
   description: Description.optional()
 }).describe("Web Annotation Body");
+var typeBodySchema = {
+  oneOf: [
+    typePersonSchema,
+    typePlaceSchema,
+    typeOrganizationSchema,
+    typeWorkSchema,
+    typePhysicalThingSchema,
+    typeConceptualObjectSchema,
+    typeEventSchema,
+    typeCitationSchema,
+    typeDateSchema,
+    typeNoteSchema,
+    typeCorrectionSchema,
+    typeKeywordSchema,
+    typeKeywordFolksnomy,
+    typeLinkSchema
+  ]
+};
 var bodySchema = {
   type: "object",
   description: "Web Annotation Body",
   properties: {
     id: { type: "string", format: "uri", description: bodyIdDescription },
-    type: { type: "string", const: "TextualBody" },
-    entityType: bodyEntityTypeSchema,
-    additionalType: {
-      anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
-    },
+    type: typeBodySchema,
     value: { type: "string" },
     label: labelSchema,
-    modeExistence: modeExistenceSchema,
+    P2_has_type: { type: "array", items: { type: "string" } },
     description: descriptionSchema
   },
-  required: ["id", "entityType"],
-  // * Conditional restrictions
+  required: ["id", "type"],
   anyOf: [
-    //* IF entityType is date OR correction OR keyword THEN type = TextualBody
-    //* && IF entityType is date THEN value = date range pattern ELSE value = string
     {
       if: {
         type: "object",
         properties: {
-          entityType: {
-            anyOf: [
-              { const: "crm:E33_Linguistic_Object" },
-              {
-                type: "array",
-                minItems: 2,
-                maxItems: 2,
-                items: [{ const: "xsd:date" }, { const: "crm:E52_Time-Span" }]
-              },
-              {
-                type: "array",
-                minItems: 2,
-                maxItems: 2,
-                items: [{ const: "fabio:Correction" }, { const: "crm:E33_Linguistic_Object" }]
-              },
-              {
-                type: "array",
-                minItems: 2,
-                maxItems: 2,
-                items: [{ const: "crm:E55_Type" }, { const: "crm:E33_Linguistic_Object" }]
-              }
-            ]
+          type: {
+            anyOf: [typeNoteSchema, typeDateSchema, typeCorrectionSchema, typeKeywordFolksnomy]
           }
         }
       },
       then: {
         type: "object",
-        required: ["type", "value"],
-        properties: {
-          type: { type: "string", const: "TextualBody" }
-        },
+        required: ["id", "type", "value"],
         if: {
           type: "object",
           properties: {
-            entityType: {
-              type: "array",
-              minItems: 2,
-              maxItems: 2,
-              items: [{ const: "xsd:date" }, { const: "crm:E52_Time-Span" }]
-            }
+            type: typeDateSchema
           }
         },
         then: {
           type: "object",
+          required: ["id", "type", "value"],
           properties: {
             value: {
               type: "string",
               pattern: DATE_RANGE_PATTERN
             }
           }
-        },
-        else: {
-          type: "object",
-          properties: { value: { type: "string" } }
         }
       }
     }
-    // TODO: Add more restrictions
-    // ? Not accept value for some entityTypes
   ],
   additionalProperties: false
 };
@@ -1179,10 +1086,7 @@ var import_zod25 = require("zod");
 // src/v1/schema/definitions/target/selector/index.ts
 var import_zod23 = require("zod");
 
-// src/v1/schema/definitions/target/selector/range.ts
-var import_zod21 = require("zod");
-
-// src/v1/schema/definitions/target/selector/xpath.ts
+// src/v1/schema/definitions/target/selector/css.ts
 var import_zod20 = require("zod");
 
 // src/v1/schema/definitions/target/selector/textPosition.ts
@@ -1308,18 +1212,18 @@ var textQuoteSelectorExtendedSchema = {
   required: ["id", "type", "exact", "prefix", "suffix"]
 };
 
-// src/v1/schema/definitions/target/selector/xpath.ts
-var XpathSelector = import_zod20.z.object({
+// src/v1/schema/definitions/target/selector/css.ts
+var CssSelector = import_zod20.z.object({
   id: import_zod20.z.string().describe(selectorIdDescription),
-  type: import_zod20.z.tuple([import_zod20.z.literal("XPathSelector"), import_zod20.z.literal("crm:E73_Information_Object")]),
-  value: import_zod20.z.string().min(1).describe("The xpath to the selected segment.")
-}).describe("Xpath Selector");
-var XpathSelectorExtended = XpathSelector.extend({
+  type: import_zod20.z.tuple([import_zod20.z.literal("CssSelector"), import_zod20.z.literal("crm:E73_Information_Object")]),
+  value: import_zod20.z.string().min(1).describe("The CSS to the selected a segment.")
+}).describe("CSS Selector");
+var CssSelectorExtended = CssSelector.extend({
   refinedBy: import_zod20.z.union([TextPositionSelector, TextQuoteSelector]).optional().describe(selectorRefinedByDescription)
 });
-var xpathSelectorSchema = {
+var cssSelectorSchema = {
   type: "object",
-  description: "Xpath Selector",
+  description: "Css Selector",
   properties: {
     id: { type: "string", format: "uri", description: selectorIdDescription },
     type: {
@@ -1327,23 +1231,23 @@ var xpathSelectorSchema = {
       minItems: 2,
       maxItems: 2,
       items: [
-        { type: "string", const: "XPathSelector" },
+        { type: "string", const: "CssSelector" },
         { type: "string", const: "crm:E73_Information_Object" }
       ],
       description: "The class of the Selector,"
     },
     value: {
       type: "string",
-      description: "Web Annotation Target Select Xpath"
+      description: "Web Annotation Target Select CSS"
     }
   },
   required: ["id", "type", "value"]
 };
-var xpathSelectorExtendedSchema = {
+var cssSelectorExtendedSchema = {
   type: "object",
-  description: "Xpath Selector",
+  description: "CSS Selector",
   properties: {
-    ...xpathSelectorSchema.properties,
+    ...cssSelectorSchema.properties,
     refinedBy: {
       type: "object",
       description: selectorRefinedByDescription,
@@ -1358,46 +1262,21 @@ var xpathSelectorExtendedSchema = {
 };
 
 // src/v1/schema/definitions/target/selector/range.ts
-var RangeSelector = import_zod21.z.object({
-  id: import_zod21.z.string().url().describe(selectorIdDescription),
-  type: import_zod21.z.tuple([import_zod21.z.literal("RangeSelector"), import_zod21.z.literal("crm:E73_Information_Object")]),
-  startSelector: XpathSelector,
-  endSelector: XpathSelector
-}).describe("Range Selector");
-var rangeSelectorSchema = {
-  type: "object",
-  description: "Range Selector",
-  properties: {
-    id: { type: "string", format: "uri", description: selectorIdDescription },
-    type: {
-      type: "array",
-      minItems: 2,
-      maxItems: 2,
-      items: [
-        { type: "string", const: "RangeSelector" },
-        { type: "string", const: "crm:E73_Information_Object" }
-      ],
-      description: "The class of the Selector,"
-    },
-    startSelector: { $ref: "defs.jsonld#/definitions/xpathSelector" },
-    endSelector: { $ref: "defs.jsonld#/definitions/xpathSelector" }
-  },
-  required: ["id", "type", "startSelector", "endSelector"]
-};
-
-// src/v1/schema/definitions/target/selector/css.ts
 var import_zod22 = require("zod");
-var CssSelector = import_zod22.z.object({
-  id: import_zod22.z.string().describe(selectorIdDescription),
-  type: import_zod22.z.tuple([import_zod22.z.literal("CssSelector"), import_zod22.z.literal("crm:E73_Information_Object")]),
-  value: import_zod22.z.string().min(1).describe("The CSS to the selected a segment.")
-}).describe("CSS Selector");
-var CssSelectorExtended = CssSelector.extend({
-  refinedBy: import_zod22.z.union([TextPositionSelector, TextQuoteSelector]).optional().describe(selectorRefinedByDescription)
+
+// src/v1/schema/definitions/target/selector/xpath.ts
+var import_zod21 = require("zod");
+var XpathSelector = import_zod21.z.object({
+  id: import_zod21.z.string().describe(selectorIdDescription),
+  type: import_zod21.z.tuple([import_zod21.z.literal("XPathSelector"), import_zod21.z.literal("crm:E73_Information_Object")]),
+  value: import_zod21.z.string().min(1).describe("The xpath to the selected segment.")
+}).describe("Xpath Selector");
+var XpathSelectorExtended = XpathSelector.extend({
+  refinedBy: import_zod21.z.union([TextPositionSelector, TextQuoteSelector]).optional().describe(selectorRefinedByDescription)
 });
-var cssSelectorSchema = {
+var xpathSelectorSchema = {
   type: "object",
-  description: "Css Selector",
+  description: "Xpath Selector",
   properties: {
     id: { type: "string", format: "uri", description: selectorIdDescription },
     type: {
@@ -1405,23 +1284,23 @@ var cssSelectorSchema = {
       minItems: 2,
       maxItems: 2,
       items: [
-        { type: "string", const: "CssSelector" },
+        { type: "string", const: "XPathSelector" },
         { type: "string", const: "crm:E73_Information_Object" }
       ],
       description: "The class of the Selector,"
     },
     value: {
       type: "string",
-      description: "Web Annotation Target Select CSS"
+      description: "Web Annotation Target Select Xpath"
     }
   },
   required: ["id", "type", "value"]
 };
-var cssSelectorExtendedSchema = {
+var xpathSelectorExtendedSchema = {
   type: "object",
-  description: "CSS Selector",
+  description: "Xpath Selector",
   properties: {
-    ...cssSelectorSchema.properties,
+    ...xpathSelectorSchema.properties,
     refinedBy: {
       type: "object",
       description: selectorRefinedByDescription,
@@ -1435,6 +1314,34 @@ var cssSelectorExtendedSchema = {
   required: ["id", "type", "value"]
 };
 
+// src/v1/schema/definitions/target/selector/range.ts
+var RangeSelector = import_zod22.z.object({
+  id: import_zod22.z.string().url().describe(selectorIdDescription),
+  type: import_zod22.z.tuple([import_zod22.z.literal("RangeSelector"), import_zod22.z.literal("crm:E73_Information_Object")]),
+  startSelector: XpathSelector,
+  endSelector: XpathSelector
+}).describe("Range Selector");
+var rangeSelectorSchema = {
+  type: "object",
+  description: "Range Selector",
+  properties: {
+    id: { type: "string", format: "uri", description: selectorIdDescription },
+    type: {
+      type: "array",
+      minItems: 2,
+      maxItems: 2,
+      items: [
+        { type: "string", const: "RangeSelector" },
+        { type: "string", const: "crm:E73_Information_Object" }
+      ],
+      description: "The class of the Selector,"
+    },
+    startSelector: { $ref: "defs.jsonld#/definitions/xpathSelector" },
+    endSelector: { $ref: "defs.jsonld#/definitions/xpathSelector" }
+  },
+  required: ["id", "type", "startSelector", "endSelector"]
+};
+
 // src/v1/schema/definitions/target/selector/index.ts
 var selectorIdDescription = "UUID that identifies the selector.";
 var selectorRefinedByDescription = "The relationship between a broader selector and the more specific selector that should be applied to the results of the first.";
@@ -1460,48 +1367,41 @@ var selectorSchema = {
 // src/v1/schema/definitions/target/source.ts
 var import_zod24 = require("zod");
 var formatDescription = "The format of the Web Resource's content. The value of the property should be the media-type of the format, following the [rfc6838] specification.";
+var languageDescription = "The language of the Web Resource's content. The value of the property should be a language code following the [bcp47] specification.";
+var titleDescription = "The title of the document being annotated.";
+var sourceIdDescription = "The IRI that identifies the Target source.";
 var Format = import_zod24.z.string().min(1).describe(formatDescription);
+var Language = import_zod24.z.string().min(2).max(3).describe(languageDescription);
+var isIdentifiedBy = import_zod24.z.object({
+  id: import_zod24.z.string().url(),
+  type: import_zod24.z.literal("crm:E33_E41_Linguistic_Appellation"),
+  title: import_zod24.z.string().min(1).describe(titleDescription)
+});
+var Source = import_zod24.z.object({
+  id: import_zod24.z.string().url().describe(sourceIdDescription),
+  type: import_zod24.z.literal("crm:D1_Digital_Object"),
+  format: import_zod24.z.union([Format, import_zod24.z.array(Format).min(1)]).describe(formatDescription),
+  P1_is_identified_by: isIdentifiedBy.optional(),
+  language: import_zod24.z.union([Language, import_zod24.z.array(Language).min(1)]).optional().describe(languageDescription)
+}).describe("Web Annotation Target");
 var formatSchema = {
   type: "string",
   description: formatDescription,
   minLength: 1
 };
-var languageDescription = "The language of the Web Resource's content. The value of the property should be a language code following the [bcp47] specification.";
-var Language = import_zod24.z.string().min(2).max(3).describe(languageDescription);
 var languageSchema = {
   type: "string",
   description: languageDescription,
   minLength: 2,
   maxLength: 3
 };
-var sourceIdDescription = "The IRI that identifies the Target source.";
-var isIdentifiedBy = import_zod24.z.object({
-  id: import_zod24.z.string().url(),
-  type: import_zod24.z.literal("crm:E33_E41_Linguistic_Appellation"),
-  title: import_zod24.z.string().min(1).describe("The title of the document being annotated.")
-});
-var Source = import_zod24.z.object({
-  id: import_zod24.z.string().url().describe(sourceIdDescription),
-  type: import_zod24.z.literal("crm:D1_Digital_Object"),
-  format: import_zod24.z.union([Format, import_zod24.z.array(Format).min(1)]).describe(
-    "The formats of the Web Resource's content. The value of the property should and array of  media-types of the format, following the [rfc6838] specification."
-  ),
-  P1_is_identified_by: isIdentifiedBy.optional(),
-  language: import_zod24.z.union([Language, import_zod24.z.array(Language).min(1)]).optional().describe(
-    "The languages of the Web Resource's content. The value of the property should be an array of language code following the [bcp47] specification."
-  )
-}).describe("Web Annotation Target");
 var isIndentifyBySchema = {
   type: "object",
   description: "indentifyBy",
   properties: {
     id: { type: "string", format: "uri" },
     type: { type: "string", const: "crm:E33_E41_Linguistic_Appellation" },
-    title: {
-      type: "string",
-      minLength: 1,
-      description: "The title of the document being annotated."
-    }
+    title: { type: "string", minLength: 1, description: titleDescription }
   },
   required: ["id", "type", "title"]
 };
@@ -1515,12 +1415,7 @@ var sourceSchema = {
       type: ["string", "array"],
       anyOf: [
         formatSchema,
-        {
-          type: "array",
-          minItems: 1,
-          items: formatSchema,
-          description: "The formats of the Web Resource's content. The value of the property should and array of  media-types of the format, following the [rfc6838] specification."
-        }
+        { type: "array", minItems: 1, items: formatSchema, description: formatDescription }
       ]
     },
     P1_is_identified_by: { ...isIndentifyBySchema, nullable: true },
@@ -1529,12 +1424,7 @@ var sourceSchema = {
       nullable: true,
       anyOf: [
         languageSchema,
-        {
-          type: "array",
-          minItems: 1,
-          items: languageSchema,
-          description: "The languages of the Web Resource's content. The value of the property should be an array of language code following the [bcp47] specification."
-        }
+        { type: "array", minItems: 1, items: languageSchema, description: languageDescription }
       ]
     }
   },
@@ -1543,13 +1433,12 @@ var sourceSchema = {
 
 // src/v1/schema/definitions/target/index.ts
 var targetIdDescription = "The IRI that identifies the Target resource.";
+var renderedViaDescription = "The relationship between the Specific Resource that represents the Target in the annotation, and the piece of software or other system that was used to render the Target when the annotation was created.";
 var Target = import_zod25.z.object({
   id: import_zod25.z.string().url().describe(targetIdDescription),
   type: import_zod25.z.tuple([import_zod25.z.literal("SpecificResource"), import_zod25.z.literal("crm:E73_Information_Object")]).describe("The class of the Specific Resource."),
   source: Source,
-  renderedVia: Software.optional().describe(
-    "The relationship between the Specific Resource that represents the Target in the annotation, and the piece of software or other system that was used to render the Target when the annotation was created."
-  ),
+  renderedVia: Software.optional().describe(renderedViaDescription),
   selector: import_zod25.z.union([Selector, import_zod25.z.array(Selector)]).describe("The relationship between a Specific Resource and a Selector.").optional()
 }).describe("Web Annotation Target");
 var targetSchema = {
@@ -1568,19 +1457,9 @@ var targetSchema = {
       description: "The class of the Specific Resource."
     },
     source: sourceSchema,
-    renderedVia: {
-      $ref: "defs.jsonld#/definitions/software",
-      description: "The relationship between the Specific Resource that represents the Target in the annotation, and the piece of software or other system that was used to render the Target when the annotation was created."
-    },
+    renderedVia: { $ref: "defs.jsonld#/definitions/software", description: renderedViaDescription },
     selector: {
-      anyOf: [
-        selectorSchema,
-        {
-          type: "array",
-          items: selectorSchema,
-          minItems: 1
-        }
-      ]
+      anyOf: [selectorSchema, { type: "array", items: selectorSchema, minItems: 1 }]
     }
   },
   required: ["id", "type", "source"],
@@ -1725,24 +1604,58 @@ var targetSchema = {
 
 // src/v1/schema/definitions/common.ts
 var import_zod26 = require("zod");
-var Quality = [
-  "edit:qualityLow",
-  "edit:qualityMedium",
-  "edit:qualityHigh",
-  "edit:qualityUnknown"
-];
-var certaintyDescription = "Indicates the degree of certainty associated with some aspect of an assertion, description, identification, or entity linked to the annotation body.";
-var Certainty = import_zod26.z.enum(Quality).describe(certaintyDescription);
-var certaintySchema = {
-  type: "string",
-  enum: Quality,
-  description: certaintyDescription
+var descriptionMotivation = "The relationship between an Annotation and a Motivation.";
+var Motivation = import_zod26.z.union([
+  import_zod26.z.literal("oa:identifying"),
+  import_zod26.z.literal("oa:describing"),
+  import_zod26.z.literal("correcting"),
+  import_zod26.z.literal("oa:tagging"),
+  import_zod26.z.literal("oa:classifying"),
+  import_zod26.z.literal("oa:linking"),
+  import_zod26.z.literal("citing")
+]).describe(descriptionMotivation);
+var MotivationSchema = {
+  oneOf: [
+    { type: "string", const: "oa:identifying" },
+    { type: "string", const: "oa:describing" },
+    { type: "string", const: "correcting" },
+    { type: "string", const: "oa:tagging" },
+    { type: "string", const: "oa:classifying" },
+    { type: "string", const: "oa:linking" },
+    { type: "string", const: "citing" }
+  ],
+  description: descriptionMotivation
+};
+var descriptionCertainty = "Indicates the degree of certainty associated with some aspect of an assertion, description, identification, or entity linked to the annotation body.";
+var Certainty = import_zod26.z.union([
+  import_zod26.z.literal("edit:qualityLowCertainty"),
+  import_zod26.z.literal("edit:qualityMediumCertainty"),
+  import_zod26.z.literal("edit:qualityHighCertainty"),
+  import_zod26.z.literal("edit:qualityUnknownCertainty")
+]).describe(descriptionCertainty);
+var CertaintySchema = {
+  oneOf: [
+    { type: "string", const: "edit:qualityLowCertainty" },
+    { type: "string", const: "edit:qualityMediumCertainty" },
+    { type: "string", const: "edit:qualityHighCertainty" },
+    { type: "string", const: "edit:qualityUnknownCertainty" }
+  ],
+  description: descriptionCertainty
 };
 var precisionDescription = "Indicates the degree of precision associated with the location of the entity linked to the annotation body.";
-var Precision = import_zod26.z.enum(Quality).describe(precisionDescription);
-var precisionSchema = {
-  type: "string",
-  enum: Quality,
+var Precision = import_zod26.z.union([
+  import_zod26.z.literal("edit:qualityLowPrecision"),
+  import_zod26.z.literal("edit:qualityMediumPrecision"),
+  import_zod26.z.literal("edit:qualityHighPrecision"),
+  import_zod26.z.literal("edit:qualityUnknownPrecision")
+]).describe(precisionDescription);
+var PrecisionSchema = {
+  oneOf: [
+    { type: "string", const: "edit:qualityLowPrecision" },
+    { type: "string", const: "edit:qualityMediumPrecision" },
+    { type: "string", const: "edit:qualityHighPrecision" },
+    { type: "string", const: "edit:qualityUnknownPrecision" }
+  ],
   description: precisionDescription
 };
 
@@ -1767,15 +1680,6 @@ var definitionSchema = {
 
 // src/v1/schema/root.ts
 var import_zod27 = require("zod");
-var Motivation = [
-  "oa:identifying",
-  "oa:describing",
-  "correcting",
-  "oa:tagging",
-  "oa:classifying",
-  "oa:linking",
-  "citing"
-];
 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."),
@@ -1786,21 +1690,26 @@ var WebAnnotation = import_zod27.z.object({
   ),
   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: import_zod27.z.enum(Motivation).describe("The relationship between an Annotation and a Motivation."),
+  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."),
-  creator: import_zod27.z.union([User, Group, Software]).describe("The agent responsible for creating the resource.").optional(),
-  contributor: import_zod27.z.array(import_zod27.z.union([User, Group, Software])).nonempty().optional().describe("The agents responsible for modifying the resource."),
+  creator: import_zod27.z.union([User, Group]).describe("The agent responsible for creating the resource.").optional(),
+  contributor: import_zod27.z.array(import_zod27.z.union([User, Group])).nonempty().optional().describe("The agents responsible for modifying the resource."),
   generator: Software.describe(
     "The agent responsible for generating the serialization of the Annotation. "
   ),
   target: import_zod27.z.union([Target, import_zod27.z.array(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."),
-  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"),
-  P2_has_type: import_zod27.z.union([import_zod27.z.string().min(3), import_zod27.z.array(import_zod27.z.string().min(3)).min(1)]).optional()
+  P2_has_type: import_zod27.z.tuple([Motivation]).rest(import_zod27.z.union([Certainty, Precision]).optional())
 }).describe("Web Annotation Root");
+var p2HasTypeSchema = {
+  type: "array",
+  minItems: 1,
+  maxItems: 3,
+  items: [{ ...MotivationSchema }],
+  additionalItems: { oneOf: [CertaintySchema, PrecisionSchema] }
+};
 var webAnnotationSchema = {
   $id: schemaId,
   type: "object",
@@ -1832,11 +1741,7 @@ var webAnnotationSchema = {
       ],
       description: "The type of the Annotation."
     },
-    motivation: {
-      type: "string",
-      enum: Motivation,
-      description: "The relationship between an Annotation and a Motivation."
-    },
+    motivation: MotivationSchema,
     created: {
       type: "string",
       format: "date-time",
@@ -1850,8 +1755,7 @@ var webAnnotationSchema = {
     creator: {
       oneOf: [
         { $ref: "defs.jsonld#/definitions/user" },
-        { $ref: "defs.jsonld#/definitions/group" },
-        { $ref: "defs.jsonld#/definitions/software" }
+        { $ref: "defs.jsonld#/definitions/group" }
       ]
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
     },
@@ -1891,25 +1795,20 @@ var webAnnotationSchema = {
         }
       ]
     },
-    certainty: certaintySchema,
-    precision: precisionSchema,
     label: { type: "string" },
-    P2_has_type: {
-      oneOf: [
-        { type: "string", minLength: 3 },
-        {
-          type: "array",
-          minItems: 1,
-          items: {
-            type: "string",
-            minLength: 3
-          },
-          uniqueItems: true
-        }
-      ]
-    }
+    P2_has_type: p2HasTypeSchema
   },
-  required: ["@context", "id", "type", "motivation", "created", "generator", "target", "body"],
+  required: [
+    "@context",
+    "id",
+    "type",
+    "motivation",
+    "created",
+    "generator",
+    "target",
+    "body",
+    "P2_has_type"
+  ],
   additionalProperties: false,
   allOf: [
     {
@@ -1919,16 +1818,16 @@ var webAnnotationSchema = {
           body: {
             type: "object",
             properties: {
-              entityType: {
+              type: {
                 oneOf: [
-                  personEntityTypeSchema,
-                  placeEntityTypeSchema,
-                  organizationEntityTypeSchema,
-                  workEntityTypeSchema,
-                  physicalThingEntityTypeSchema,
-                  conceptualObjectEntityTypeSchema,
-                  dateEntityTypeSchema,
-                  eventEntityTypeSchema
+                  typePersonSchema,
+                  typePlaceSchema,
+                  typeOrganizationSchema,
+                  typeWorkSchema,
+                  typePhysicalThingSchema,
+                  typeConceptualObjectSchema,
+                  typeDateSchema,
+                  typeEventSchema
                 ]
               }
             }
@@ -1938,7 +1837,14 @@ var webAnnotationSchema = {
       then: {
         type: "object",
         properties: {
-          motivation: { type: "string", const: "oa:identifying" }
+          motivation: { type: "string", const: "oa:identifying" },
+          P2_has_type: {
+            type: "array",
+            minItems: 1,
+            maxItems: 3,
+            items: [{ type: "string", const: "oa:identifying" }],
+            additionalItems: { oneOf: [CertaintySchema, PrecisionSchema] }
+          }
         }
       },
       else: {
@@ -1948,7 +1854,7 @@ var webAnnotationSchema = {
             body: {
               type: "object",
               properties: {
-                entityType: noteEntityTypeSchema
+                type: typeNoteSchema
               }
             }
           }
@@ -1956,7 +1862,11 @@ var webAnnotationSchema = {
         then: {
           type: "object",
           properties: {
-            motivation: { type: "string", const: "oa:describing" }
+            motivation: { type: "string", const: "oa:describing" },
+            P2_has_type: {
+              ...p2HasTypeSchema,
+              items: [{ type: "string", const: "oa:describing" }]
+            }
           }
         },
         else: {
@@ -1966,7 +1876,7 @@ var webAnnotationSchema = {
               body: {
                 type: "object",
                 properties: {
-                  entityType: correctionEntityTypeSchema
+                  type: typeCorrectionSchema
                 }
               }
             }
@@ -1974,7 +1884,11 @@ var webAnnotationSchema = {
           then: {
             type: "object",
             properties: {
-              motivation: { type: "string", const: "correcting" }
+              motivation: { type: "string", const: "correcting" },
+              P2_has_type: {
+                ...p2HasTypeSchema,
+                items: [{ type: "string", const: "correcting" }]
+              }
             }
           },
           else: {
@@ -1984,7 +1898,7 @@ var webAnnotationSchema = {
                 body: {
                   type: "object",
                   properties: {
-                    entityType: keywordFolksnomyEntityTypeSchema
+                    type: typeKeywordFolksnomy
                   }
                 }
               }
@@ -1992,7 +1906,11 @@ var webAnnotationSchema = {
             then: {
               type: "object",
               properties: {
-                motivation: { type: "string", const: "oa:tagging" }
+                motivation: { type: "string", const: "oa:tagging" },
+                P2_has_type: {
+                  ...p2HasTypeSchema,
+                  items: [{ type: "string", const: "oa:tagging" }]
+                }
               }
             },
             else: {
@@ -2002,7 +1920,7 @@ var webAnnotationSchema = {
                   body: {
                     type: "object",
                     properties: {
-                      entityType: keywordEntityTypeSchema
+                      type: typeKeywordSchema
                     }
                   }
                 }
@@ -2010,7 +1928,11 @@ var webAnnotationSchema = {
               then: {
                 type: "object",
                 properties: {
-                  motivation: { type: "string", const: "oa:classifying" }
+                  motivation: { type: "string", const: "oa:classifying" },
+                  P2_has_type: {
+                    ...p2HasTypeSchema,
+                    items: [{ type: "string", const: "oa:classifying" }]
+                  }
                 }
               },
               else: {
@@ -2020,7 +1942,7 @@ var webAnnotationSchema = {
                     body: {
                       type: "object",
                       properties: {
-                        entityType: linkEntityTypeSchema
+                        type: typeLinkSchema
                       }
                     }
                   }
@@ -2028,7 +1950,11 @@ var webAnnotationSchema = {
                 then: {
                   type: "object",
                   properties: {
-                    motivation: { type: "string", const: "oa:linking" }
+                    motivation: { type: "string", const: "oa:linking" },
+                    P2_has_type: {
+                      ...p2HasTypeSchema,
+                      items: [{ type: "string", const: "oa:linking" }]
+                    }
                   }
                 },
                 else: {
@@ -2038,7 +1964,7 @@ var webAnnotationSchema = {
                       body: {
                         type: "object",
                         properties: {
-                          entityType: citationEntityTypeSchema
+                          type: typeCitationSchema
                         }
                       }
                     }
@@ -2046,7 +1972,11 @@ var webAnnotationSchema = {
                   then: {
                     type: "object",
                     properties: {
-                      motivation: { type: "string", const: "citing" }
+                      motivation: { type: "string", const: "citing" },
+                      P2_has_type: {
+                        ...p2HasTypeSchema,
+                        items: [{ type: "string", const: "citing" }]
+                      }
                     }
                   }
                 }
@@ -2055,6 +1985,41 @@ var webAnnotationSchema = {
           }
         }
       }
+    },
+    {
+      if: {
+        type: "object",
+        properties: {
+          body: {
+            type: "object",
+            properties: {
+              type: { type: "string", const: "Choice" }
+            }
+          }
+        }
+      },
+      then: {
+        type: "object",
+        properties: {
+          body: { $ref: "defs.jsonld#/definitions/bodyChoice" }
+        }
+      },
+      else: {
+        type: "object",
+        properties: {
+          body: {
+            oneOf: [
+              { $ref: "defs.jsonld#/definitions/body" },
+              {
+                type: "array",
+                items: { $ref: "defs.jsonld#/definitions/body" },
+                minItems: 1
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              }
+            ]
+          }
+        }
+      }
     }
   ]
 };
@@ -2083,7 +2048,8 @@ var ValidateResult = import_zod28.z.object({
 var ajv = new import_ajv.default({
   code: { source: true },
   allErrors: true,
-  allowUnionTypes: true
+  allowUnionTypes: true,
+  strictTuples: false
 }).addSchema([webAnnotationSchema, definitionSchema]);
 (0, import_ajv_formats.default)(ajv);
 var validator = ajv.compile(webAnnotationSchema);
@@ -2111,42 +2077,32 @@ var v1_exports = {};
 __export(v1_exports, {
   Body: () => Body,
   BodyChoice: () => BodyChoice,
-  BodyEntityType: () => BodyEntityType,
   Certainty: () => Certainty,
+  CertaintySchema: () => CertaintySchema,
   Citation: () => Citation,
-  CitationEntityType: () => CitationEntityType,
   ConceptualObject: () => ConceptualObject,
-  ConceptualObjectEntityType: () => ConceptualObjectEntityType,
   Correction: () => Correction,
-  CorrectionEntityType: () => CorrectionEntityType,
+  CssSelector: () => CssSelector,
+  CssSelectorExtended: () => CssSelectorExtended,
   DATE_RANGE_PATTERN: () => DATE_RANGE_PATTERN,
   Date: () => Date,
-  DateEntityType: () => DateEntityType,
   Description: () => Description,
   Event: () => Event,
-  EventEntityType: () => EventEntityType,
   Group: () => Group,
   Keyword: () => Keyword,
-  KeywordEntityType: () => KeywordEntityType,
   KeywordFolksnomy: () => KeywordFolksnomy,
-  KeywordFolksnomyEntityType: () => KeywordFolksnomyEntityType,
   Label: () => Label,
   Link: () => Link,
-  LinkEntityType: () => LinkEntityType,
   ModeExistence: () => ModeExistence,
   Motivation: () => Motivation,
+  MotivationSchema: () => MotivationSchema,
   Note: () => Note,
-  NoteEntityType: () => NoteEntityType,
   Organization: () => Organization,
-  OrganizationEntityType: () => OrganizationEntityType,
   Person: () => Person,
-  PersonEntityType: () => PersonEntityType,
   PhysicalThing: () => PhysicalThing,
-  PhysicalThingEntityType: () => PhysicalThingEntityType,
   Place: () => Place,
-  PlaceEntityType: () => PlaceEntityType,
   Precision: () => Precision,
-  Quality: () => Quality,
+  PrecisionSchema: () => PrecisionSchema,
   RangeSelector: () => RangeSelector,
   Selector: () => Selector,
   Software: () => Software,
@@ -2156,59 +2112,60 @@ __export(v1_exports, {
   TextPositionSelectorExtended: () => TextPositionSelectorExtended,
   TextQuoteSelector: () => TextQuoteSelector,
   TextQuoteSelectorExtended: () => TextQuoteSelectorExtended,
+  TypeBody: () => TypeBody,
+  TypeCitation: () => TypeCitation,
+  TypeConceptualObject: () => TypeConceptualObject,
+  TypeCorrection: () => TypeCorrection,
+  TypeDate: () => TypeDate,
+  TypeEvent: () => TypeEvent,
+  TypeKeyword: () => TypeKeyword,
+  TypeKeywordFolksnomy: () => TypeKeywordFolksnomy,
+  TypeLink: () => TypeLink,
+  TypeNote: () => TypeNote,
+  TypeOrganization: () => TypeOrganization,
+  TypePerson: () => TypePerson,
+  TypePhysicalThing: () => TypePhysicalThing,
+  TypePlace: () => TypePlace,
+  TypeWork: () => TypeWork,
   User: () => User,
   VERSION: () => VERSION,
   ValidateResult: () => ValidateResult,
   ValidationError: () => ValidationError,
   WebAnnotation: () => WebAnnotation,
   Work: () => Work,
-  WorkEntityType: () => WorkEntityType,
   XpathSelector: () => XpathSelector,
   XpathSelectorExtended: () => XpathSelectorExtended,
   ajv: () => ajv,
   bodyChoiceSchema: () => bodyChoiceSchema,
-  bodyEntityTypeSchema: () => bodyEntityTypeSchema,
   bodyIdDescription: () => bodyIdDescription,
   bodySchema: () => bodySchema,
-  certaintySchema: () => certaintySchema,
-  citationEntityTypeSchema: () => citationEntityTypeSchema,
   citationSchema: () => citationSchema,
-  conceptualObjectEntityTypeSchema: () => conceptualObjectEntityTypeSchema,
   conceptualObjectSchema: () => conceptualObjectSchema,
   contextUri: () => contextUri,
-  correctionEntityTypeSchema: () => correctionEntityTypeSchema,
   correctionSchema: () => correctionSchema,
-  dateEntityTypeSchema: () => dateEntityTypeSchema,
+  cssSelectorExtendedSchema: () => cssSelectorExtendedSchema,
+  cssSelectorSchema: () => cssSelectorSchema,
   dateSchema: () => dateSchema,
   definitionSchema: () => definitionSchema,
   defsId: () => defsId,
   descriptionSchema: () => descriptionSchema,
-  eventEntityTypeSchema: () => eventEntityTypeSchema,
   eventSchema: () => eventSchema,
   formatSchema: () => formatSchema,
   groupSchema: () => groupSchema,
   isIdentifiedBy: () => isIdentifiedBy,
   isIndentifyBySchema: () => isIndentifyBySchema,
-  keywordEntityTypeSchema: () => keywordEntityTypeSchema,
-  keywordFolksnomyEntityTypeSchema: () => keywordFolksnomyEntityTypeSchema,
   keywordFolksnomySchema: () => keywordFolksnomySchema,
   keywordSchema: () => keywordSchema,
   labelSchema: () => labelSchema,
   languageSchema: () => languageSchema,
-  linkEntityTypeSchema: () => linkEntityTypeSchema,
   linkSchema: () => linkSchema,
   modeExistenceSchema: () => modeExistenceSchema,
-  noteEntityTypeSchema: () => noteEntityTypeSchema,
   noteSchema: () => noteSchema,
-  organizationEntityTypeSchema: () => organizationEntityTypeSchema,
   organizationSchema: () => organizationSchema,
-  personEntityTypeSchema: () => personEntityTypeSchema,
+  p2HasTypeSchema: () => p2HasTypeSchema,
   personSchema: () => personSchema,
-  physicalThingEntityTypeSchema: () => physicalThingEntityTypeSchema,
   physicalThingSchema: () => physicalThingSchema,
-  placeEntityTypeSchema: () => placeEntityTypeSchema,
   placeSchema: () => placeSchema,
-  precisionSchema: () => precisionSchema,
   rangeSelectorSchema: () => rangeSelectorSchema,
   schemaContext: () => schemaContext,
   schemaId: () => schemaId,
@@ -2222,11 +2179,25 @@ __export(v1_exports, {
   textPositionSelectorSchema: () => textPositionSelectorSchema,
   textQuoteSelectorExtendedSchema: () => textQuoteSelectorExtendedSchema,
   textQuoteSelectorSchema: () => textQuoteSelectorSchema,
+  typeBodySchema: () => typeBodySchema,
+  typeCitationSchema: () => typeCitationSchema,
+  typeConceptualObjectSchema: () => typeConceptualObjectSchema,
+  typeCorrectionSchema: () => typeCorrectionSchema,
+  typeDateSchema: () => typeDateSchema,
+  typeEventSchema: () => typeEventSchema,
+  typeKeywordFolksnomy: () => typeKeywordFolksnomy,
+  typeKeywordSchema: () => typeKeywordSchema,
+  typeLinkSchema: () => typeLinkSchema,
+  typeNoteSchema: () => typeNoteSchema,
+  typeOrganizationSchema: () => typeOrganizationSchema,
+  typePersonSchema: () => typePersonSchema,
+  typePhysicalThingSchema: () => typePhysicalThingSchema,
+  typePlaceSchema: () => typePlaceSchema,
+  typeWorkSchema: () => typeWorkSchema,
   userSchema: () => userSchema,
   validate: () => validate,
   validator: () => validator,
   webAnnotationSchema: () => webAnnotationSchema,
-  workEntityTypeSchema: () => workEntityTypeSchema,
   workSchema: () => workSchema,
   xpathSelectorExtendedSchema: () => xpathSelectorExtendedSchema,
   xpathSelectorSchema: () => xpathSelectorSchema
@@ -2235,42 +2206,32 @@ __export(v1_exports, {
 0 && (module.exports = {
   Body,
   BodyChoice,
-  BodyEntityType,
   Certainty,
+  CertaintySchema,
   Citation,
-  CitationEntityType,
   ConceptualObject,
-  ConceptualObjectEntityType,
   Correction,
-  CorrectionEntityType,
+  CssSelector,
+  CssSelectorExtended,
   DATE_RANGE_PATTERN,
   Date,
-  DateEntityType,
   Description,
   Event,
-  EventEntityType,
   Group,
   Keyword,
-  KeywordEntityType,
   KeywordFolksnomy,
-  KeywordFolksnomyEntityType,
   Label,
   Link,
-  LinkEntityType,
   ModeExistence,
   Motivation,
+  MotivationSchema,
   Note,
-  NoteEntityType,
   Organization,
-  OrganizationEntityType,
   Person,
-  PersonEntityType,
   PhysicalThing,
-  PhysicalThingEntityType,
   Place,
-  PlaceEntityType,
   Precision,
-  Quality,
+  PrecisionSchema,
   RangeSelector,
   Selector,
   Software,
@@ -2280,59 +2241,60 @@ __export(v1_exports, {
   TextPositionSelectorExtended,
   TextQuoteSelector,
   TextQuoteSelectorExtended,
+  TypeBody,
+  TypeCitation,
+  TypeConceptualObject,
+  TypeCorrection,
+  TypeDate,
+  TypeEvent,
+  TypeKeyword,
+  TypeKeywordFolksnomy,
+  TypeLink,
+  TypeNote,
+  TypeOrganization,
+  TypePerson,
+  TypePhysicalThing,
+  TypePlace,
+  TypeWork,
   User,
   VERSION,
   ValidateResult,
   ValidationError,
   WebAnnotation,
   Work,
-  WorkEntityType,
   XpathSelector,
   XpathSelectorExtended,
   ajv,
   bodyChoiceSchema,
-  bodyEntityTypeSchema,
   bodyIdDescription,
   bodySchema,
-  certaintySchema,
-  citationEntityTypeSchema,
   citationSchema,
-  conceptualObjectEntityTypeSchema,
   conceptualObjectSchema,
   contextUri,
-  correctionEntityTypeSchema,
   correctionSchema,
-  dateEntityTypeSchema,
+  cssSelectorExtendedSchema,
+  cssSelectorSchema,
   dateSchema,
   definitionSchema,
   defsId,
   descriptionSchema,
-  eventEntityTypeSchema,
   eventSchema,
   formatSchema,
   groupSchema,
   isIdentifiedBy,
   isIndentifyBySchema,
-  keywordEntityTypeSchema,
-  keywordFolksnomyEntityTypeSchema,
   keywordFolksnomySchema,
   keywordSchema,
   labelSchema,
   languageSchema,
-  linkEntityTypeSchema,
   linkSchema,
   modeExistenceSchema,
-  noteEntityTypeSchema,
   noteSchema,
-  organizationEntityTypeSchema,
   organizationSchema,
-  personEntityTypeSchema,
+  p2HasTypeSchema,
   personSchema,
-  physicalThingEntityTypeSchema,
   physicalThingSchema,
-  placeEntityTypeSchema,
   placeSchema,
-  precisionSchema,
   rangeSelectorSchema,
   schemaContext,
   schemaId,
@@ -2346,12 +2308,26 @@ __export(v1_exports, {
   textPositionSelectorSchema,
   textQuoteSelectorExtendedSchema,
   textQuoteSelectorSchema,
+  typeBodySchema,
+  typeCitationSchema,
+  typeConceptualObjectSchema,
+  typeCorrectionSchema,
+  typeDateSchema,
+  typeEventSchema,
+  typeKeywordFolksnomy,
+  typeKeywordSchema,
+  typeLinkSchema,
+  typeNoteSchema,
+  typeOrganizationSchema,
+  typePersonSchema,
+  typePhysicalThingSchema,
+  typePlaceSchema,
+  typeWorkSchema,
   userSchema,
   v1,
   validate,
   validator,
   webAnnotationSchema,
-  workEntityTypeSchema,
   workSchema,
   xpathSelectorExtendedSchema,
   xpathSelectorSchema