@lincs.project/webannotation-schema 1.1.1 → 1.2.1

package/dist/index.js

@@ -2768,33 +2768,119 @@ var require_lib = __commonJS({
 var src_exports = {};
 __export(src_exports, {
   Body: () => Body,
+  BodyEntityType: () => BodyEntityType,
+  Certainty: () => Certainty,
+  Citation: () => Citation,
+  CitationEntityType: () => CitationEntityType,
+  ConceptualObject: () => ConceptualObject,
+  ConceptualObjectEntityType: () => ConceptualObjectEntityType,
+  Correction: () => Correction,
+  CorrectionEntityType: () => CorrectionEntityType,
+  DATE_RANGE_PATTERN: () => DATE_RANGE_PATTERN,
+  Date: () => Date2,
+  DateEntityType: () => DateEntityType,
+  Description: () => Description,
+  Event: () => Event,
+  EventEntityType: () => EventEntityType,
+  Keyword: () => Keyword,
+  KeywordEntityType: () => KeywordEntityType,
+  KeywordFolksnomy: () => KeywordFolksnomy,
+  KeywordFolksnomyEntityType: () => KeywordFolksnomyEntityType,
+  Label: () => Label,
+  Link: () => Link,
+  LinkEntityType: () => LinkEntityType,
   Motivation: () => Motivation,
+  Note: () => Note,
+  NoteEntityType: () => NoteEntityType,
+  Organization: () => Organization,
+  OrganizationEntityType: () => OrganizationEntityType,
   Person: () => Person,
   PersonEntityType: () => PersonEntityType,
+  PhysicalThing: () => PhysicalThing,
+  PhysicalThingEntityType: () => PhysicalThingEntityType,
+  Place: () => Place,
+  PlaceEntityType: () => PlaceEntityType,
+  Precision: () => Precision,
+  Quality: () => Quality,
+  RangeSelector: () => RangeSelector,
+  Selector: () => Selector,
   Software: () => Software,
+  Source: () => Source,
   Status: () => Status,
   Target: () => Target,
+  TextPositionSelector: () => TextPositionSelector,
+  TextPositionSelectorExtended: () => TextPositionSelectorExtended,
+  TextQuoteSelector: () => TextQuoteSelector,
+  TextQuoteSelectorExtended: () => TextQuoteSelectorExtended,
   User: () => User,
   VERSION: () => VERSION,
   ValidateResult: () => ValidateResult,
   ValidationError: () => ValidationError,
   WebAnnotation: () => WebAnnotation,
+  Work: () => Work,
+  WorkEntityType: () => WorkEntityType,
+  XpathSelector: () => XpathSelector,
+  XpathSelectorExtended: () => XpathSelectorExtended,
   ajv: () => ajv,
+  bodyIdDescription: () => bodyIdDescription,
   bodySchema: () => bodySchema,
+  certaintySchema: () => certaintySchema,
+  citationEntityTypeSchema: () => citationEntityTypeSchema,
+  citationSchema: () => citationSchema,
+  conceptualObjectEntityTypeSchema: () => conceptualObjectEntityTypeSchema,
+  conceptualObjectSchema: () => conceptualObjectSchema,
   contextUri: () => contextUri,
+  correctionEntityTypeSchema: () => correctionEntityTypeSchema,
+  correctionSchema: () => correctionSchema,
   creatorSchema: () => creatorSchema,
+  dateEntityTypeSchema: () => dateEntityTypeSchema,
+  dateSchema: () => dateSchema,
   definitionSchema: () => definitionSchema,
   defsId: () => defsId,
+  descriptionSchema: () => descriptionSchema,
+  eventEntityTypeSchema: () => eventEntityTypeSchema,
+  eventSchema: () => eventSchema,
+  formatSchema: () => formatSchema,
+  keywordEntityTypeSchema: () => keywordEntityTypeSchema,
+  keywordFolksnomyEntityTypeSchema: () => keywordFolksnomyEntityTypeSchema,
+  keywordFolksnomySchema: () => keywordFolksnomySchema,
+  keywordSchema: () => keywordSchema,
+  labelSchema: () => labelSchema,
+  languageSchema: () => languageSchema,
+  linkEntityTypeSchema: () => linkEntityTypeSchema,
+  linkSchema: () => linkSchema,
+  noteEntityTypeSchema: () => noteEntityTypeSchema,
+  noteSchema: () => noteSchema,
+  organizationEntityTypeSchema: () => organizationEntityTypeSchema,
+  organizationSchema: () => organizationSchema,
   personEntityTypeSchema: () => personEntityTypeSchema,
   personSchema: () => personSchema,
+  physicalThingEntityTypeSchema: () => physicalThingEntityTypeSchema,
+  physicalThingSchema: () => physicalThingSchema,
+  placeEntityTypeSchema: () => placeEntityTypeSchema,
+  placeSchema: () => placeSchema,
+  precisionSchema: () => precisionSchema,
+  rangeSelectorSchema: () => rangeSelectorSchema,
   schemaContext: () => schemaContext,
   schemaId: () => schemaId,
+  selectorIdDescription: () => selectorIdDescription,
+  selectorRefinedByDescription: () => selectorRefinedByDescription,
+  selectorSchema: () => selectorSchema,
   softwareSchema: () => softwareSchema,
+  sourceSchema: () => sourceSchema,
   targetSchema: () => targetSchema,
+  textPositionSelectorExtendedSchema: () => textPositionSelectorExtendedSchema,
+  textPositionSelectorSchema: () => textPositionSelectorSchema,
+  textQuoteSelectorExtendedSchema: () => textQuoteSelectorExtendedSchema,
+  textQuoteSelectorSchema: () => textQuoteSelectorSchema,
   v1: () => v1_exports,
   validate: () => validate,
   validator: () => validator,
-  webAnnotationSchema: () => webAnnotationSchema
+  webAnnotationSchema: () => webAnnotationSchema,
+  workEntityTypeSchema: () => workEntityTypeSchema,
+  workSchema: () => workSchema,
+  xpathSelectorExtendedSchema: () => xpathSelectorExtendedSchema,
+  xpathSelectorSchema: () => xpathSelectorSchema
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -2833,7 +2919,7 @@ var schemaContext = {
     },
     entityType: {
       "@type": "@id",
-      "@id": "crm:P2_has_type"
+      "@id": "rdf:type"
     },
     additionalType: {
       "@type": "@id",
@@ -2849,8 +2935,9 @@ var schemaContext = {
 
 // src/v1/schema/definitions/agent.ts
 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.union([import_zod.z.string().url({ message: "Must be an URI" }), import_zod.z.literal("anonymous")]).describe("The IRI that identifies the agent (Creator or Contributor)."),
+  id: import_zod.z.string().url().describe(userIdDescription),
   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");
@@ -2858,20 +2945,15 @@ var creatorSchema = {
   type: "object",
   description: "Software Agent",
   properties: {
-    id: {
-      anyOf: [
-        { type: "string", format: "uri" },
-        { type: "string", const: "anonymous" }
-      ],
-      description: "The URI that identifies the agent (Creator or Contributor)."
-    },
+    id: { type: "string", format: "uri", description: userIdDescription },
     type: { type: "string", const: "crm:E21_Person" },
     name: { type: "string", minLength: 1, description: "The name of the agent." }
   },
   required: ["id", "type", "name"]
 };
+var softwareIdDescription = "The IRI that identifies the agent (software).";
 var Software = import_zod.z.object({
-  id: import_zod.z.string().url({ message: "Must be an URI" }).describe("The IRI that identifies the agent (software)."),
+  id: import_zod.z.string().url().describe(softwareIdDescription),
   type: import_zod.z.tuple([import_zod.z.literal("Software"), import_zod.z.literal("crm:P16_used_specific_object")]).describe("The type of the Agent."),
   label: import_zod.z.string().min(1).describe("The name of the software."),
   softwareVersion: import_zod.z.string().optional().describe("The software version.")
@@ -2880,11 +2962,7 @@ var softwareSchema = {
   type: "object",
   description: "Software Agent",
   properties: {
-    id: {
-      type: "string",
-      format: "uri",
-      description: "The IRI that identifies the agent (software)."
-    },
+    id: { type: "string", format: "uri", description: softwareIdDescription },
     type: {
       type: "array",
       minItems: 2,
@@ -2915,32 +2993,32 @@ var Quality = [
   "edit:qualityHigh",
   "edit:qualityUnknown"
 ];
-var Certainty = import_zod2.z.enum(Quality).describe(
-  "Indicates the degree of certainty associated with some aspect of an assertion, description, identification, or entity linked to the annotation body."
-);
+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_zod2.z.enum(Quality).describe(certaintyDescription);
 var certaintySchema = {
   type: "string",
   enum: Quality,
-  description: "Indicates the degree of certainty associated with some aspect of an assertion, description, identification, or entity linked to the annotation body."
+  description: certaintyDescription
 };
-var Precision = import_zod2.z.enum(Quality).describe(
-  "Indicates the degree of precision associated with the location of the entity linked to the annotation body."
-);
+var precisionDescription = "Indicates the degree of precision associated with the location of the entity linked to the annotation body.";
+var Precision = import_zod2.z.enum(Quality).describe(precisionDescription);
 var precisionSchema = {
   type: "string",
   enum: Quality,
-  description: "Indicates the degree of precision associated with the location of the entity linked to the annotation body."
+  description: precisionDescription
 };
-var Label = import_zod2.z.string().min(1, { message: "The label cannot be empty" }).describe("The title or name of a linked resource or named entity.");
+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 = {
   type: "string",
   minLength: 1,
-  description: "The title or name of a linked resource or named entity."
+  description: labelDescription
 };
-var Description = import_zod2.z.string().describe("Short description of the linked resources or named entity.");
+var descriptionDescription = "Short description of the linked resources or named entity.";
+var Description = import_zod2.z.string().describe(descriptionDescription);
 var descriptionSchema = {
   type: "string",
-  description: "Short description of the linked resources or named entity."
+  description: descriptionDescription
 };
 
 // src/v1/schema/definitions/body/citation.ts
@@ -2949,11 +3027,8 @@ var CitationEntityType = import_zod3.z.tuple([
   import_zod3.z.literal("crm:E73_Information_Object")
 ]);
 var Citation = import_zod3.z.object({
-  id: import_zod3.z.union([
-    import_zod3.z.string().url({ message: "Must be an URI" }).describe("The IRI that identifies the Body resource."),
-    import_zod3.z.string().uuid({ message: "Must be an UUID" }).describe("UUID that identifies the annotation's body.")
-  ]),
-  entityType: import_zod3.z.tuple([import_zod3.z.literal("cito:Citation"), import_zod3.z.literal("crm:E73_Information_Object")]),
+  id: import_zod3.z.string().url().describe(bodyIdDescription),
+  entityType: CitationEntityType,
   certainty: Certainty.optional(),
   label: Label.optional(),
   description: Description.optional()
@@ -2967,6 +3042,18 @@ var citationEntityTypeSchema = {
     { type: "string", const: "crm:E73_Information_Object" }
   ]
 };
+var citationSchema = {
+  type: "object",
+  description: "A citation entity",
+  properties: {
+    id: { type: "string", format: "uri", description: bodyIdDescription },
+    entityType: citationEntityTypeSchema,
+    certainty: { $ref: "defs.jsonld#/definitions/certainty" },
+    label: { $ref: "defs.jsonld#/definitions/label" },
+    description: { $ref: "defs.jsonld#/definitions/description" }
+  },
+  required: ["id", "entityType"]
+};
 
 // src/v1/schema/definitions/body/conceptualObject.ts
 var import_zod4 = require("zod");
@@ -2978,10 +3065,7 @@ var ConceptualObjectEntityType = import_zod4.z.union([
   ])
 ]);
 var ConceptualObject = import_zod4.z.object({
-  id: import_zod4.z.union([
-    import_zod4.z.string().url({ message: "Must be an URI" }).describe("The IRI that identifies the Body resource."),
-    import_zod4.z.string().uuid({ message: "Must be an UUID" }).describe("UUID that identifies the annotation's body.")
-  ]),
+  id: import_zod4.z.string().url().describe(bodyIdDescription),
   entityType: ConceptualObjectEntityType,
   certainty: Certainty.optional(),
   label: Label.optional(),
@@ -3001,6 +3085,18 @@ var conceptualObjectEntityTypeSchema = {
     }
   ]
 };
+var conceptualObjectSchema = {
+  type: "object",
+  description: "A conceptual object entity",
+  properties: {
+    id: { type: "string", format: "uri", description: bodyIdDescription },
+    entityType: conceptualObjectEntityTypeSchema,
+    certainty: { $ref: "defs.jsonld#/definitions/certainty" },
+    label: { $ref: "defs.jsonld#/definitions/label" },
+    description: { $ref: "defs.jsonld#/definitions/description" }
+  },
+  required: ["id", "entityType"]
+};
 
 // src/v1/schema/definitions/body/correction.ts
 var import_zod5 = require("zod");
@@ -3009,7 +3105,7 @@ var CorrectionEntityType = import_zod5.z.tuple([
   import_zod5.z.literal("crm:E33_Linguistic_Object")
 ]);
 var Correction = import_zod5.z.object({
-  id: import_zod5.z.string().uuid({ message: "Must be an UUID" }).describe("UUID that identifies the annotation's body."),
+  id: import_zod5.z.string().url().describe(bodyIdDescription),
   type: import_zod5.z.literal("TextualBody"),
   entityType: CorrectionEntityType,
   value: import_zod5.z.string().describe("The correction.")
@@ -3023,15 +3119,31 @@ var correctionEntityTypeSchema = {
     { type: "string", const: "crm:E33_Linguistic_Object" }
   ]
 };
+var correctionSchema = {
+  type: "object",
+  description: "A correction entity",
+  properties: {
+    id: { type: "string", format: "uri", description: bodyIdDescription },
+    type: { type: "string", const: "TextualBody" },
+    entityType: correctionEntityTypeSchema,
+    value: { type: "string" }
+  },
+  required: ["id", "type", "entityType", "value"]
+  // errorMessage: {
+  //   properties: {
+  //     type: 'must be exacty "TextualBody"',
+  //   },
+  // },
+};
 
 // src/v1/schema/definitions/body/date.ts
 var import_zod6 = require("zod");
 var DateEntityType = import_zod6.z.tuple([import_zod6.z.literal("xsd:date"), import_zod6.z.literal("crm:E52_Time-Span")]);
 var Date2 = import_zod6.z.object({
-  id: import_zod6.z.string().uuid({ message: "Must be an UUID" }).describe("UUID that identifies the annotation's body."),
+  id: import_zod6.z.string().url().describe(bodyIdDescription),
   type: import_zod6.z.literal("TextualBody"),
   entityType: DateEntityType,
-  value: import_zod6.z.string().describe("The date time."),
+  value: import_zod6.z.string().regex(new RegExp(DATE_RANGE_PATTERN)).describe("The date time."),
   certainty: Certainty.optional(),
   precision: Precision.optional()
 }).describe("Date");
@@ -3044,18 +3156,76 @@ var dateEntityTypeSchema = {
     { type: "string", const: "crm:E52_Time-Span" }
   ]
 };
+var dateSchema = {
+  type: "object",
+  description: "A date entity",
+  properties: {
+    id: { type: "string", format: "uri", description: bodyIdDescription },
+    type: { type: "string", const: "TextualBody" },
+    entityType: dateEntityTypeSchema,
+    value: { type: "string", pattern: DATE_RANGE_PATTERN },
+    certainty: { type: "string", $ref: "defs.jsonld#/definitions/certainty" },
+    precision: { type: "string", $ref: "defs.jsonld#/definitions/precision" }
+  },
+  required: ["id", "type", "entityType", "value"]
+  // errorMessage: {
+  //   properties: {
+  //     type: 'must be exacty "TextualBody"',
+  //   },
+  // },
+};
 
-// src/v1/schema/definitions/body/keyword.ts
+// src/v1/schema/definitions/body/event.ts
 var import_zod7 = require("zod");
-var KeywordEntityType = import_zod7.z.tuple([
-  import_zod7.z.literal("crm:E55_Type"),
-  import_zod7.z.literal("crmdig:D1_Digital_Object")
+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 Event = import_zod7.z.object({
+  id: import_zod7.z.string().url().describe(bodyIdDescription),
+  entityType: EventEntityType,
+  certainty: Certainty.optional(),
+  label: Label.optional(),
+  description: Description.optional()
+}).describe("Organization");
+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", description: "Real Event" },
+        { type: "string", const: "crm:E89_Propositional_Object", description: "Fictional Event" }
+      ]
+    }
+  ]
+};
+var eventSchema = {
+  type: "object",
+  description: "A organization entity",
+  properties: {
+    id: { type: "string", format: "uri", description: bodyIdDescription },
+    entityType: eventEntityTypeSchema,
+    certainty: { $ref: "defs.jsonld#/definitions/certainty" },
+    label: { $ref: "defs.jsonld#/definitions/label" },
+    description: { $ref: "defs.jsonld#/definitions/description" }
+  },
+  required: ["id", "entityType"]
+};
+
+// src/v1/schema/definitions/body/keyword.ts
+var import_zod8 = require("zod");
+var KeywordEntityType = import_zod8.z.tuple([
+  import_zod8.z.literal("crm:E55_Type"),
+  import_zod8.z.literal("crmdig:D1_Digital_Object")
 ]);
-var Keyword = import_zod7.z.object({
-  id: import_zod7.z.union([
-    import_zod7.z.string().url({ message: "Must be an URI" }).describe("The IRI that identifies the Body resource."),
-    import_zod7.z.string().uuid({ message: "Must be an UUID" }).describe("UUID that identifies the annotation's body.")
-  ]),
+var Keyword = import_zod8.z.object({
+  id: import_zod8.z.string().url().describe(bodyIdDescription),
   entityType: KeywordEntityType,
   certainty: Certainty.optional(),
   label: Label.optional(),
@@ -3070,15 +3240,27 @@ var keywordEntityTypeSchema = {
     { type: "string", const: "crmdig:D1_Digital_Object" }
   ]
 };
-var KeywordFolksnomyEntityType = import_zod7.z.tuple([
-  import_zod7.z.literal("crm:E55_Type"),
-  import_zod7.z.literal("crm:E33_Linguistic_Object")
+var keywordSchema = {
+  type: "object",
+  description: "A keyword entity",
+  properties: {
+    id: { type: "string", format: "uri", description: bodyIdDescription },
+    entityType: keywordEntityTypeSchema,
+    certainty: { $ref: "defs.jsonld#/definitions/certainty" },
+    label: { $ref: "defs.jsonld#/definitions/label" },
+    description: { $ref: "defs.jsonld#/definitions/description" }
+  },
+  required: ["id", "entityType"]
+};
+var KeywordFolksnomyEntityType = import_zod8.z.tuple([
+  import_zod8.z.literal("crm:E55_Type"),
+  import_zod8.z.literal("crm:E33_Linguistic_Object")
 ]);
-var KeywordFolksnomy = import_zod7.z.object({
-  id: import_zod7.z.string().url().describe("The IRI that identifies the Body resource."),
-  type: import_zod7.z.literal("TextualBody"),
+var KeywordFolksnomy = import_zod8.z.object({
+  id: import_zod8.z.string().url().describe(bodyIdDescription),
+  type: import_zod8.z.literal("TextualBody"),
   entityType: KeywordFolksnomyEntityType,
-  value: import_zod7.z.string().describe("The keyword.")
+  value: import_zod8.z.string().describe("The keyword.")
 }).describe("Keyword");
 var keywordFolksnomyEntityTypeSchema = {
   type: "array",
@@ -3089,12 +3271,29 @@ var keywordFolksnomyEntityTypeSchema = {
     { type: "string", const: "crm:E33_Linguistic_Object" }
   ]
 };
+var keywordFolksnomySchema = {
+  type: "object",
+  description: "A keyword entity",
+  properties: {
+    id: { type: "string", format: "uri", description: bodyIdDescription },
+    type: { type: "string", const: "TextualBody" },
+    entityType: keywordFolksnomyEntityTypeSchema,
+    value: { type: "string" }
+  },
+  required: ["id", "type", "entityType", "value"]
+  // errorMessage: {
+  //   properties: {
+  //     type: 'must be exacty "TextualBody"',
+  //   },
+  // },
+};
 
 // src/v1/schema/definitions/body/link.ts
-var import_zod8 = require("zod");
-var LinkEntityType = import_zod8.z.literal("crmdig:D1_Digital_Object");
-var Link = import_zod8.z.object({
-  id: import_zod8.z.string().url().describe("The link URL."),
+var import_zod9 = require("zod");
+var idDescription = "The link URL.";
+var LinkEntityType = import_zod9.z.literal("crmdig:D1_Digital_Object");
+var Link = import_zod9.z.object({
+  id: import_zod9.z.string().url().describe(idDescription),
   entityType: LinkEntityType,
   certainty: Certainty.optional()
 }).describe("A link to a webpage");
@@ -3102,36 +3301,62 @@ var linkEntityTypeSchema = {
   type: "string",
   const: "crmdig:D1_Digital_Object"
 };
+var linkSchema = {
+  type: "object",
+  description: "A link entity",
+  properties: {
+    id: { type: "string", format: "uri", description: idDescription },
+    entityType: linkEntityTypeSchema,
+    certainty: { $ref: "defs.jsonld#/definitions/certainty" }
+  },
+  required: ["id", "entityType"]
+};
 
 // src/v1/schema/definitions/body/note.ts
-var import_zod9 = require("zod");
-var NoteEntityType = import_zod9.z.literal("crm:E33_Linguistic_Object");
-var Note = import_zod9.z.object({
-  id: import_zod9.z.string().uuid({ message: "Must be an UUID" }).describe("UUID that identifies the annotation's body."),
-  type: import_zod9.z.literal("TextualBody"),
+var import_zod10 = require("zod");
+var NoteEntityType = 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_zod9.z.union([import_zod9.z.string(), import_zod9.z.string().array()]).optional().describe("Extra types that refines the note"),
-  value: import_zod9.z.string().describe("The note.")
+  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.")
 }).describe("Note");
 var noteEntityTypeSchema = {
   type: "string",
   const: "crm:E33_Linguistic_Object"
 };
+var noteSchema = {
+  type: "object",
+  description: "A note entity",
+  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" }
+  },
+  required: ["id", "type", "entityType", "value"]
+  // errorMessage: {
+  //   properties: {
+  //     type: 'must be exacty "TextualBody"',
+  //   },
+  // },
+};
 
 // src/v1/schema/definitions/body/organization.ts
-var import_zod10 = require("zod");
-var OrganizationEntityType = import_zod10.z.tuple([
-  import_zod10.z.literal("foaf:Organization"),
-  import_zod10.z.union([
-    import_zod10.z.literal("crm:E74_Group").describe("Real Organization"),
-    import_zod10.z.literal("crm:E89_Propositional_Object").describe("Fictional Organization")
+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 Organization = import_zod10.z.object({
-  id: import_zod10.z.union([
-    import_zod10.z.string().url({ message: "Must be an URI" }).describe("The IRI that identifies the Body resource."),
-    import_zod10.z.string().uuid({ message: "Must be an UUID" }).describe("UUID that identifies the annotation's body.")
-  ]),
+var Organization = import_zod11.z.object({
+  id: import_zod11.z.string().url().describe(bodyIdDescription),
   entityType: OrganizationEntityType,
   certainty: Certainty.optional(),
   label: Label.optional(),
@@ -3155,21 +3380,30 @@ var organizationEntityTypeSchema = {
     }
   ]
 };
+var organizationSchema = {
+  type: "object",
+  description: "A organization entity",
+  properties: {
+    id: { type: "string", format: "uri", description: bodyIdDescription },
+    entityType: organizationEntityTypeSchema,
+    certainty: { $ref: "defs.jsonld#/definitions/certainty" },
+    label: { $ref: "defs.jsonld#/definitions/label" },
+    description: { $ref: "defs.jsonld#/definitions/description" }
+  },
+  required: ["id", "entityType"]
+};
 
 // src/v1/schema/definitions/body/person.ts
-var import_zod11 = require("zod");
-var PersonEntityType = import_zod11.z.tuple([
-  import_zod11.z.literal("Person").describe("foaf:person."),
-  import_zod11.z.union([
-    import_zod11.z.literal("crm:E21_Person").describe("Real Person"),
-    import_zod11.z.literal("crm:E89_Propositional_Object").describe("Fictional Person")
+var import_zod12 = require("zod");
+var PersonEntityType = import_zod12.z.tuple([
+  import_zod12.z.literal("Person").describe("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 Person = import_zod11.z.object({
-  id: import_zod11.z.union([
-    import_zod11.z.string().url({ message: "Must be an URI" }).describe("The IRI that identifies the Body resource."),
-    import_zod11.z.string().uuid({ message: "Must be an UUID" }).describe("UUID that identifies the annotation's body.")
-  ]),
+var Person = import_zod12.z.object({
+  id: import_zod12.z.string().url().describe(bodyIdDescription),
   entityType: PersonEntityType,
   certainty: Certainty.optional(),
   label: Label.optional(),
@@ -3193,35 +3427,26 @@ var personSchema = {
   type: "object",
   description: "A person entity",
   properties: {
-    id: {
-      oneOf: [
-        { type: "string", format: "uri", description: "The IRI that identifies the Body resource" },
-        { type: "string", format: "uuid" }
-      ]
-    },
+    id: { type: "string", format: "uri", description: bodyIdDescription },
     entityType: personEntityTypeSchema,
     certainty: { $ref: "defs.jsonld#/definitions/certainty" },
     label: { $ref: "defs.jsonld#/definitions/label" },
     description: { $ref: "defs.jsonld#/definitions/description" }
   },
   required: ["id", "entityType"]
-  // errorMessage: { properties: { id: 'Must be an URI' } },
 };
 
 // src/v1/schema/definitions/body/physicalThing.ts
-var import_zod12 = require("zod");
-var PhysicalThingEntityType = import_zod12.z.union([
-  import_zod12.z.literal("crm:E18_Physical_Thing"),
-  import_zod12.z.tuple([
-    import_zod12.z.literal("crm:E18_Physical_Thing"),
-    import_zod12.z.literal("wikidata:Q15831596").describe("Fictional Physical Thing")
+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")
   ])
 ]);
-var PhysicalThing = import_zod12.z.object({
-  id: import_zod12.z.union([
-    import_zod12.z.string().url({ message: "Must be an URI" }).describe("The IRI that identifies the Body resource."),
-    import_zod12.z.string().uuid({ message: "Must be an UUID" }).describe("UUID that identifies the annotation's body.")
-  ]),
+var PhysicalThing = import_zod13.z.object({
+  id: import_zod13.z.string().url().describe(bodyIdDescription),
   entityType: PhysicalThingEntityType,
   certainty: Certainty.optional(),
   label: Label.optional(),
@@ -3241,21 +3466,30 @@ var physicalThingEntityTypeSchema = {
     }
   ]
 };
+var physicalThingSchema = {
+  type: "object",
+  description: "A physical thing entity",
+  properties: {
+    id: { type: "string", format: "uri", description: bodyIdDescription },
+    entityType: physicalThingEntityTypeSchema,
+    certainty: { $ref: "defs.jsonld#/definitions/certainty" },
+    label: { $ref: "defs.jsonld#/definitions/label" },
+    description: { $ref: "defs.jsonld#/definitions/description" }
+  },
+  required: ["id", "entityType"]
+};
 
 // src/v1/schema/definitions/body/place.ts
-var import_zod13 = require("zod");
-var PlaceEntityType = import_zod13.z.union([
-  import_zod13.z.literal("cwrc:place"),
-  import_zod13.z.tuple([
-    import_zod13.z.literal("cwrc:place"),
-    import_zod13.z.literal("crm:E89_Propositional_Object").describe("Fictional Place")
+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")
   ])
 ]);
-var Place = import_zod13.z.object({
-  id: import_zod13.z.union([
-    import_zod13.z.string().url({ message: "Must be an URI" }).describe("The IRI that identifies the Body resource."),
-    import_zod13.z.string().uuid({ message: "Must be an UUID" }).describe("UUID that identifies the annotation's body.")
-  ]),
+var Place = import_zod14.z.object({
+  id: import_zod14.z.string().url().describe(bodyIdDescription),
   entityType: PlaceEntityType,
   certainty: Certainty.optional(),
   precision: Precision.optional(),
@@ -3276,21 +3510,31 @@ var placeEntityTypeSchema = {
     }
   ]
 };
+var placeSchema = {
+  type: "object",
+  description: "A place entity",
+  properties: {
+    id: { type: "string", format: "uri", description: bodyIdDescription },
+    entityType: placeEntityTypeSchema,
+    certainty: { $ref: "defs.jsonld#/definitions/certainty" },
+    precision: { $ref: "defs.jsonld#/definitions/precision" },
+    label: { $ref: "defs.jsonld#/definitions/label" },
+    description: { $ref: "defs.jsonld#/definitions/description" }
+  },
+  required: ["id", "entityType"]
+};
 
 // src/v1/schema/definitions/body/work.ts
-var import_zod14 = require("zod");
-var WorkEntityType = import_zod14.z.tuple([
-  import_zod14.z.literal("crm:E89_Propositional_Object"),
-  import_zod14.z.union([
-    import_zod14.z.literal("frbroo:F1").describe("Real Work"),
-    import_zod14.z.literal("wikidata:Q15306849").describe("Fictional Work")
+var import_zod15 = require("zod");
+var WorkEntityType = import_zod15.z.tuple([
+  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")
   ])
 ]);
-var Work = import_zod14.z.object({
-  id: import_zod14.z.union([
-    import_zod14.z.string().url({ message: "Must be an URI" }).describe("The IRI that identifies the Body resource."),
-    import_zod14.z.string().uuid({ message: "Must be an UUID" }).describe("UUID that identifies the annotation's body.")
-  ]),
+var Work = import_zod15.z.object({
+  id: import_zod15.z.string().url().describe(bodyIdDescription),
   entityType: WorkEntityType,
   certainty: Certainty.optional(),
   label: Label.optional(),
@@ -3310,49 +3554,42 @@ var workEntityTypeSchema = {
     }
   ]
 };
-
-// src/v1/schema/definitions/body/event.ts
-var import_zod15 = require("zod");
-var EventEntityType = import_zod15.z.literal("PLACEHOLDER_FOR_EVENT");
-var Event = import_zod15.z.object({
-  id: import_zod15.z.union([
-    import_zod15.z.string().url({ message: "Must be an URI" }).describe("The IRI that identifies the Body resource."),
-    import_zod15.z.string().uuid({ message: "Must be an UUID" }).describe("UUID that identifies the annotation's body.")
-  ]),
-  entityType: EventEntityType,
-  certainty: Certainty.optional(),
-  label: Label.optional(),
-  description: Description.optional()
-}).describe("Organization");
-var eventEntityTypeSchema = {
-  type: "string",
-  const: "PLACEHOLDER_FOR_EVENT"
+var workSchema = {
+  type: "object",
+  description: "A work entity",
+  properties: {
+    id: { type: "string", format: "uri", description: bodyIdDescription },
+    entityType: workEntityTypeSchema,
+    certainty: { $ref: "defs.jsonld#/definitions/certainty" },
+    label: { $ref: "defs.jsonld#/definitions/label" },
+    description: { $ref: "defs.jsonld#/definitions/description" }
+  },
+  required: ["id", "entityType"]
 };
 
 // src/v1/schema/definitions/body/index.ts
-var DATE_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 bodyIdDescription = "The IRI that identifies the Body resource.";
+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 BodyEntityType = import_zod16.z.union([
+  PersonEntityType,
+  PlaceEntityType,
+  OrganizationEntityType,
+  WorkEntityType,
+  PhysicalThingEntityType,
+  ConceptualObjectEntityType,
+  CitationEntityType,
+  DateEntityType,
+  NoteEntityType,
+  CorrectionEntityType,
+  KeywordEntityType,
+  KeywordFolksnomyEntityType,
+  LinkEntityType,
+  EventEntityType
+]);
 var Body = import_zod16.z.object({
-  id: import_zod16.z.union([
-    import_zod16.z.string().url({ message: "Must be an URI" }).describe("The IRI that identifies the Body resource."),
-    import_zod16.z.string().uuid({ message: "Must be an UUID" }).describe("UUID that identifies the annotation's body.")
-  ]),
+  id: import_zod16.z.string().url().describe(bodyIdDescription),
   type: import_zod16.z.literal("TextualBody").optional(),
-  entityType: import_zod16.z.union([
-    PersonEntityType,
-    PlaceEntityType,
-    OrganizationEntityType,
-    WorkEntityType,
-    PhysicalThingEntityType,
-    ConceptualObjectEntityType,
-    CitationEntityType,
-    DateEntityType,
-    NoteEntityType,
-    CorrectionEntityType,
-    KeywordEntityType,
-    KeywordFolksnomyEntityType,
-    LinkEntityType,
-    EventEntityType
-  ]),
+  entityType: BodyEntityType,
   additionalType: import_zod16.z.union([import_zod16.z.string(), import_zod16.z.string().array()]).optional().describe("Extra types that refines the body"),
   value: import_zod16.z.string().describe("The value of the body").optional(),
   certainty: Certainty.optional(),
@@ -3364,12 +3601,7 @@ var bodySchema = {
   type: "object",
   description: "Web Annotation Body",
   properties: {
-    id: {
-      oneOf: [
-        { type: "string", format: "uri", description: "The IRI that identifies the Body resource" },
-        { type: "string", format: "uuid" }
-      ]
-    },
+    id: { type: "string", format: "uri", description: bodyIdDescription },
     type: { type: "string", const: "TextualBody" },
     entityType: {
       oneOf: [
@@ -3401,42 +3633,7 @@ var bodySchema = {
   required: ["id", "entityType"],
   // * Conditional restrictions
   anyOf: [
-    //* IF type is TextualBody THEN id = uuid
-    //* && IF entityType is date THEN value = date range pattern ELSE value = string
-    // {
-    //   if: {
-    //     type: 'object',
-    //     properties: { type: { const: 'TextualBody' } },
-    //   },
-    //   then: {
-    //     type: 'object',
-    //     required: ['value'],
-    //     properties: { id: { type: 'string', format: 'uuid' } },
-    //     if: {
-    //       type: 'object',
-    //       properties: {
-    //         entityType: {
-    //           type: 'array',
-    //           minItems: 2,
-    //           maxItems: 2,
-    //           items: [
-    //             { type: 'string', const: 'xsd:date' },
-    //             { type: 'string', const: 'crm:E52_Time-Span' },
-    //           ],
-    //         },
-    //       },
-    //     },
-    //     then: {
-    //       type: 'object',
-    //       properties: { value: { type: 'string', pattern: DATE_PATTERN } },
-    //     },
-    //     else: {
-    //       type: 'object',
-    //       properties: { value: { type: 'string' } },
-    //     },
-    //   },
-    // },
-    //* IF entityType is date OR correction OR keyword THEN id = uuid AND type = TextualBody
+    //* IF entityType is date OR correction OR keyword THEN type = TextualBody
     //* && IF entityType is date THEN value = date range pattern ELSE value = string
     {
       if: {
@@ -3471,7 +3668,6 @@ var bodySchema = {
         type: "object",
         required: ["type", "value"],
         properties: {
-          id: { type: "string", format: "uuid" },
           type: { type: "string", const: "TextualBody" }
         },
         if: {
@@ -3490,7 +3686,7 @@ var bodySchema = {
           properties: {
             value: {
               type: "string",
-              pattern: DATE_PATTERN
+              pattern: DATE_RANGE_PATTERN
             }
           }
         },
@@ -3498,21 +3694,6 @@ var bodySchema = {
           type: "object",
           properties: { value: { type: "string" } }
         }
-      },
-      else: {
-        type: "object",
-        properties: {
-          id: {
-            oneOf: [
-              {
-                type: "string",
-                format: "uri",
-                description: "The IRI that identifies the Body resource"
-              },
-              { type: "string", format: "uuid" }
-            ]
-          }
-        }
       }
     }
     // ? TODO: Add more restrictions
@@ -3523,33 +3704,35 @@ var bodySchema = {
 };
 
 // src/v1/schema/definitions/target/index.ts
+var import_zod23 = require("zod");
+
+// src/v1/schema/definitions/target/selector/index.ts
 var import_zod21 = require("zod");
 
 // src/v1/schema/definitions/target/selector/range.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 
 // src/v1/schema/definitions/target/selector/xpath.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 
 // src/v1/schema/definitions/target/selector/textPosition.ts
 var import_zod17 = require("zod");
 var TextPositionSelector = import_zod17.z.object({
-  id: import_zod17.z.string().url().describe("The IRI that identifies the target resource."),
+  id: import_zod17.z.string().url().describe(selectorIdDescription),
   type: import_zod17.z.tuple([import_zod17.z.literal("TextPositionSelector"), import_zod17.z.literal("crm:E73_Information_Object")]),
   start: import_zod17.z.number().min(0).describe("The starting position of the segment. The first byte is character position 0."),
   end: import_zod17.z.number().describe(
     "The end position of the segment. The last character is not included within the segment."
   )
 }).describe("TextPosition Selector");
+var TextPositionSelectorExtended = TextPositionSelector.extend({
+  refinedBy: import_zod17.z.union([import_zod17.z.lazy(() => TextPositionSelector), import_zod17.z.lazy(() => TextQuoteSelector)]).optional().describe(selectorRefinedByDescription)
+});
 var textPositionSelectorSchema = {
   type: "object",
   description: "TextPosition Selector",
   properties: {
-    id: {
-      type: "string",
-      format: "uuid",
-      description: "UUID that identifies the selector."
-    },
+    id: { type: "string", format: "uri", description: selectorIdDescription },
     type: {
       type: "array",
       minItems: 2,
@@ -3572,27 +3755,105 @@ var textPositionSelectorSchema = {
     }
   },
   required: ["id", "type", "start", "end"]
-  // errorMessage: { properties: { id: 'Must be an URI' } },
+};
+var textPositionSelectorExtendedSchema = {
+  type: "object",
+  description: "TextPosition Selector",
+  properties: {
+    ...textPositionSelectorSchema.properties,
+    refinedBy: {
+      type: "object",
+      description: selectorRefinedByDescription,
+      oneOf: [
+        { $ref: "defs.jsonld#/definitions/textPositionSelector" },
+        { $ref: "defs.jsonld#/definitions/textQuoteSelector" }
+      ],
+      nullable: true,
+      required: []
+    }
+  },
+  required: ["id", "type", "start", "end"]
 };
 
-// src/v1/schema/definitions/target/selector/xpath.ts
-var XpathSelector = import_zod18.z.object({
-  id: import_zod18.z.string().uuid().describe("UUID that identifies the selector."),
-  type: import_zod18.z.tuple([import_zod18.z.literal("XPathSelector"), import_zod18.z.literal("crm:E73_Information_Object")]),
-  value: import_zod18.z.string().min(1).describe("The xpath to the selected segment."),
-  refinedBy: TextPositionSelector.optional().describe(
-    "The relationship between a broader selector and the more specific selector that should be applied to the results of the first."
+// src/v1/schema/definitions/target/selector/textQuote.ts
+var import_zod18 = require("zod");
+var TextQuoteSelector = import_zod18.z.object({
+  id: import_zod18.z.string().url().describe(selectorIdDescription),
+  type: import_zod18.z.tuple([import_zod18.z.literal("TextQuoteSelector"), import_zod18.z.literal("crm:E33_Linguistic_Object")]),
+  exact: import_zod18.z.string().describe("A copy of the text which is being selected, after normalization."),
+  prefix: import_zod18.z.string().describe(
+    "The snippet of text that occurs immediately before the text which is being selected."
+  ),
+  suffix: import_zod18.z.string().describe(
+    "The snippet of text that occurs immediately after the text which is being selected."
   )
+}).describe("Quote Selector");
+var TextQuoteSelectorExtended = TextQuoteSelector.extend({
+  refinedBy: import_zod18.z.union([import_zod18.z.lazy(() => TextPositionSelector), import_zod18.z.lazy(() => TextQuoteSelector)]).optional().describe(selectorRefinedByDescription)
+});
+var textQuoteSelectorSchema = {
+  type: "object",
+  description: "Quote Selector",
+  properties: {
+    id: { type: "string", format: "uri", description: selectorIdDescription },
+    type: {
+      type: "array",
+      minItems: 2,
+      maxItems: 2,
+      items: [
+        { type: "string", const: "TextQuoteSelector" },
+        { type: "string", const: "crm:E33_Linguistic_Object" }
+      ],
+      description: "The class of the Selector"
+    },
+    exact: {
+      type: "string",
+      description: "A copy of the text which is being selected, after normalization."
+    },
+    prefix: {
+      type: "string",
+      description: "The snippet of text that occurs immediately before the text which is being selected."
+    },
+    suffix: {
+      type: "string",
+      description: "The snippet of text that occurs immediately after the text which is being selected."
+    }
+  },
+  required: ["id", "type", "exact", "prefix", "suffix"]
+};
+var textQuoteSelectorExtendedSchema = {
+  type: "object",
+  description: "Quote Selector",
+  properties: {
+    ...textQuoteSelectorSchema.properties,
+    refinedBy: {
+      type: "object",
+      description: selectorRefinedByDescription,
+      oneOf: [
+        { $ref: "defs.jsonld#/definitions/textPositionSelector" },
+        { $ref: "defs.jsonld#/definitions/textQuoteSelector" }
+      ],
+      nullable: true,
+      required: []
+    }
+  },
+  required: ["id", "type", "exact", "prefix", "suffix"]
+};
+
+// src/v1/schema/definitions/target/selector/xpath.ts
+var XpathSelector = import_zod19.z.object({
+  id: import_zod19.z.string().describe(selectorIdDescription),
+  type: import_zod19.z.tuple([import_zod19.z.literal("XPathSelector"), import_zod19.z.literal("crm:E73_Information_Object")]),
+  value: import_zod19.z.string().min(1).describe("The xpath to the selected segment.")
 }).describe("Xpath Selector");
+var XpathSelectorExtended = XpathSelector.extend({
+  refinedBy: import_zod19.z.union([TextPositionSelector, TextQuoteSelector]).optional().describe(selectorRefinedByDescription)
+});
 var xpathSelectorSchema = {
   type: "object",
   description: "Xpath Selector",
   properties: {
-    id: {
-      type: "string",
-      format: "uuid",
-      description: "UUID that identifies the selector."
-    },
+    id: { type: "string", format: "uri", description: selectorIdDescription },
     type: {
       type: "array",
       minItems: 2,
@@ -3606,20 +3867,33 @@ var xpathSelectorSchema = {
     value: {
       type: "string",
       description: "Web Annotation Target Select Xpath"
-    },
+    }
+  },
+  required: ["id", "type", "value"]
+};
+var xpathSelectorExtendedSchema = {
+  type: "object",
+  description: "Xpath Selector",
+  properties: {
+    ...xpathSelectorSchema.properties,
     refinedBy: {
-      $ref: "defs.jsonld#/definitions/textPositionSelector",
-      description: "The relationship between a broader selector and the more specific selector that should be applied to the results of the first."
+      type: "object",
+      description: selectorRefinedByDescription,
+      anyOf: [
+        { $ref: "defs.jsonld#/definitions/textPositionSelector" },
+        { $ref: "defs.jsonld#/definitions/textQuoteSelector" }
+      ],
+      nullable: true,
+      required: []
     }
   },
   required: ["id", "type", "value"]
-  // errorMessage: { properties: { id: 'Must be an URI' } },
 };
 
 // src/v1/schema/definitions/target/selector/range.ts
-var RangeSelector = import_zod19.z.object({
-  id: import_zod19.z.string().uuid().describe("UUID that identifies the selector."),
-  type: import_zod19.z.tuple([import_zod19.z.literal("RangeSelector"), import_zod19.z.literal("crm:E73_Information_Object")]),
+var RangeSelector = import_zod20.z.object({
+  id: import_zod20.z.string().url().describe(selectorIdDescription),
+  type: import_zod20.z.tuple([import_zod20.z.literal("RangeSelector"), import_zod20.z.literal("crm:E73_Information_Object")]),
   startSelector: XpathSelector,
   endSelector: XpathSelector
 }).describe("Range Selector");
@@ -3627,11 +3901,7 @@ var rangeSelectorSchema = {
   type: "object",
   description: "Range Selector",
   properties: {
-    id: {
-      type: "string",
-      format: "uuid",
-      description: "UUID that identifies the selector."
-    },
+    id: { type: "string", format: "uri", description: selectorIdDescription },
     type: {
       type: "array",
       minItems: 2,
@@ -3646,106 +3916,113 @@ var rangeSelectorSchema = {
     endSelector: { $ref: "defs.jsonld#/definitions/xpathSelector" }
   },
   required: ["id", "type", "startSelector", "endSelector"]
-  // errorMessage: { properties: { id: 'Must be an URI' } },
 };
 
-// src/v1/schema/definitions/target/selector/textQuote.ts
-var import_zod20 = require("zod");
-var TextQuoteSelector = import_zod20.z.object({
-  id: import_zod20.z.string().uuid().describe("UUID that identifies the selector."),
-  type: import_zod20.z.tuple([import_zod20.z.literal("TextQuoteSelector"), import_zod20.z.literal("crm:E33_Linguistic_Object")]),
-  exact: import_zod20.z.string().describe("A copy of the text which is being selected, after normalization."),
-  prefix: import_zod20.z.string().optional().describe(
-    "The snippet of text that occurs immediately before the text which is being selected."
+// 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.";
+var Selector = import_zod21.z.union([
+  TextQuoteSelectorExtended,
+  TextPositionSelectorExtended,
+  XpathSelectorExtended,
+  RangeSelector
+]);
+var selectorSchema = {
+  type: "object",
+  oneOf: [
+    textQuoteSelectorExtendedSchema,
+    textPositionSelectorExtendedSchema,
+    xpathSelectorExtendedSchema,
+    rangeSelectorSchema
+  ],
+  required: []
+};
+
+// src/v1/schema/definitions/target/source.ts
+var import_zod22 = 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 Format = import_zod22.z.string().min(1).describe(formatDescription);
+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_zod22.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 Source = import_zod22.z.object({
+  id: import_zod22.z.string().url().describe(sourceIdDescription),
+  format: import_zod22.z.union([Format, import_zod22.z.array(Format).min(1)]).optional().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."
   ),
-  sufix: import_zod20.z.string().optional().describe(
-    "The snippet of text that occurs immediately after the text which is being selected."
+  language: import_zod22.z.union([Language, import_zod22.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."
   ),
-  refinedBy: import_zod20.z.union([RangeSelector, XpathSelector, TextPositionSelector]).optional().describe(
-    "The relationship between a broader selector and the more specific selector that should be applied to the results of the first."
-  )
-}).describe("Quote Selector");
-var textQuoteSelectorSchema = {
+  title: import_zod22.z.string().min(1, { message: "The title cannot be empty" }).optional().describe("The title of the document being annotated.")
+}).describe("Web Annotation Target");
+var sourceSchema = {
   type: "object",
-  description: "Quote Selector",
+  description: `Web Annotation Target's source`,
   properties: {
-    id: {
-      type: "string",
-      format: "uuid",
-      description: "UUID that identifies the selector."
-    },
-    type: {
-      type: "array",
-      minItems: 2,
-      maxItems: 2,
-      items: [
-        { type: "string", const: "TextQuoteSelector" },
-        { type: "string", const: "crm:E33_Linguistic_Object" }
-      ],
-      description: "The class of the Selector"
-    },
-    exact: {
-      type: "string",
-      description: "A copy of the text which is being selected, after normalization."
+    id: { type: "string", format: "uri", description: sourceIdDescription },
+    format: {
+      type: ["string", "array"],
+      nullable: true,
+      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."
+        }
+      ]
     },
-    prefix: {
-      type: "string",
-      description: "The snippet of text that occurs immediately before the text which is being selected."
+    language: {
+      type: ["string", "array"],
+      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."
+        }
+      ]
     },
-    sufix: {
+    title: {
       type: "string",
-      description: "The snippet of text that occurs immediately after the text which is being selected."
-    },
-    refinedBy: {
-      type: "object",
-      description: "The relationship between a broader selector and the more specific selector that should be applied to the results of the first.",
-      oneOf: [
-        { $ref: "defs.jsonld#/definitions/rangeSelector" },
-        { $ref: "defs.jsonld#/definitions/xpathSelector" },
-        { $ref: "defs.jsonld#/definitions/textPositionSelector" }
-      ],
-      required: []
+      minLength: 1,
+      nullable: true,
+      description: "The title of the document being annotated."
     }
   },
-  required: ["id", "type", "exact"]
-  // errorMessage: { properties: { id: 'Must be an URI' } },
+  required: ["id"]
 };
 
 // src/v1/schema/definitions/target/index.ts
-var Target = import_zod21.z.object({
-  id: import_zod21.z.union([import_zod21.z.string().url(), import_zod21.z.string().uuid()]).describe("The IRI that identifies the Target resource."),
-  type: import_zod21.z.tuple([import_zod21.z.literal("SpecificResource"), import_zod21.z.literal("crm:E73_Information_Object")]).describe("The class of the Specific Resource."),
-  format: import_zod21.z.array(
-    import_zod21.z.string().min(1).describe(
-      "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."
-    )
-  ).optional().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."
-  ),
-  language: import_zod21.z.array(
-    import_zod21.z.string().min(2).max(3).describe(
-      "The language of the Web Resource's content. The value of the property should be a language code following the [bcp47] specification."
-    )
-  ).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."
-  ),
-  title: import_zod21.z.string().min(1, { message: "The title cannot be empty" }).optional().describe("The title of the document being annotated."),
+var targetIdDescription = "The IRI that identifies the Target resource.";
+var Target = import_zod23.z.object({
+  id: import_zod23.z.string().url().describe(targetIdDescription),
+  type: import_zod23.z.tuple([import_zod23.z.literal("SpecificResource"), import_zod23.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."
   ),
-  selector: import_zod21.z.union([TextQuoteSelector, RangeSelector, XpathSelector, TextPositionSelector]).optional().describe("The relationship between a Specific Resource and a Selector. ")
+  selector: import_zod23.z.union([Selector, import_zod23.z.array(Selector)]).describe("The relationship between a Specific Resource and a Selector. ")
 }).describe("Web Annotation Target");
 var targetSchema = {
   type: "object",
   description: "Web Annotation Target",
   properties: {
-    id: {
-      anyOf: [
-        { type: "string", format: "uri", description: "This document URI" },
-        { type: "string", format: "uuid" }
-      ],
-      description: "The IRI that identifies the Target resource."
-    },
+    id: { type: "string", format: "uri", description: targetIdDescription },
     type: {
       type: "array",
       minItems: 2,
@@ -3756,49 +4033,23 @@ var targetSchema = {
       ],
       description: "The class of the Specific Resource."
     },
-    format: {
-      type: "array",
-      items: {
-        type: "string",
-        minLength: 1,
-        description: "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."
-      },
-      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."
-    },
-    language: {
-      type: "array",
-      items: {
-        type: "string",
-        minLength: 2,
-        maxLength: 3,
-        description: "The language of the Web Resource's content. The value of the property should be a language code following the [bcp47] specification."
-      },
-      minItems: 1,
-      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."
-    },
-    title: {
-      type: "string",
-      minLength: 1,
-      description: "The title of the document being annotated."
-    },
+    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."
     },
     selector: {
-      type: "object",
-      oneOf: [
-        { $ref: "defs.jsonld#/definitions/textQuoteSelector" },
-        { $ref: "defs.jsonld#/definitions/rangeSelector" },
-        { $ref: "defs.jsonld#/definitions/xpathSelector" },
-        { $ref: "defs.jsonld#/definitions/textPositionSelector" }
-      ],
-      description: "The relationship between a Specific Resource and a Selector. ",
-      required: ["id", "type"]
+      anyOf: [
+        selectorSchema,
+        {
+          type: "array",
+          items: selectorSchema,
+          minItems: 1
+        }
+      ]
     }
   },
-  required: ["id", "type"],
-  // errorMessage: { properties: { id: 'Must be an URI or an UUID' } },
+  required: ["id", "type", "source", "selector"],
   allOf: [
     {
       if: {
@@ -3823,10 +4074,9 @@ var targetSchema = {
       then: {
         type: "object",
         properties: {
-          selector: { type: "object", required: ["type", "exact"] }
+          selector: { type: "object", required: ["id", "type", "exact", "prefix", "suffix"] }
         }
-      },
-      required: ["selector"]
+      }
     },
     {
       if: {
@@ -3852,8 +4102,7 @@ var targetSchema = {
         type: "object",
         properties: {
           selector: { type: "object", required: ["type", "startSelector", "endSelector"] }
-        },
-        required: ["selector"]
+        }
       }
     },
     {
@@ -3880,8 +4129,7 @@ var targetSchema = {
         type: "object",
         properties: {
           selector: { type: "object", required: ["type", "value"] }
-        },
-        required: ["selector"]
+        }
       }
     },
     {
@@ -3908,8 +4156,7 @@ var targetSchema = {
         type: "object",
         properties: {
           selector: { type: "object", required: ["type", "start", "end"] }
-        },
-        required: ["selector"]
+        }
       }
     }
   ]
@@ -3923,17 +4170,17 @@ var definitionSchema = {
     creator: creatorSchema,
     software: softwareSchema,
     target: targetSchema,
+    textPositionSelector: textPositionSelectorSchema,
     textQuoteSelector: textQuoteSelectorSchema,
-    rangeSelector: rangeSelectorSchema,
     xpathSelector: xpathSelectorSchema,
-    textPositionSelector: textPositionSelectorSchema,
+    rangeSelector: rangeSelectorSchema,
     body: bodySchema
   },
   required: []
 };
 
 // src/v1/schema/root.ts
-var import_zod22 = require("zod");
+var import_zod24 = require("zod");
 var Status = ["draft", "approved", "published"];
 var Motivation = [
   "identifying",
@@ -3944,32 +4191,26 @@ var Motivation = [
   "linking",
   "citing"
 ];
-var WebAnnotation = import_zod22.z.object({
-  "@context": import_zod22.z.tuple([
-    import_zod22.z.literal("http://www.w3.org/ns/anno.jsonld").describe("W3C Web Annotation Context."),
-    import_zod22.z.literal(contextUri).describe("LINCS Web Annotation Context.")
+var WebAnnotation = import_zod24.z.object({
+  "@context": import_zod24.z.tuple([
+    import_zod24.z.literal("http://www.w3.org/ns/anno.jsonld").describe("W3C Web Annotation Context."),
+    import_zod24.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_zod22.z.union([
-    import_zod22.z.string().url(),
-    //? We can improve this making it a regexp to make sure that this URI contains a search params named 'annoID' with n UUID value".])
-    import_zod22.z.string().uuid()
-  ]).describe(
-    "The identity of the Annotation. It must be a UUID or URI containing a UUID in the search params (URI?annoId=URI)"
-  ),
-  type: import_zod22.z.tuple([import_zod22.z.literal("Annotation"), import_zod22.z.literal("crm:E33_Linguistic_Object")]).describe("The type of the Annotation."),
-  motivation: import_zod22.z.tuple([import_zod22.z.enum(Motivation), import_zod22.z.literal("crm:E55_Type")]).describe("The relationship between an Annotation and a Motivation."),
-  created: import_zod22.z.string().datetime().describe("The time at which the resource was created."),
-  modified: import_zod22.z.string().datetime().optional().describe("The time at which the resource was modified, after creation."),
-  status: import_zod22.z.enum(Status).describe("The status of this annotation in a workflow."),
+  id: import_zod24.z.string().url().describe("The identity of the Annotation."),
+  type: import_zod24.z.tuple([import_zod24.z.literal("Annotation"), import_zod24.z.literal("crm:E33_Linguistic_Object")]).describe("The type of the Annotation."),
+  motivation: import_zod24.z.tuple([import_zod24.z.enum(Motivation), import_zod24.z.literal("crm:E55_Type")]).describe("The relationship between an Annotation and a Motivation."),
+  created: import_zod24.z.string().datetime().describe("The time at which the resource was created."),
+  modified: import_zod24.z.string().datetime().optional().describe("The time at which the resource was modified, after creation."),
+  status: import_zod24.z.enum(Status).describe("The status of this annotation in a workflow."),
   creator: User.describe("The agent responsible for creating the resource.").optional(),
-  contributor: import_zod22.z.array(User.describe("The agents responsible for modifying the resource.")).nonempty().optional().describe("The agents responsible for modifying the resource."),
+  contributor: import_zod24.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_zod22.z.union([Body, import_zod22.z.array(Body)]).describe("The relationship between an Annotation and its Body.")
+  body: import_zod24.z.union([Body, import_zod24.z.array(Body)]).describe("The relationship between an Annotation and its Body.")
 }).describe("Web Annotation Root");
 var webAnnotationSchema = {
   $id: schemaId,
@@ -3987,15 +4228,9 @@ var webAnnotationSchema = {
       description: "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: {
-      anyOf: [
-        {
-          type: "string",
-          format: "uri",
-          description: "It must be a UUID or URI containing a UUID in the search params (URI?annoId=URI)."
-        },
-        { type: "string", format: "uuid" }
-      ],
-      description: "The identity of the Annotation. It must be a UUID or URI containing a UUID in the search params (URI?annoId=URI)"
+      type: "string",
+      format: "uri",
+      description: "The type of the Annotation."
     },
     type: {
       type: "array",
@@ -4062,28 +4297,6 @@ var webAnnotationSchema = {
     "status"
   ],
   allOf: [
-    {
-      if: {
-        type: "object",
-        properties: {
-          status: { const: "published" }
-        }
-      },
-      then: {
-        type: "object",
-        properties: {
-          id: { type: "string", format: "uri" }
-        },
-        required: ["status"]
-      },
-      else: {
-        type: "object",
-        properties: {
-          id: { type: "string", format: "uuid" }
-        },
-        required: ["status"]
-      }
-    },
     {
       if: {
         type: "object",
@@ -4294,24 +4507,25 @@ var import_ajv = __toESM(require("ajv"));
 var import_ajv_formats = __toESM(require("ajv-formats"));
 
 // src/v1/validator/types.ts
-var import_zod23 = require("zod");
-var ValidationError = import_zod23.z.object({
-  message: import_zod23.z.string(),
-  path: import_zod23.z.string(),
-  suggestion: import_zod23.z.string().optional(),
-  context: import_zod23.z.object({
-    errorType: import_zod23.z.string()
-  }).and(import_zod23.z.unknown())
+var import_zod25 = require("zod");
+var ValidationError = import_zod25.z.object({
+  message: import_zod25.z.string(),
+  path: import_zod25.z.string(),
+  suggestion: import_zod25.z.string().optional(),
+  context: import_zod25.z.object({
+    errorType: import_zod25.z.string()
+  }).and(import_zod25.z.unknown())
 });
-var ValidateResult = import_zod23.z.object({
-  valid: import_zod23.z.boolean(),
-  errors: import_zod23.z.array(ValidationError).optional()
+var ValidateResult = import_zod25.z.object({
+  valid: import_zod25.z.boolean(),
+  errors: import_zod25.z.array(ValidationError).optional()
 });
 
 // src/v1/validator/index.ts
 var ajv = new import_ajv.default({
   code: { source: true },
-  allErrors: true
+  allErrors: true,
+  allowUnionTypes: true
 }).addSchema([webAnnotationSchema, definitionSchema]);
 (0, import_ajv_formats.default)(ajv);
 var validator = ajv.compile(webAnnotationSchema);
@@ -4338,33 +4552,119 @@ var getErrors = (annotation) => {
 var v1_exports = {};
 __export(v1_exports, {
   Body: () => Body,
+  BodyEntityType: () => BodyEntityType,
+  Certainty: () => Certainty,
+  Citation: () => Citation,
+  CitationEntityType: () => CitationEntityType,
+  ConceptualObject: () => ConceptualObject,
+  ConceptualObjectEntityType: () => ConceptualObjectEntityType,
+  Correction: () => Correction,
+  CorrectionEntityType: () => CorrectionEntityType,
+  DATE_RANGE_PATTERN: () => DATE_RANGE_PATTERN,
+  Date: () => Date2,
+  DateEntityType: () => DateEntityType,
+  Description: () => Description,
+  Event: () => Event,
+  EventEntityType: () => EventEntityType,
+  Keyword: () => Keyword,
+  KeywordEntityType: () => KeywordEntityType,
+  KeywordFolksnomy: () => KeywordFolksnomy,
+  KeywordFolksnomyEntityType: () => KeywordFolksnomyEntityType,
+  Label: () => Label,
+  Link: () => Link,
+  LinkEntityType: () => LinkEntityType,
   Motivation: () => Motivation,
+  Note: () => Note,
+  NoteEntityType: () => NoteEntityType,
+  Organization: () => Organization,
+  OrganizationEntityType: () => OrganizationEntityType,
   Person: () => Person,
   PersonEntityType: () => PersonEntityType,
+  PhysicalThing: () => PhysicalThing,
+  PhysicalThingEntityType: () => PhysicalThingEntityType,
+  Place: () => Place,
+  PlaceEntityType: () => PlaceEntityType,
+  Precision: () => Precision,
+  Quality: () => Quality,
+  RangeSelector: () => RangeSelector,
+  Selector: () => Selector,
   Software: () => Software,
+  Source: () => Source,
   Status: () => Status,
   Target: () => Target,
+  TextPositionSelector: () => TextPositionSelector,
+  TextPositionSelectorExtended: () => TextPositionSelectorExtended,
+  TextQuoteSelector: () => TextQuoteSelector,
+  TextQuoteSelectorExtended: () => TextQuoteSelectorExtended,
   User: () => User,
   VERSION: () => VERSION,
   ValidateResult: () => ValidateResult,
   ValidationError: () => ValidationError,
   WebAnnotation: () => WebAnnotation,
+  Work: () => Work,
+  WorkEntityType: () => WorkEntityType,
+  XpathSelector: () => XpathSelector,
+  XpathSelectorExtended: () => XpathSelectorExtended,
   ajv: () => ajv,
+  bodyIdDescription: () => bodyIdDescription,
   bodySchema: () => bodySchema,
+  certaintySchema: () => certaintySchema,
+  citationEntityTypeSchema: () => citationEntityTypeSchema,
+  citationSchema: () => citationSchema,
+  conceptualObjectEntityTypeSchema: () => conceptualObjectEntityTypeSchema,
+  conceptualObjectSchema: () => conceptualObjectSchema,
   contextUri: () => contextUri,
+  correctionEntityTypeSchema: () => correctionEntityTypeSchema,
+  correctionSchema: () => correctionSchema,
   creatorSchema: () => creatorSchema,
+  dateEntityTypeSchema: () => dateEntityTypeSchema,
+  dateSchema: () => dateSchema,
   definitionSchema: () => definitionSchema,
   defsId: () => defsId,
+  descriptionSchema: () => descriptionSchema,
+  eventEntityTypeSchema: () => eventEntityTypeSchema,
+  eventSchema: () => eventSchema,
+  formatSchema: () => formatSchema,
   generateAssets: () => generateAssets,
+  keywordEntityTypeSchema: () => keywordEntityTypeSchema,
+  keywordFolksnomyEntityTypeSchema: () => keywordFolksnomyEntityTypeSchema,
+  keywordFolksnomySchema: () => keywordFolksnomySchema,
+  keywordSchema: () => keywordSchema,
+  labelSchema: () => labelSchema,
+  languageSchema: () => languageSchema,
+  linkEntityTypeSchema: () => linkEntityTypeSchema,
+  linkSchema: () => linkSchema,
+  noteEntityTypeSchema: () => noteEntityTypeSchema,
+  noteSchema: () => noteSchema,
+  organizationEntityTypeSchema: () => organizationEntityTypeSchema,
+  organizationSchema: () => organizationSchema,
   personEntityTypeSchema: () => personEntityTypeSchema,
   personSchema: () => personSchema,
+  physicalThingEntityTypeSchema: () => physicalThingEntityTypeSchema,
+  physicalThingSchema: () => physicalThingSchema,
+  placeEntityTypeSchema: () => placeEntityTypeSchema,
+  placeSchema: () => placeSchema,
+  precisionSchema: () => precisionSchema,
+  rangeSelectorSchema: () => rangeSelectorSchema,
   schemaContext: () => schemaContext,
   schemaId: () => schemaId,
+  selectorIdDescription: () => selectorIdDescription,
+  selectorRefinedByDescription: () => selectorRefinedByDescription,
+  selectorSchema: () => selectorSchema,
   softwareSchema: () => softwareSchema,
+  sourceSchema: () => sourceSchema,
   targetSchema: () => targetSchema,
+  textPositionSelectorExtendedSchema: () => textPositionSelectorExtendedSchema,
+  textPositionSelectorSchema: () => textPositionSelectorSchema,
+  textQuoteSelectorExtendedSchema: () => textQuoteSelectorExtendedSchema,
+  textQuoteSelectorSchema: () => textQuoteSelectorSchema,
   validate: () => validate,
   validator: () => validator,
-  webAnnotationSchema: () => webAnnotationSchema
+  webAnnotationSchema: () => webAnnotationSchema,
+  workEntityTypeSchema: () => workEntityTypeSchema,
+  workSchema: () => workSchema,
+  xpathSelectorExtendedSchema: () => xpathSelectorExtendedSchema,
+  xpathSelectorSchema: () => xpathSelectorSchema
 });
 
 // src/v1/generate/examples.ts
@@ -4480,45 +4780,49 @@ var commonCreator = {
   name: "user"
 };
 var commonSoftware = {
-  id: "htpps://leafwriter.com",
+  id: "https://leafwriter.com",
   type: ["Software", "crm:P16_used_specific_object"],
   label: "LEAF-Writer"
 };
 var commonSelectorTextPosition = {
-  id: "55369c00-5c43-4d1a-8462-31c74fbec584",
+  id: "https://wa.lincsproject/selector/55369c00-5c43-4d1a-8462-31c74fbec584",
   type: ["TextPositionSelector", "crm:E73_Information_Object"],
   start: 12,
   end: 30
 };
 var commonSelectorXpath = {
-  id: "55369c00-5c43-4d1a-8462-31c74fbec582",
+  id: "https://wa.lincsproject/selector/55369c00-5c43-4d1a-8462-31c74fbec582",
   type: ["XPathSelector", "crm:E73_Information_Object"],
   value: "TEI/tex/div/text/p/personName"
 };
 var commonSelectorRange = {
-  id: "55369c00-5c43-4d1a-8462-31c74fbec582",
+  id: "https://wa.lincsproject/selector/55369c00-5c43-4d1a-8462-31c74fbec581",
   type: ["RangeSelector", "crm:E73_Information_Object"],
   startSelector: commonSelectorXpath,
   endSelector: commonSelectorXpath
 };
 var commonSelectorTextQuote = {
-  id: "55369c00-5c43-4d1a-8462-31c74fbec583",
+  id: "https://wa.lincsproject/selector/55369c00-5c43-4d1a-8462-31c74fbec583",
   type: ["TextQuoteSelector", "crm:E33_Linguistic_Object"],
-  exact: "text",
-  prefix: "pre",
-  suffix: "suf"
-};
-var commonDetailedSelector = {
-  ...commonSelectorTextQuote,
-  refinedBy: { ...commonSelectorXpath, refinedBy: commonSelectorTextPosition }
+  exact: "exact text",
+  prefix: "prefix text",
+  suffix: "prefix text"
 };
 var commonTarget = {
-  id: "https://document.com",
+  id: "https://wa.lincsproject/target/55369c00-5c43-4d1a-8462-31c74fbec522",
   type: ["SpecificResource", "crm:E73_Information_Object"],
-  format: ["application/xml"],
-  language: ["eng"],
-  renderedVia: commonSoftware,
-  selector: commonDetailedSelector
+  source: {
+    id: "https://document-url.com"
+  },
+  selector: commonSelectorTextQuote
+};
+var commonTargetMultipleSelectors = {
+  id: "https://wa.lincsproject/target/55369c00-5c43-4d1a-8462-31c74fbec522",
+  type: ["SpecificResource", "crm:E73_Information_Object"],
+  source: {
+    id: "https://document-url.com"
+  },
+  selector: [commonSelectorTextQuote, commonSelectorTextPosition]
 };
 var commonBody = {
   id: "https://www.uo.com/person",
@@ -4526,7 +4830,7 @@ var commonBody = {
 };
 var commonAnnotation = {
   "@context": ["http://www.w3.org/ns/anno.jsonld", "https://wa.lincsproject.ca/v1/ns/anno.jsonld"],
-  id: "c7aa1b38-6364-483c-8607-44dc3f510a59",
+  id: "https://wa.lincsproject/c7aa1b38-6364-483c-8607-44dc3f510a59",
   type: ["Annotation", "crm:E33_Linguistic_Object"],
   motivation: ["identifying", "crm:E55_Type"],
   created: "2022-12-21T23:21:02Z",
@@ -4543,7 +4847,10 @@ var common = {
     textPosition: commonSelectorTextPosition,
     xpath: commonSelectorXpath,
     range: commonSelectorRange,
-    textQuote: commonSelectorTextQuote
+    textQuote: commonSelectorTextQuote,
+    multipleSelectors: {
+      textQuoteAndTextPosition: commonTargetMultipleSelectors
+    }
   },
   target: commonTarget,
   body: commonBody,
@@ -4654,7 +4961,7 @@ var simple = {
   ...common.annotation,
   motivation: ["citing", "crm:E55_Type"],
   body: {
-    id: "https://www.uo.com/conceptualObject",
+    id: "https://www.uo.com/work",
     entityType: ["cito:Citation", "crm:E73_Information_Object"]
   }
 };
@@ -4662,7 +4969,7 @@ var withCertainty3 = {
   ...common.annotation,
   motivation: ["citing", "crm:E55_Type"],
   body: {
-    id: "https://www.uo.com/conceptualObject",
+    id: "https://www.uo.com/work",
     entityType: ["cito:Citation", "crm:E73_Information_Object"],
     certainty: "edit:qualityHigh"
   }
@@ -4671,7 +4978,7 @@ var withLabelAndDescription3 = {
   ...common.annotation,
   motivation: ["citing", "crm:E55_Type"],
   body: {
-    id: "https://www.uo.com/conceptualObject",
+    id: "https://www.uo.com/work",
     entityType: ["cito:Citation", "crm:E73_Information_Object"],
     label: "Sandman",
     description: "Graphic Novel"
@@ -4731,7 +5038,7 @@ var valid = {
   ...common.annotation,
   motivation: ["correcting", "crm:E55_Type"],
   body: {
-    id: "55369c00-5c43-4d1a-8462-31c74fbec584",
+    id: "https://wa.lincsproject/55369c00-5c43-4d1a-8462-31c74fbec584",
     type: "TextualBody",
     entityType: ["fabio:Correction", "crm:E33_Linguistic_Object"],
     value: "this is a correction"
@@ -4745,7 +5052,7 @@ var correction = {
 var simple2 = {
   ...common.annotation,
   body: {
-    id: "55369c00-5c43-4d1a-8462-31c74fbec584",
+    id: "https://wa.lincsproject/55369c00-5c43-4d1a-8462-31c74fbec584",
     type: "TextualBody",
     entityType: ["xsd:date", "crm:E52_Time-Span"],
     value: "2012-03-01T00:00:00/2012-02-01T18:21:07"
@@ -4754,7 +5061,7 @@ var simple2 = {
 var withCertainty5 = {
   ...common.annotation,
   body: {
-    id: "55369c00-5c43-4d1a-8462-31c74fbec584",
+    id: "https://wa.lincsproject/55369c00-5c43-4d1a-8462-31c74fbec584",
     type: "TextualBody",
     entityType: ["xsd:date", "crm:E52_Time-Span"],
     value: "2012-03-01T00:00:00/2012-02-01T18:21:07",
@@ -4764,7 +5071,7 @@ var withCertainty5 = {
 var withPrecision2 = {
   ...common.annotation,
   body: {
-    id: "55369c00-5c43-4d1a-8462-31c74fbec584",
+    id: "https://wa.lincsproject/55369c00-5c43-4d1a-8462-31c74fbec584",
     type: "TextualBody",
     entityType: ["xsd:date", "crm:E52_Time-Span"],
     value: "2012-03-01T00:00:00/2012-02-01T18:21:07",
@@ -4811,7 +5118,7 @@ var folksonomy = {
   ...common.annotation,
   motivation: ["tagging", "crm:E55_Type"],
   body: {
-    id: "55369c00-5c43-4d1a-8462-31c74fbec584",
+    id: "https://wa.lincsproject/55369c00-5c43-4d1a-8462-31c74fbec584",
     type: "TextualBody",
     entityType: ["crm:E55_Type", "crm:E33_Linguistic_Object"],
     value: "a tag"
@@ -4858,7 +5165,7 @@ var simple4 = {
   ...common.annotation,
   motivation: ["describing", "crm:E55_Type"],
   body: {
-    id: "55369c00-5c43-4d1a-8462-31c74fbec584",
+    id: "https://wa.lincsproject/55369c00-5c43-4d1a-8462-31c74fbec584",
     type: "TextualBody",
     entityType: "crm:E33_Linguistic_Object",
     value: "this is a note"
@@ -4868,7 +5175,7 @@ var additionalType = {
   ...common.annotation,
   motivation: ["describing", "crm:E55_Type"],
   body: {
-    id: "55369c00-5c43-4d1a-8462-31c74fbec584",
+    id: "https://wa.lincsproject/55369c00-5c43-4d1a-8462-31c74fbec584",
     type: "TextualBody",
     entityType: "crm:E33_Linguistic_Object",
     additionalType: "cwrc:NoteScholarly",
@@ -4879,7 +5186,7 @@ var additionalMultipleTypes = {
   ...common.annotation,
   motivation: ["describing", "crm:E55_Type"],
   body: {
-    id: "55369c00-5c43-4d1a-8462-31c74fbec584",
+    id: "https://wa.lincsproject/55369c00-5c43-4d1a-8462-31c74fbec584",
     type: "TextualBody",
     entityType: "crm:E33_Linguistic_Object",
     additionalType: ["scholarly", "academic"],
@@ -5017,6 +5324,47 @@ var work = {
   }
 };
 
+// src/v1/mocks/body/event.ts
+var real7 = {
+  ...common.annotation,
+  body: {
+    id: "https://www.uo.com/event",
+    entityType: ["YET TO BE DEFINED EVENT CLASS", "crm:E5_Event"]
+  }
+};
+var fictional7 = {
+  ...common.annotation,
+  body: {
+    id: "https://www.uo.com/event",
+    entityType: ["YET TO BE DEFINED EVENT CLASS", "crm:E89_Propositional_Object"]
+  }
+};
+var withCertainty10 = {
+  ...common.annotation,
+  body: {
+    id: "https://www.uo.com/event",
+    entityType: ["YET TO BE DEFINED EVENT CLASS", "crm:E5_Event"],
+    certainty: "edit:qualityLow"
+  }
+};
+var withLabelAndDescription8 = {
+  ...common.annotation,
+  body: {
+    id: "https://www.uo.com/event",
+    entityType: ["YET TO BE DEFINED EVENT CLASS", "crm:E5_Event"],
+    label: "revolution",
+    description: "An event"
+  }
+};
+var event = {
+  valid: {
+    real: real7,
+    fictional: fictional7,
+    withCertainty: withCertainty10,
+    withLabelAndDescription: withLabelAndDescription8
+  }
+};
+
 // src/v1/mocks/body/index.ts
 var personPlace = {
   ...common.annotation,
@@ -5051,7 +5399,6 @@ var generatorWithVersion = {
   ...common.annotation,
   generator: { ...common.software, softwareVersion: "v1.2.5" }
 };
-var { creator } = common.annotation;
 var noCreator = {
   ...common.annotation
 };
@@ -5071,15 +5418,6 @@ var agent = {
 };
 
 // src/v1/mocks/root/root.ts
-var idUri = {
-  ...common.annotation,
-  id: "http://www.uo.com/wa",
-  status: "published"
-};
-var idUUID = {
-  ...common.annotation,
-  id: "55369c00-5c43-4d1a-8462-31c74fbec584"
-};
 var motivationIdentify = {
   ...common.annotation,
   motivation: ["identifying", "crm:E55_Type"],
@@ -5089,7 +5427,7 @@ var motivationDescribing = {
   ...common.annotation,
   motivation: ["describing", "crm:E55_Type"],
   body: {
-    id: "55369c00-5c43-4d1a-8462-31c74fbec584",
+    id: "https://wa.lincsproject/55369c00-5c43-4d1a-8462-31c74fbec584",
     type: "TextualBody",
     entityType: "crm:E33_Linguistic_Object",
     value: "this is a note"
@@ -5099,7 +5437,7 @@ var motivationCorrecting = {
   ...common.annotation,
   motivation: ["correcting", "crm:E55_Type"],
   body: {
-    id: "55369c00-5c43-4d1a-8462-31c74fbec584",
+    id: "https://wa.lincsproject/55369c00-5c43-4d1a-8462-31c74fbec584",
     type: "TextualBody",
     entityType: ["fabio:Correction", "crm:E33_Linguistic_Object"],
     value: "this is a correction"
@@ -5109,7 +5447,7 @@ var motivationTagging = {
   ...common.annotation,
   motivation: ["tagging", "crm:E55_Type"],
   body: {
-    id: "55369c00-5c43-4d1a-8462-31c74fbec584",
+    id: "https://wa.lincsproject/55369c00-5c43-4d1a-8462-31c74fbec584",
     type: "TextualBody",
     entityType: ["crm:E55_Type", "crm:E33_Linguistic_Object"],
     value: "a tag"
@@ -5158,10 +5496,6 @@ var statusPublished = {
 };
 var root = {
   valid: {
-    id: {
-      uri: idUri,
-      uuid: idUUID
-    },
     motivation: {
       identify: motivationIdentify,
       describing: motivationDescribing,
@@ -5181,133 +5515,191 @@ var root = {
 };
 
 // src/v1/mocks/target/selector.ts
-var textQuoteSimple = {
+var textQuote = {
   ...common.annotation,
   target: {
     ...common.target,
     selector: common.selector.textQuote
   }
 };
-var textQuoteRefinedByXpath = {
+var textQuoteRefinedByTextPosition = {
   ...common.annotation,
   target: {
     ...common.target,
     selector: {
       ...common.selector.textQuote,
-      refinedBy: common.selector.xpath
+      refinedBy: common.selector.textPosition
     }
   }
 };
-var textQuoteRefinedByXapthRefinedByTextPosition = {
+var textQuoteRefinedByTextQuote = {
   ...common.annotation,
   target: {
     ...common.target,
     selector: {
       ...common.selector.textQuote,
-      refinedBy: {
-        ...common.selector.xpath,
-        refinedBy: common.selector.textPosition
-      }
+      refinedBy: common.selector.textQuote
     }
   }
 };
-var textQuoteRefinedByTextPosition = {
+var xpath = {
+  ...common.annotation,
+  target: {
+    ...common.target,
+    selector: common.selector.xpath
+  }
+};
+var xpathRefinedByTextPosition = {
   ...common.annotation,
   target: {
     ...common.target,
     selector: {
-      ...common.selector.textQuote,
+      ...common.selector.xpath,
       refinedBy: common.selector.textPosition
     }
   }
 };
-var xpath = {
+var xpathRefinedByTextQuote = {
   ...common.annotation,
   target: {
     ...common.target,
-    selector: common.selector.xpath
+    selector: {
+      ...common.selector.xpath,
+      refinedBy: common.selector.textQuote
+    }
   }
 };
-var xpathRefinedByTextPosition = {
+var textPosition = {
+  ...common.annotation,
+  target: {
+    ...common.target,
+    selector: common.selector.textPosition
+  }
+};
+var textPositionRefinedByTextQuote = {
   ...common.annotation,
   target: {
     ...common.target,
     selector: {
-      ...common.selector.xpath,
+      ...common.selector.textPosition,
+      refinedBy: common.selector.textQuote
+    }
+  }
+};
+var textPositionRefinedByTextPosition = {
+  ...common.annotation,
+  target: {
+    ...common.target,
+    selector: {
+      ...common.selector.textPosition,
       refinedBy: common.selector.textPosition
     }
   }
 };
-var textPosition = {
+var range = {
   ...common.annotation,
   target: {
     ...common.target,
-    selector: common.selector.textPosition
+    selector: common.selector.range
+  }
+};
+var textQuoteAndTextPosition = {
+  ...common.annotation,
+  target: {
+    ...common.target,
+    selector: [common.selector.textQuote, common.selector.textPosition]
   }
 };
 var targetSelector = {
   valid: {
     selector: {
       textQuote: {
-        simple: textQuoteSimple,
-        refinedByXpath: textQuoteRefinedByXpath,
-        refinedByXpathAndTextPosition: textQuoteRefinedByXapthRefinedByTextPosition,
-        refinedByTextPositon: textQuoteRefinedByTextPosition
+        simple: textQuote,
+        refinedByTextPositon: textQuoteRefinedByTextPosition,
+        refinedByTextQuote: textQuoteRefinedByTextQuote
       },
       xpath: {
         simple: xpath,
-        refinedByTextPositon: xpathRefinedByTextPosition
+        refinedByTextPositon: xpathRefinedByTextPosition,
+        refinedByTextQuote: xpathRefinedByTextQuote
       },
-      textPositon: textPosition
+      textPosition: {
+        simple: textPosition,
+        refinedByTextPositon: textPositionRefinedByTextQuote,
+        refinedByTextQuote: textPositionRefinedByTextPosition
+      },
+      range,
+      multipleSelector: {
+        textQuoteAndTextPosition
+      }
     }
   }
 };
 
 // src/v1/mocks/target/target.ts
 var simple5 = {
+  ...common.annotation,
+  target: common.target
+};
+var withSourceTitle = {
   ...common.annotation,
   target: {
-    id: "https://document.com",
-    type: ["SpecificResource", "crm:E73_Information_Object"],
-    selector: common.selector.textPosition
+    ...common.target,
+    source: {
+      id: "https://document-url.com",
+      title: "Document Title"
+    }
   }
 };
-var withFormat = {
+var withSourceFormat = {
   ...common.annotation,
   target: {
-    id: "https://document.com",
-    type: ["SpecificResource", "crm:E73_Information_Object"],
-    format: ["application/xml"],
-    selector: common.selector.textPosition
+    ...common.target,
+    source: {
+      id: "https://document-url.com",
+      title: "Document Title",
+      format: ["application/xml"]
+    }
   }
 };
-var withLanguage = {
+var withSourceLanguage = {
   ...common.annotation,
   target: {
-    id: "https://document.com",
-    type: ["SpecificResource", "crm:E73_Information_Object"],
-    language: ["eng"],
-    selector: common.selector.textPosition
+    ...common.target,
+    source: {
+      id: "https://document-url.com",
+      title: "Document Title",
+      format: ["application/xml"],
+      language: ["eng"]
+    }
   }
 };
 var withRendererSoftware = {
   ...common.annotation,
   target: {
-    id: "https://document.com",
-    type: ["SpecificResource", "crm:E73_Information_Object"],
-    renderedVia: common.software,
-    selector: common.selector.textPosition
+    ...common.target,
+    renderedVia: common.software
   }
 };
 var complete = {
   ...common.annotation,
-  target: common.target
+  target: {
+    ...common.target,
+    source: {
+      id: "https://document-url.com",
+      title: "Document Title",
+      format: ["application/xml"],
+      language: ["eng"]
+    },
+    renderedVia: common.software
+  }
 };
 var target = {
   valid: {
     simple: simple5,
-    withFormat,
-    withLanguage,
+    withSourceTitle,
+    withSourceFormat,
+    withSourceLanguage,
     withRendererSoftware,
     complete
   }
@@ -5320,8 +5712,6 @@ var generateValidExamples = async () => {
   console.log(kleur_default.cyan(`Generating Web Annotation Examples`));
   if (!import_fs_extra.default.existsSync(FOLDER))
     import_fs_extra.default.mkdirSync(FOLDER, { recursive: true });
-  await import_fs_extra.default.writeJSON(import_path.default.join(FOLDER, "id_uri.jsonld"), root.valid.id.uri, JSON_OPTIONS);
-  await import_fs_extra.default.writeJSON(import_path.default.join(FOLDER, "id_uuid.jsonld"), root.valid.id.uuid, JSON_OPTIONS);
   await import_fs_extra.default.writeJSON(
     import_path.default.join(FOLDER, "motivation_citing.jsonld"),
     root.valid.motivation.citing,
@@ -5401,13 +5791,18 @@ var generateValidExamples = async () => {
   );
   await import_fs_extra.default.writeJSON(import_path.default.join(FOLDER, "target.jsonld"), target.valid.simple, JSON_OPTIONS);
   await import_fs_extra.default.writeJSON(
-    import_path.default.join(FOLDER, "target_with_format.jsonld"),
-    target.valid.withFormat,
+    import_path.default.join(FOLDER, "target_with_sourceTitle.jsonld"),
+    target.valid.withSourceTitle,
+    JSON_OPTIONS
+  );
+  await import_fs_extra.default.writeJSON(
+    import_path.default.join(FOLDER, "target_with_source_format.jsonld"),
+    target.valid.withSourceFormat,
     JSON_OPTIONS
   );
   await import_fs_extra.default.writeJSON(
-    import_path.default.join(FOLDER, "target_with_language.jsonld"),
-    target.valid.withLanguage,
+    import_path.default.join(FOLDER, "target_with_source_language.jsonld"),
+    target.valid.withSourceLanguage,
     JSON_OPTIONS
   );
   await import_fs_extra.default.writeJSON(
@@ -5415,19 +5810,64 @@ var generateValidExamples = async () => {
     target.valid.withRendererSoftware,
     JSON_OPTIONS
   );
+  await import_fs_extra.default.writeJSON(
+    import_path.default.join(FOLDER, "target_complete.jsonld"),
+    target.valid.complete,
+    JSON_OPTIONS
+  );
   await import_fs_extra.default.writeJSON(
     import_path.default.join(FOLDER, "target_selector_textQuote.jsonld"),
     targetSelector.valid.selector.textQuote.simple,
     JSON_OPTIONS
   );
   await import_fs_extra.default.writeJSON(
-    import_path.default.join(FOLDER, "target_selector_textQuote_refinedBy_xpath_textPosition.jsonld"),
-    targetSelector.valid.selector.textQuote.refinedByXpathAndTextPosition,
+    import_path.default.join(FOLDER, "target_selector_textQuote_refinedBy_textPosition.jsonld"),
+    targetSelector.valid.selector.textQuote.refinedByTextPositon,
+    JSON_OPTIONS
+  );
+  await import_fs_extra.default.writeJSON(
+    import_path.default.join(FOLDER, "target_selector_textQuote_refinedBy_textQuote.jsonld"),
+    targetSelector.valid.selector.textQuote.refinedByTextQuote,
     JSON_OPTIONS
   );
   await import_fs_extra.default.writeJSON(
     import_path.default.join(FOLDER, "target_selector_textPosition.jsonld"),
-    targetSelector.valid.selector.textPositon,
+    targetSelector.valid.selector.textPosition.simple,
+    JSON_OPTIONS
+  );
+  await import_fs_extra.default.writeJSON(
+    import_path.default.join(FOLDER, "target_selector_textPosition_refinedBy_textQuote.jsonld"),
+    targetSelector.valid.selector.textPosition.refinedByTextQuote,
+    JSON_OPTIONS
+  );
+  await import_fs_extra.default.writeJSON(
+    import_path.default.join(FOLDER, "target_selector_textPosition_refinedBy_textPosition.jsonld"),
+    targetSelector.valid.selector.textPosition.refinedByTextPositon,
+    JSON_OPTIONS
+  );
+  await import_fs_extra.default.writeJSON(
+    import_path.default.join(FOLDER, "target_selector_range.jsonld"),
+    targetSelector.valid.selector.range,
+    JSON_OPTIONS
+  );
+  await import_fs_extra.default.writeJSON(
+    import_path.default.join(FOLDER, "target_selector_xpath.jsonld"),
+    targetSelector.valid.selector.xpath.simple,
+    JSON_OPTIONS
+  );
+  await import_fs_extra.default.writeJSON(
+    import_path.default.join(FOLDER, "target_selector_xpath_refinedBt_textPosition.jsonld"),
+    targetSelector.valid.selector.xpath.refinedByTextPositon,
+    JSON_OPTIONS
+  );
+  await import_fs_extra.default.writeJSON(
+    import_path.default.join(FOLDER, "target_selector_xpath_refinedBt_textQuote.jsonld"),
+    targetSelector.valid.selector.xpath.refinedByTextQuote,
+    JSON_OPTIONS
+  );
+  await import_fs_extra.default.writeJSON(
+    import_path.default.join(FOLDER, "target_multiple_selectors_textQuote_and_textPosition.jsonld"),
+    targetSelector.valid.selector.multipleSelector.textQuoteAndTextPosition,
     JSON_OPTIONS
   );
   await import_fs_extra.default.writeJSON(import_path.default.join(FOLDER, "person.jsonld"), person.valid.real, JSON_OPTIONS);
@@ -5483,6 +5923,12 @@ var generateValidExamples = async () => {
     physicalThing.valid.fictional,
     JSON_OPTIONS
   );
+  await import_fs_extra.default.writeJSON(import_path.default.join(FOLDER, "event.jsonld"), event.valid.real, JSON_OPTIONS);
+  await import_fs_extra.default.writeJSON(
+    import_path.default.join(FOLDER, "event_fictional.jsonld"),
+    event.valid.fictional,
+    JSON_OPTIONS
+  );
   await import_fs_extra.default.writeJSON(
     import_path.default.join(FOLDER, "conceptual_object_real.jsonld"),
     conceptualObject.valid.real,
@@ -5567,31 +6013,117 @@ var generateAssets = async () => {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Body,
+  BodyEntityType,
+  Certainty,
+  Citation,
+  CitationEntityType,
+  ConceptualObject,
+  ConceptualObjectEntityType,
+  Correction,
+  CorrectionEntityType,
+  DATE_RANGE_PATTERN,
+  Date,
+  DateEntityType,
+  Description,
+  Event,
+  EventEntityType,
+  Keyword,
+  KeywordEntityType,
+  KeywordFolksnomy,
+  KeywordFolksnomyEntityType,
+  Label,
+  Link,
+  LinkEntityType,
   Motivation,
+  Note,
+  NoteEntityType,
+  Organization,
+  OrganizationEntityType,
   Person,
   PersonEntityType,
+  PhysicalThing,
+  PhysicalThingEntityType,
+  Place,
+  PlaceEntityType,
+  Precision,
+  Quality,
+  RangeSelector,
+  Selector,
   Software,
+  Source,
   Status,
   Target,
+  TextPositionSelector,
+  TextPositionSelectorExtended,
+  TextQuoteSelector,
+  TextQuoteSelectorExtended,
   User,
   VERSION,
   ValidateResult,
   ValidationError,
   WebAnnotation,
+  Work,
+  WorkEntityType,
+  XpathSelector,
+  XpathSelectorExtended,
   ajv,
+  bodyIdDescription,
   bodySchema,
+  certaintySchema,
+  citationEntityTypeSchema,
+  citationSchema,
+  conceptualObjectEntityTypeSchema,
+  conceptualObjectSchema,
   contextUri,
+  correctionEntityTypeSchema,
+  correctionSchema,
   creatorSchema,
+  dateEntityTypeSchema,
+  dateSchema,
   definitionSchema,
   defsId,
+  descriptionSchema,
+  eventEntityTypeSchema,
+  eventSchema,
+  formatSchema,
+  keywordEntityTypeSchema,
+  keywordFolksnomyEntityTypeSchema,
+  keywordFolksnomySchema,
+  keywordSchema,
+  labelSchema,
+  languageSchema,
+  linkEntityTypeSchema,
+  linkSchema,
+  noteEntityTypeSchema,
+  noteSchema,
+  organizationEntityTypeSchema,
+  organizationSchema,
   personEntityTypeSchema,
   personSchema,
+  physicalThingEntityTypeSchema,
+  physicalThingSchema,
+  placeEntityTypeSchema,
+  placeSchema,
+  precisionSchema,
+  rangeSelectorSchema,
   schemaContext,
   schemaId,
+  selectorIdDescription,
+  selectorRefinedByDescription,
+  selectorSchema,
   softwareSchema,
+  sourceSchema,
   targetSchema,
+  textPositionSelectorExtendedSchema,
+  textPositionSelectorSchema,
+  textQuoteSelectorExtendedSchema,
+  textQuoteSelectorSchema,
   v1,
   validate,
   validator,
-  webAnnotationSchema
+  webAnnotationSchema,
+  workEntityTypeSchema,
+  workSchema,
+  xpathSelectorExtendedSchema,
+  xpathSelectorSchema
 });