@elek-io/core 0.6.0 → 0.8.0

package/dist/node/index.node.js

@@ -136,13 +136,13 @@ var baseFileSchema = z2.object({
    */
   id: uuidSchema.readonly(),
   /**
-   * The timestamp of the file being created is set by the service of "objectType" while creating it
+   * The datetime of the file being created is set by the service of "objectType" while creating it
    */
-  created: z2.number().readonly(),
+  created: z2.string().datetime().readonly(),
   /**
-   * The timestamp of the file being updated is set by the service of "objectType" while updating it
+   * The datetime of the file being updated is set by the service of "objectType" while updating it
    */
-  updated: z2.number().nullable()
+  updated: z2.string().datetime().nullable()
 });
 var baseFileWithLanguageSchema = baseFileSchema.extend({
   /**
@@ -219,7 +219,7 @@ var deleteAssetSchema = assetFileSchema.pick({
 var countAssetsSchema = z3.object({ projectId: uuidSchema.readonly() });
 
 // src/schema/collectionSchema.ts
-import z6 from "zod";
+import z7 from "zod";
 
 // src/schema/entrySchema.ts
 import z5 from "zod";
@@ -232,153 +232,6 @@ var ValueTypeSchema = z4.enum([
   "boolean",
   "reference"
 ]);
-var ValueInputTypeSchema = z4.enum([
-  // String
-  "text",
-  "textarea",
-  "email",
-  // 'password', @todo maybe if there is a usecase
-  "url",
-  "ip",
-  "date",
-  "time",
-  "datetime",
-  "telephone",
-  // Number
-  "number",
-  "range",
-  // Boolean
-  "toggle",
-  // Reference
-  "asset",
-  "entry"
-  // 'sharedValue', // @todo
-]);
-var ValueInputWidthSchema = z4.enum(["12", "6", "4", "3"]);
-var ValueDefinitionBaseSchema = z4.object({
-  id: uuidSchema.readonly(),
-  label: translatableStringSchema,
-  description: translatableStringSchema,
-  isRequired: z4.boolean(),
-  isDisabled: z4.boolean(),
-  isUnique: z4.boolean(),
-  inputWidth: ValueInputWidthSchema
-});
-var StringValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend(
-  {
-    valueType: z4.literal(ValueTypeSchema.Enum.string),
-    defaultValue: z4.string().nullable()
-  }
-);
-var textValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
-  {
-    inputType: z4.literal(ValueInputTypeSchema.Enum.text),
-    min: z4.number().nullable(),
-    max: z4.number().nullable()
-  }
-);
-var textareaValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: z4.literal(ValueInputTypeSchema.Enum.textarea),
-  min: z4.number().nullable(),
-  max: z4.number().nullable()
-});
-var emailValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: z4.literal(ValueInputTypeSchema.Enum.email),
-  defaultValue: z4.string().email().nullable()
-});
-var urlValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: z4.literal(ValueInputTypeSchema.Enum.url),
-  defaultValue: z4.string().url().nullable()
-});
-var ipValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: z4.literal(ValueInputTypeSchema.Enum.ip),
-  defaultValue: z4.string().ip().nullable()
-});
-var dateValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
-  {
-    inputType: z4.literal(ValueInputTypeSchema.Enum.date),
-    defaultValue: z4.string().date().nullable()
-  }
-);
-var timeValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
-  {
-    inputType: z4.literal(ValueInputTypeSchema.Enum.time),
-    defaultValue: z4.string().time().nullable()
-  }
-);
-var datetimeValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: z4.literal(ValueInputTypeSchema.Enum.datetime),
-  defaultValue: z4.string().datetime().nullable()
-});
-var telephoneValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: z4.literal(ValueInputTypeSchema.Enum.telephone)
-  // defaultValue: z.string().e164(), @todo when zod v4 releases @see https://github.com/colinhacks/zod/pull/3476
-});
-var stringValueDefinitionSchema = z4.union([
-  textValueDefinitionSchema,
-  textareaValueDefinitionSchema,
-  emailValueDefinitionSchema,
-  urlValueDefinitionSchema,
-  ipValueDefinitionSchema,
-  dateValueDefinitionSchema,
-  timeValueDefinitionSchema,
-  datetimeValueDefinitionSchema,
-  telephoneValueDefinitionSchema
-]);
-var NumberValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend(
-  {
-    valueType: z4.literal(ValueTypeSchema.Enum.number),
-    min: z4.number().nullable(),
-    max: z4.number().nullable(),
-    isUnique: z4.literal(false),
-    defaultValue: z4.number().nullable()
-  }
-);
-var numberValueDefinitionSchema = NumberValueDefinitionBaseSchema.extend({
-  inputType: z4.literal(ValueInputTypeSchema.Enum.number)
-});
-var rangeValueDefinitionSchema = NumberValueDefinitionBaseSchema.extend({
-  inputType: z4.literal(ValueInputTypeSchema.Enum.range),
-  // Overwrite from nullable to required because a range needs min, max and default to work and is required, since it always returns a number
-  isRequired: z4.literal(true),
-  min: z4.number(),
-  max: z4.number(),
-  defaultValue: z4.number()
-});
-var BooleanValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend({
-  valueType: z4.literal(ValueTypeSchema.Enum.boolean),
-  // Overwrite from nullable to required because a boolean needs a default to work and is required, since it always is either true or false
-  isRequired: z4.literal(true),
-  defaultValue: z4.boolean(),
-  isUnique: z4.literal(false)
-});
-var toggleValueDefinitionSchema = BooleanValueDefinitionBaseSchema.extend({
-  inputType: z4.literal(ValueInputTypeSchema.Enum.toggle)
-});
-var ReferenceValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend({
-  valueType: z4.literal(ValueTypeSchema.Enum.reference)
-});
-var assetValueDefinitionSchema = ReferenceValueDefinitionBaseSchema.extend({
-  inputType: z4.literal(ValueInputTypeSchema.Enum.asset),
-  allowedMimeTypes: z4.array(supportedAssetMimeTypeSchema).min(1),
-  min: z4.number().nullable(),
-  max: z4.number().nullable()
-});
-var entryValueDefinitionSchema = ReferenceValueDefinitionBaseSchema.extend({
-  inputType: z4.literal(ValueInputTypeSchema.Enum.entry),
-  ofCollections: z4.array(uuidSchema),
-  min: z4.number().nullable(),
-  max: z4.number().nullable()
-});
-var valueDefinitionSchema = z4.union([
-  stringValueDefinitionSchema,
-  numberValueDefinitionSchema,
-  rangeValueDefinitionSchema,
-  toggleValueDefinitionSchema,
-  assetValueDefinitionSchema,
-  entryValueDefinitionSchema
-  // sharedValueDefinitionSchema,
-]);
 var valueContentReferenceBase = z4.object({
   id: uuidSchema
 });
@@ -408,7 +261,7 @@ var resolvedValueContentReferenceSchema = z4.union([
 ]);
 var directValueBaseSchema = z4.object({
   objectType: z4.literal(objectTypeSchema.Enum.value).readonly(),
-  definitionId: uuidSchema.readonly()
+  fieldDefinitionId: uuidSchema.readonly()
 });
 var directStringValueSchema = directValueBaseSchema.extend({
   valueType: z4.literal(ValueTypeSchema.Enum.string).readonly(),
@@ -429,7 +282,7 @@ var directValueSchema = z4.union([
 ]);
 var referencedValueSchema = z4.object({
   objectType: z4.literal(objectTypeSchema.Enum.value).readonly(),
-  definitionId: uuidSchema.readonly(),
+  fieldDefinitionId: uuidSchema.readonly(),
   valueType: z4.literal(ValueTypeSchema.Enum.reference).readonly(),
   content: translatableArrayOf(valueContentReferenceSchema)
 });
@@ -441,28 +294,216 @@ var resolvedValueSchema = z4.union([
   directValueSchema,
   resolvedReferencedValueSchema
 ]);
-function getValueContentSchemaFromDefinition(definition) {
-  switch (definition.valueType) {
+
+// src/schema/entrySchema.ts
+var entryFileSchema = baseFileSchema.extend({
+  objectType: z5.literal(objectTypeSchema.Enum.entry).readonly(),
+  values: z5.array(valueSchema)
+});
+var entrySchema = entryFileSchema.extend({
+  values: z5.array(z5.lazy(() => resolvedValueSchema))
+});
+var entryExportSchema = entrySchema.extend({});
+var createEntrySchema = entryFileSchema.omit({
+  id: true,
+  objectType: true,
+  created: true,
+  updated: true
+}).extend({
+  projectId: uuidSchema.readonly(),
+  collectionId: uuidSchema.readonly(),
+  values: z5.array(valueSchema)
+});
+var readEntrySchema = z5.object({
+  id: uuidSchema.readonly(),
+  projectId: uuidSchema.readonly(),
+  collectionId: uuidSchema.readonly()
+});
+var updateEntrySchema = entrySchema.omit({
+  objectType: true,
+  created: true,
+  updated: true
+}).extend({
+  projectId: uuidSchema.readonly(),
+  collectionId: uuidSchema.readonly()
+});
+var deleteEntrySchema = readEntrySchema.extend({});
+var countEntriesSchema = z5.object({
+  projectId: uuidSchema.readonly(),
+  collectionId: uuidSchema.readonly()
+});
+
+// src/schema/fieldSchema.ts
+import { z as z6 } from "zod";
+var FieldTypeSchema = z6.enum([
+  // String Values
+  "text",
+  "textarea",
+  "email",
+  // 'password', @todo maybe if there is a usecase
+  "url",
+  "ip",
+  "date",
+  "time",
+  "datetime",
+  "telephone",
+  // Number Values
+  "number",
+  "range",
+  // Boolean Values
+  "toggle",
+  // Reference Values
+  "asset",
+  "entry"
+  // 'sharedValue', // @todo
+]);
+var FieldWidthSchema = z6.enum(["12", "6", "4", "3"]);
+var FieldDefinitionBaseSchema = z6.object({
+  id: uuidSchema.readonly(),
+  label: translatableStringSchema,
+  description: translatableStringSchema,
+  isRequired: z6.boolean(),
+  isDisabled: z6.boolean(),
+  isUnique: z6.boolean(),
+  inputWidth: FieldWidthSchema
+});
+var StringFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend(
+  {
+    valueType: z6.literal(ValueTypeSchema.Enum.string),
+    defaultValue: z6.string().nullable()
+  }
+);
+var textFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend(
+  {
+    fieldType: z6.literal(FieldTypeSchema.Enum.text),
+    min: z6.number().nullable(),
+    max: z6.number().nullable()
+  }
+);
+var textareaFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
+  fieldType: z6.literal(FieldTypeSchema.Enum.textarea),
+  min: z6.number().nullable(),
+  max: z6.number().nullable()
+});
+var emailFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
+  fieldType: z6.literal(FieldTypeSchema.Enum.email),
+  defaultValue: z6.string().email().nullable()
+});
+var urlFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
+  fieldType: z6.literal(FieldTypeSchema.Enum.url),
+  defaultValue: z6.string().url().nullable()
+});
+var ipFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
+  fieldType: z6.literal(FieldTypeSchema.Enum.ip),
+  defaultValue: z6.string().ip().nullable()
+});
+var dateFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend(
+  {
+    fieldType: z6.literal(FieldTypeSchema.Enum.date),
+    defaultValue: z6.string().date().nullable()
+  }
+);
+var timeFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend(
+  {
+    fieldType: z6.literal(FieldTypeSchema.Enum.time),
+    defaultValue: z6.string().time().nullable()
+  }
+);
+var datetimeFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
+  fieldType: z6.literal(FieldTypeSchema.Enum.datetime),
+  defaultValue: z6.string().datetime().nullable()
+});
+var telephoneFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
+  fieldType: z6.literal(FieldTypeSchema.Enum.telephone)
+  // defaultValue: z.string().e164(), @todo when zod v4 releases @see https://github.com/colinhacks/zod/pull/3476
+});
+var stringFieldDefinitionSchema = z6.union([
+  textFieldDefinitionSchema,
+  textareaFieldDefinitionSchema,
+  emailFieldDefinitionSchema,
+  urlFieldDefinitionSchema,
+  ipFieldDefinitionSchema,
+  dateFieldDefinitionSchema,
+  timeFieldDefinitionSchema,
+  datetimeFieldDefinitionSchema,
+  telephoneFieldDefinitionSchema
+]);
+var NumberFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend(
+  {
+    valueType: z6.literal(ValueTypeSchema.Enum.number),
+    min: z6.number().nullable(),
+    max: z6.number().nullable(),
+    isUnique: z6.literal(false),
+    defaultValue: z6.number().nullable()
+  }
+);
+var numberFieldDefinitionSchema = NumberFieldDefinitionBaseSchema.extend({
+  fieldType: z6.literal(FieldTypeSchema.Enum.number)
+});
+var rangeFieldDefinitionSchema = NumberFieldDefinitionBaseSchema.extend({
+  fieldType: z6.literal(FieldTypeSchema.Enum.range),
+  // Overwrite from nullable to required because a range needs min, max and default to work and is required, since it always returns a number
+  isRequired: z6.literal(true),
+  min: z6.number(),
+  max: z6.number(),
+  defaultValue: z6.number()
+});
+var BooleanFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({
+  valueType: z6.literal(ValueTypeSchema.Enum.boolean),
+  // Overwrite from nullable to required because a boolean needs a default to work and is required, since it always is either true or false
+  isRequired: z6.literal(true),
+  defaultValue: z6.boolean(),
+  isUnique: z6.literal(false)
+});
+var toggleFieldDefinitionSchema = BooleanFieldDefinitionBaseSchema.extend({
+  fieldType: z6.literal(FieldTypeSchema.Enum.toggle)
+});
+var ReferenceFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({
+  valueType: z6.literal(ValueTypeSchema.Enum.reference)
+});
+var assetFieldDefinitionSchema = ReferenceFieldDefinitionBaseSchema.extend({
+  fieldType: z6.literal(FieldTypeSchema.Enum.asset),
+  allowedMimeTypes: z6.array(supportedAssetMimeTypeSchema).min(1),
+  min: z6.number().nullable(),
+  max: z6.number().nullable()
+});
+var entryFieldDefinitionSchema = ReferenceFieldDefinitionBaseSchema.extend({
+  fieldType: z6.literal(FieldTypeSchema.Enum.entry),
+  ofCollections: z6.array(uuidSchema),
+  min: z6.number().nullable(),
+  max: z6.number().nullable()
+});
+var fieldDefinitionSchema = z6.union([
+  stringFieldDefinitionSchema,
+  numberFieldDefinitionSchema,
+  rangeFieldDefinitionSchema,
+  toggleFieldDefinitionSchema,
+  assetFieldDefinitionSchema,
+  entryFieldDefinitionSchema
+  // sharedValueDefinitionSchema,
+]);
+function getValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  switch (fieldDefinition.valueType) {
     case ValueTypeSchema.Enum.boolean:
       return getBooleanValueContentSchema();
     case ValueTypeSchema.Enum.number:
-      return getNumberValueContentSchema(definition);
+      return getNumberValueContentSchema(fieldDefinition);
     case ValueTypeSchema.Enum.string:
-      return getStringValueContentSchema(definition);
+      return getStringValueContentSchema(fieldDefinition);
     case ValueTypeSchema.Enum.reference:
-      return getReferenceValueContentSchema(definition);
+      return getReferenceValueContentSchema(fieldDefinition);
     default:
       throw new Error(
         // @ts-expect-error
-        `Error generating schema for unsupported ValueType "${definition.valueType}"`
+        `Error generating schema for unsupported ValueType "${fieldDefinition.valueType}"`
       );
   }
 }
 function getBooleanValueContentSchema() {
-  return z4.boolean();
+  return z6.boolean();
 }
 function getNumberValueContentSchema(definition) {
-  let schema = z4.number();
+  let schema = z6.number();
   if (definition.min) {
     schema = schema.min(definition.min);
   }
@@ -475,33 +516,33 @@ function getNumberValueContentSchema(definition) {
   return schema;
 }
 function getStringValueContentSchema(definition) {
-  let schema = z4.string().trim();
+  let schema = z6.string().trim();
   if ("min" in definition && definition.min) {
     schema = schema.min(definition.min);
   }
   if ("max" in definition && definition.max) {
     schema = schema.max(definition.max);
   }
-  switch (definition.inputType) {
-    case ValueInputTypeSchema.Enum.email:
+  switch (definition.fieldType) {
+    case FieldTypeSchema.Enum.email:
       schema = schema.email();
       break;
-    case ValueInputTypeSchema.Enum.url:
+    case FieldTypeSchema.Enum.url:
       schema = schema.url();
       break;
-    case ValueInputTypeSchema.Enum.ip:
+    case FieldTypeSchema.Enum.ip:
       schema = schema.ip();
       break;
-    case ValueInputTypeSchema.Enum.date:
+    case FieldTypeSchema.Enum.date:
       schema = schema.date();
       break;
-    case ValueInputTypeSchema.Enum.time:
+    case FieldTypeSchema.Enum.time:
       schema = schema.time();
       break;
-    case ValueInputTypeSchema.Enum.datetime:
+    case FieldTypeSchema.Enum.datetime:
       schema = schema.datetime();
       break;
-    case ValueInputTypeSchema.Enum.telephone:
+    case FieldTypeSchema.Enum.telephone:
       break;
   }
   if (definition.isRequired === false) {
@@ -511,15 +552,15 @@ function getStringValueContentSchema(definition) {
 }
 function getReferenceValueContentSchema(definition) {
   let schema;
-  switch (definition.inputType) {
-    case ValueInputTypeSchema.Enum.asset:
+  switch (definition.fieldType) {
+    case FieldTypeSchema.Enum.asset:
       {
-        schema = z4.array(valueContentReferenceToAssetSchema);
+        schema = z6.array(valueContentReferenceToAssetSchema);
       }
       break;
-    case ValueInputTypeSchema.Enum.entry:
+    case FieldTypeSchema.Enum.entry:
       {
-        schema = z4.array(valueContentReferenceToEntrySchema);
+        schema = z6.array(valueContentReferenceToEntrySchema);
       }
       break;
   }
@@ -535,62 +576,24 @@ function getReferenceValueContentSchema(definition) {
   return schema;
 }
 
-// src/schema/entrySchema.ts
-var entryFileSchema = baseFileSchema.extend({
-  objectType: z5.literal(objectTypeSchema.Enum.entry).readonly(),
-  values: z5.array(valueSchema)
-});
-var entrySchema = entryFileSchema.extend({
-  values: z5.array(z5.lazy(() => resolvedValueSchema))
-});
-var entryExportSchema = entrySchema.extend({});
-var createEntrySchema = entryFileSchema.omit({
-  id: true,
-  objectType: true,
-  created: true,
-  updated: true
-}).extend({
-  projectId: uuidSchema.readonly(),
-  collectionId: uuidSchema.readonly(),
-  values: z5.array(valueSchema)
-});
-var readEntrySchema = z5.object({
-  id: uuidSchema.readonly(),
-  projectId: uuidSchema.readonly(),
-  collectionId: uuidSchema.readonly()
-});
-var updateEntrySchema = entrySchema.omit({
-  objectType: true,
-  created: true,
-  updated: true
-}).extend({
-  projectId: uuidSchema.readonly(),
-  collectionId: uuidSchema.readonly()
-});
-var deleteEntrySchema = readEntrySchema.extend({});
-var countEntriesSchema = z5.object({
-  projectId: uuidSchema.readonly(),
-  collectionId: uuidSchema.readonly()
-});
-
 // src/schema/collectionSchema.ts
 var collectionFileSchema = baseFileSchema.extend({
-  objectType: z6.literal(objectTypeSchema.Enum.collection).readonly(),
-  name: z6.object({
+  objectType: z7.literal(objectTypeSchema.Enum.collection).readonly(),
+  name: z7.object({
     singular: translatableStringSchema,
     plural: translatableStringSchema
   }),
-  slug: z6.object({
-    singular: z6.string(),
-    plural: z6.string()
+  slug: z7.object({
+    singular: z7.string(),
+    plural: z7.string()
   }),
   description: translatableStringSchema,
   icon: supportedIconSchema,
-  valueDefinitions: z6.array(valueDefinitionSchema)
+  fieldDefinitions: z7.array(fieldDefinitionSchema)
 });
 var collectionSchema = collectionFileSchema.extend({});
 var collectionExportSchema = collectionSchema.extend({
-  entries: z6.array(entryExportSchema)
+  entries: z7.array(entryExportSchema)
 });
 var createCollectionSchema = collectionSchema.omit({
   id: true,
@@ -600,7 +603,7 @@ var createCollectionSchema = collectionSchema.omit({
 }).extend({
   projectId: uuidSchema.readonly()
 });
-var readCollectionSchema = z6.object({
+var readCollectionSchema = z7.object({
   id: uuidSchema.readonly(),
   projectId: uuidSchema.readonly()
 });
@@ -610,18 +613,18 @@ var updateCollectionSchema = collectionFileSchema.pick({
   slug: true,
   description: true,
   icon: true,
-  valueDefinitions: true
+  fieldDefinitions: true
 }).extend({
   projectId: uuidSchema.readonly()
 });
 var deleteCollectionSchema = readCollectionSchema.extend({});
-var countCollectionsSchema = z6.object({
+var countCollectionsSchema = z7.object({
   projectId: uuidSchema.readonly()
 });
 
 // src/schema/coreSchema.ts
-import { z as z7 } from "zod";
-var elekIoCoreOptionsSchema = z7.object({
+import { z as z8 } from "zod";
+var elekIoCoreOptionsSchema = z8.object({
   /**
    * The environment elek.io Core is currently running in
    */
@@ -630,14 +633,14 @@ var elekIoCoreOptionsSchema = z7.object({
    * The current version of elek.io Core
    */
   version: versionSchema,
-  file: z7.object({
-    json: z7.object({
+  file: z8.object({
+    json: z8.object({
       /**
        * If set, adds indentation with spaces (number) or escape character (string)
        * and line break characters to saved JSON files on disk, to make them easier to read.
        * Defaults to 2 spaces of indentation.
        */
-      indentation: z7.union([z7.number(), z7.string()])
+      indentation: z8.union([z8.number(), z8.string()])
     })
   })
 });
@@ -649,21 +652,21 @@ var constructorElekIoCoreSchema = elekIoCoreOptionsSchema.omit({
 }).optional();
 
 // src/schema/gitSchema.ts
-import { z as z8 } from "zod";
-var gitRepositoryPathSchema = z8.string();
-var gitSignatureSchema = z8.object({
-  name: z8.string(),
-  email: z8.string()
+import { z as z9 } from "zod";
+var gitRepositoryPathSchema = z9.string();
+var gitSignatureSchema = z9.object({
+  name: z9.string(),
+  email: z9.string()
 });
-var gitCommitSchema = z8.object({
+var gitCommitSchema = z9.object({
   /**
    * SHA-1 hash of the commit
    */
-  hash: z8.string(),
-  message: z8.string(),
+  hash: z9.string(),
+  message: z9.string(),
   author: gitSignatureSchema,
-  timestamp: z8.number(),
-  tag: z8.string().nullable()
+  datetime: z9.string().datetime(),
+  tag: z9.string().nullable()
 });
 var GitCommitIconNative = /* @__PURE__ */ ((GitCommitIconNative2) => {
   GitCommitIconNative2["INIT"] = ":tada:";
@@ -672,66 +675,66 @@ var GitCommitIconNative = /* @__PURE__ */ ((GitCommitIconNative2) => {
   GitCommitIconNative2["DELETE"] = ":fire:";
   return GitCommitIconNative2;
 })(GitCommitIconNative || {});
-var gitCommitIconSchema = z8.nativeEnum(GitCommitIconNative);
-var gitInitOptionsSchema = z8.object({
+var gitCommitIconSchema = z9.nativeEnum(GitCommitIconNative);
+var gitInitOptionsSchema = z9.object({
   /**
    * Use the specified name for the initial branch in the newly created repository. If not specified, fall back to the default name (currently master, but this is subject to change in the future; the name can be customized via the init.defaultBranch configuration variable).
    */
-  initialBranch: z8.string()
+  initialBranch: z9.string()
 });
-var gitCloneOptionsSchema = z8.object({
+var gitCloneOptionsSchema = z9.object({
   /**
    * Create a shallow clone with a history truncated to the specified number of commits. Implies --single-branch unless --no-single-branch is given to fetch the histories near the tips of all branches. If you want to clone submodules shallowly, also pass --shallow-submodules.
    */
-  depth: z8.number(),
+  depth: z9.number(),
   /**
    * Clone only the history leading to the tip of a single branch, either specified by the --branch option or the primary branch remote’s HEAD points at. Further fetches into the resulting repository will only update the remote-tracking branch for the branch this option was used for the initial cloning. If the HEAD at the remote did not point at any branch when --single-branch clone was made, no remote-tracking branch is created.
    */
-  singleBranch: z8.boolean(),
+  singleBranch: z9.boolean(),
   /**
    * Instead of pointing the newly created HEAD to the branch pointed to by the cloned repository’s HEAD, point to <name> branch instead. In a non-bare repository, this is the branch that will be checked out. --branch can also take tags and detaches the HEAD at that commit in the resulting repository.
    */
-  branch: z8.string()
+  branch: z9.string()
 });
-var gitSwitchOptionsSchema = z8.object({
+var gitSwitchOptionsSchema = z9.object({
   /**
    * If true, creates a new local branch and then switches to it
    *
    * @see https://git-scm.com/docs/git-switch#Documentation/git-switch.txt---createltnew-branchgt
    */
-  isNew: z8.boolean().optional()
+  isNew: z9.boolean().optional()
 });
-var gitLogOptionsSchema = z8.object({
+var gitLogOptionsSchema = z9.object({
   /**
    * Limit the result to given number of commits
    */
-  limit: z8.number().optional(),
+  limit: z9.number().optional(),
   /**
    * Only list commits that are between given SHAs or tag names
    *
    * Note that the commits of from and to are not included in the result
    */
-  between: z8.object({
+  between: z9.object({
     /**
      * From the oldest commit
      */
-    from: z8.string(),
+    from: z9.string(),
     /**
      * To the newest commit
      *
      * Defaults to the current HEAD
      */
-    to: z8.string().optional()
+    to: z9.string().optional()
   })
 });
 
 // src/schema/gitTagSchema.ts
-import { z as z9 } from "zod";
-var gitTagSchema = z9.object({
+import { z as z10 } from "zod";
+var gitTagSchema = z10.object({
   id: uuidSchema,
-  message: z9.string(),
+  message: z10.string(),
   author: gitSignatureSchema,
-  timestamp: z9.number()
+  datetime: z10.string().datetime()
 });
 var createGitTagSchema = gitTagSchema.pick({
   message: true
@@ -739,25 +742,25 @@ var createGitTagSchema = gitTagSchema.pick({
   path: gitRepositoryPathSchema,
   hash: gitCommitSchema.shape.hash.optional()
 });
-var readGitTagSchema = z9.object({
+var readGitTagSchema = z10.object({
   path: gitRepositoryPathSchema,
   id: uuidSchema.readonly()
 });
 var deleteGitTagSchema = readGitTagSchema.extend({});
-var countGitTagsSchema = z9.object({
+var countGitTagsSchema = z10.object({
   path: gitRepositoryPathSchema
 });
 
 // src/schema/projectSchema.ts
-import { z as z10 } from "zod";
-var projectStatusSchema = z10.enum(["foo", "bar", "todo"]);
-var projectSettingsSchema = z10.object({
-  language: z10.object({
+import { z as z11 } from "zod";
+var projectStatusSchema = z11.enum(["foo", "bar", "todo"]);
+var projectSettingsSchema = z11.object({
+  language: z11.object({
     default: supportedLanguageSchema,
-    supported: z10.array(supportedLanguageSchema)
+    supported: z11.array(supportedLanguageSchema)
   })
 });
-var projectFolderSchema = z10.enum([
+var projectFolderSchema = z11.enum([
   "assets",
   "collections",
   "shared-values",
@@ -767,18 +770,18 @@ var projectFolderSchema = z10.enum([
   // 'theme',
 ]);
 var projectFileSchema = baseFileSchema.extend({
-  objectType: z10.literal(objectTypeSchema.Enum.project).readonly(),
+  objectType: z11.literal(objectTypeSchema.Enum.project).readonly(),
   coreVersion: versionSchema,
-  name: z10.string().trim().min(1, "shared.projectNameRequired"),
-  description: z10.string().trim().min(1, "shared.projectDescriptionRequired"),
+  name: z11.string().trim().min(1, "shared.projectNameRequired"),
+  description: z11.string().trim().min(1, "shared.projectDescriptionRequired"),
   version: versionSchema,
   status: projectStatusSchema,
   settings: projectSettingsSchema
 });
 var projectSchema = projectFileSchema.extend({});
 var projectExportSchema = projectSchema.extend({
-  assets: z10.array(assetExportSchema),
-  collections: z10.array(collectionExportSchema)
+  assets: z11.array(assetExportSchema),
+  collections: z11.array(collectionExportSchema)
 });
 var createProjectSchema = projectSchema.pick({
   name: true,
@@ -788,7 +791,7 @@ var createProjectSchema = projectSchema.pick({
   description: true,
   settings: true
 });
-var readProjectSchema = z10.object({
+var readProjectSchema = z11.object({
   id: uuidSchema.readonly()
 });
 var updateProjectSchema = projectSchema.pick({
@@ -801,11 +804,11 @@ var updateProjectSchema = projectSchema.pick({
   description: true,
   settings: true
 });
-var upgradeProjectSchema = z10.object({
+var upgradeProjectSchema = z11.object({
   id: uuidSchema.readonly()
 });
 var deleteProjectSchema = readProjectSchema.extend({});
-var projectUpgradeSchema = z10.object({
+var projectUpgradeSchema = z11.object({
   /**
    * The Core version the Project will be upgraded to
    */
@@ -813,45 +816,45 @@ var projectUpgradeSchema = z10.object({
   /**
    * Function that will be executed in the process of upgrading a Project
    */
-  run: z10.function().args(projectFileSchema).returns(z10.promise(z10.void()))
+  run: z11.function().args(projectFileSchema).returns(z11.promise(z11.void()))
 });
-var cloneProjectSchema = z10.object({
-  url: z10.string()
+var cloneProjectSchema = z11.object({
+  url: z11.string()
 });
-var listBranchesProjectSchema = z10.object({
+var listBranchesProjectSchema = z11.object({
   id: uuidSchema.readonly()
 });
-var currentBranchProjectSchema = z10.object({
+var currentBranchProjectSchema = z11.object({
   id: uuidSchema.readonly()
 });
-var switchBranchProjectSchema = z10.object({
+var switchBranchProjectSchema = z11.object({
   id: uuidSchema.readonly(),
-  branch: z10.string(),
+  branch: z11.string(),
   options: gitSwitchOptionsSchema.optional()
 });
-var getRemoteOriginUrlProjectSchema = z10.object({
+var getRemoteOriginUrlProjectSchema = z11.object({
   id: uuidSchema.readonly()
 });
-var setRemoteOriginUrlProjectSchema = z10.object({
+var setRemoteOriginUrlProjectSchema = z11.object({
   id: uuidSchema.readonly(),
-  url: z10.string()
+  url: z11.string()
 });
-var getChangesProjectSchema = z10.object({
+var getChangesProjectSchema = z11.object({
   id: uuidSchema.readonly()
 });
-var synchronizeProjectSchema = z10.object({
+var synchronizeProjectSchema = z11.object({
   id: uuidSchema.readonly()
 });
-var searchProjectSchema = z10.object({
+var searchProjectSchema = z11.object({
   id: uuidSchema.readonly(),
-  query: z10.string(),
+  query: z11.string(),
   language: supportedLanguageSchema,
-  type: z10.array(objectTypeSchema).optional()
+  type: z11.array(objectTypeSchema).optional()
 });
 
 // src/schema/serviceSchema.ts
-import { z as z11 } from "zod";
-var serviceTypeSchema = z11.enum([
+import { z as z12 } from "zod";
+var serviceTypeSchema = z12.enum([
   "Git",
   "GitTag",
   "User",
@@ -863,10 +866,10 @@ var serviceTypeSchema = z11.enum([
   "Entry",
   "Value"
 ]);
-var listSchema = z11.object({
+var listSchema = z12.object({
   projectId: uuidSchema,
-  limit: z11.number().optional(),
-  offset: z11.number().optional()
+  limit: z12.number().optional(),
+  offset: z12.number().optional()
 });
 var listCollectionsSchema = listSchema;
 var listEntriesSchema = listSchema.extend({
@@ -876,25 +879,25 @@ var listAssetsSchema = listSchema;
 var listProjectsSchema = listSchema.omit({
   projectId: true
 });
-var listGitTagsSchema = z11.object({
+var listGitTagsSchema = z12.object({
   path: gitRepositoryPathSchema
 });
 
 // src/schema/userSchema.ts
-import z12 from "zod";
-var UserTypeSchema = z12.enum(["local", "cloud"]);
+import z13 from "zod";
+var UserTypeSchema = z13.enum(["local", "cloud"]);
 var baseUserSchema = gitSignatureSchema.extend({
   userType: UserTypeSchema,
   language: supportedLanguageSchema
 });
 var localUserSchema = baseUserSchema.extend({
-  userType: z12.literal(UserTypeSchema.Enum.local)
+  userType: z13.literal(UserTypeSchema.Enum.local)
 });
 var cloudUserSchema = baseUserSchema.extend({
-  userType: z12.literal(UserTypeSchema.Enum.cloud),
+  userType: z13.literal(UserTypeSchema.Enum.cloud),
   id: uuidSchema
 });
-var userFileSchema = z12.union([localUserSchema, cloudUserSchema]);
+var userFileSchema = z13.union([localUserSchema, cloudUserSchema]);
 var userSchema = userFileSchema;
 var setUserSchema = userSchema;
 
@@ -1188,24 +1191,22 @@ import Fs2 from "fs-extra";
 import isSvg from "is-svg";
 
 // src/util/shared.ts
-import slugify from "slugify";
+import slugify from "@sindresorhus/slugify";
 import { v4 as generateUuid } from "uuid";
-var Slugify = slugify.default || slugify;
 function uuid() {
   return generateUuid();
 }
-function currentTimestamp() {
-  return Math.floor(Date.now() / 1e3);
+function datetime(value) {
+  if (!value) {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  return new Date(value).toISOString();
 }
 function slug(string) {
-  return Slugify(string, {
-    replacement: "-",
-    // replace spaces with replacement character, defaults to `-`
-    // remove: undefined, // remove characters that match regex, defaults to `undefined`
-    lower: true,
-    // convert to lower case, defaults to `false`
-    strict: true
-    // strip special characters except replacement, defaults to `false`
+  return slugify(string, {
+    separator: "-",
+    lowercase: true,
+    decamelize: true
   });
 }
 
@@ -1238,7 +1239,7 @@ var AssetService = class extends AbstractCrudService {
       ...props,
       objectType: "asset",
       id,
-      created: currentTimestamp(),
+      created: datetime(),
       updated: null,
       extension: fileType.extension,
       mimeType: fileType.mimeType,
@@ -1287,7 +1288,7 @@ var AssetService = class extends AbstractCrudService {
     const assetFile = {
       ...prevAssetFile,
       ...props,
-      updated: currentTimestamp()
+      updated: datetime()
     };
     if (props.newFilePath) {
       const fileType = await this.getSupportedFileTypeOrThrow(
@@ -1462,7 +1463,7 @@ var CollectionService = class extends AbstractCrudService {
         singular: slug(props.slug.singular),
         plural: slug(props.slug.plural)
       },
-      created: currentTimestamp(),
+      created: datetime(),
       updated: null
     };
     await Fs3.ensureDir(collectionPath);
@@ -1504,7 +1505,7 @@ var CollectionService = class extends AbstractCrudService {
     const collectionFile = {
       ...prevCollectionFile,
       ...props,
-      updated: currentTimestamp()
+      updated: datetime()
     };
     await this.jsonFileService.update(
       collectionFile,
@@ -1606,7 +1607,7 @@ var EntryService = class extends AbstractCrudService {
       objectType: "entry",
       id,
       values: props.values,
-      created: currentTimestamp(),
+      created: datetime(),
       updated: null
     };
     const entry = await this.toEntry({
@@ -1616,7 +1617,7 @@ var EntryService = class extends AbstractCrudService {
     });
     this.validateValues({
       collectionId: props.collectionId,
-      valueDefinitions: collection.valueDefinitions,
+      fieldDefinitions: collection.fieldDefinitions,
       values: entry.values
     });
     await this.jsonFileService.create(
@@ -1666,7 +1667,7 @@ var EntryService = class extends AbstractCrudService {
     const entryFile = {
       ...prevEntryFile,
       values: props.values,
-      updated: currentTimestamp()
+      updated: datetime()
     };
     const entry = await this.toEntry({
       projectId: props.projectId,
@@ -1675,7 +1676,7 @@ var EntryService = class extends AbstractCrudService {
     });
     this.validateValues({
       collectionId: props.collectionId,
-      valueDefinitions: collection.valueDefinitions,
+      fieldDefinitions: collection.fieldDefinitions,
       values: entry.values
     });
     await this.jsonFileService.update(
@@ -1743,39 +1744,39 @@ var EntryService = class extends AbstractCrudService {
     return entrySchema.safeParse(obj).success;
   }
   /**
-   * Returns a Value definition by ID
+   * Returns a Field definition by ID
    */
-  getValueDefinitionById(props) {
-    const definition = props.valueDefinitions.find((def) => {
-      if (def.id === props.id) {
+  getFieldDefinitionById(props) {
+    const fieldDefinition = props.fieldDefinitions.find((definition) => {
+      if (definition.id === props.id) {
         return true;
       }
       return false;
     });
-    if (!definition) {
+    if (!fieldDefinition) {
       throw new Error(
-        `No definition with ID "${props.id}" found in Collection "${props.collectionId}" for given Value reference`
+        `No Field definition with ID "${props.id}" found in Collection "${props.collectionId}" for given Value reference`
       );
     }
-    return definition;
+    return fieldDefinition;
   }
   /**
-   * Validates given Values against it's Collections definitions
+   * Validates given Values against their Collections Field definitions
    */
   validateValues(props) {
     props.values.map((value) => {
-      const definition = this.getValueDefinitionById({
+      const fieldDefinition = this.getFieldDefinitionById({
         collectionId: props.collectionId,
-        valueDefinitions: props.valueDefinitions,
-        id: value.definitionId
+        fieldDefinitions: props.fieldDefinitions,
+        id: value.fieldDefinitionId
       });
-      const schema = getValueContentSchemaFromDefinition(definition);
+      const contentSchema = getValueContentSchemaFromFieldDefinition(fieldDefinition);
       try {
-        for (const [, content] of Object.entries(value.content)) {
-          schema.parse(content);
+        for (const [_language, content] of Object.entries(value.content)) {
+          contentSchema.parse(content);
         }
       } catch (error) {
-        console.log("Definition:", definition);
+        console.log("Definition:", fieldDefinition);
         console.log("Value:", value);
         throw error;
       }
@@ -1947,7 +1948,7 @@ var GitTagService = class extends AbstractCrudService {
   /**
    * Gets all local tags or filter them by pattern
    *
-   * They are sorted by authordate of the commit, not the timestamp the tag is created.
+   * They are sorted by authordate of the commit, not when the tag is created.
    * This ensures tags are sorted correctly in the timeline of their commits.
    *
    * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---list
@@ -1958,7 +1959,7 @@ var GitTagService = class extends AbstractCrudService {
     args = [
       ...args,
       "--sort=-*authordate",
-      "--format=%(refname:short)|%(subject)|%(*authorname)|%(*authoremail)|%(*authordate:unix)"
+      "--format=%(refname:short)|%(subject)|%(*authorname)|%(*authoremail)|%(*authordate:iso-strict)"
     ];
     const result = await this.git(props.path, args);
     const noEmptyLinesArr = result.stdout.split(EOL).filter((line) => {
@@ -1973,7 +1974,7 @@ var GitTagService = class extends AbstractCrudService {
           name: lineArray[2],
           email: lineArray[3]
         },
-        timestamp: parseInt(lineArray[4] || "")
+        datetime: datetime(lineArray[4])
       };
     });
     const gitTags = lineObjArr.filter(this.isGitTag.bind(this));
@@ -2337,7 +2338,7 @@ var GitService = class {
     }
     const result = await this.git(path, [
       ...args,
-      "--format=%H|%s|%an|%ae|%at|%D"
+      "--format=%H|%s|%an|%ae|%aI|%D"
     ]);
     const noEmptyLinesArr = result.stdout.split(EOL2).filter((line) => {
       return line.trim() !== "";
@@ -2351,7 +2352,7 @@ var GitService = class {
           name: lineArray[2],
           email: lineArray[3]
         },
-        timestamp: parseInt(lineArray[4] || ""),
+        datetime: datetime(lineArray[4]),
         tag: this.refNameToTagName(lineArray[5] || "")
       };
     });
@@ -2364,62 +2365,6 @@ var GitService = class {
     }
     return tagName;
   }
-  /**
-   * Returns a timestamp of given files creation
-   *
-   * Git only returns the timestamp the file was added,
-   * which could be different from the file being created.
-   * But since file operations will always be committed
-   * immediately, this is practically the same.
-   *
-   * @param path Path to the repository
-   * @param file File to get timestamp from
-   */
-  async getFileCreatedTimestamp(path, file) {
-    const result = await this.git(path, [
-      "log",
-      "--diff-filter=A",
-      "--follow",
-      "--format=%at",
-      "--max-count=1",
-      "--",
-      file
-    ]);
-    return parseInt(result.stdout);
-  }
-  /**
-   * Returns a timestamp of the files last modification
-   *
-   * @param path Path to the repository
-   * @param file File to get timestamp from
-   */
-  async getFileLastUpdatedTimestamp(path, file) {
-    const result = await this.git(path, [
-      "log",
-      "--follow",
-      "--format=%at",
-      "--max-count=1",
-      "--",
-      file
-    ]);
-    return parseInt(result.stdout);
-  }
-  /**
-   * Returns created and updated timestamps from given file
-   *
-   * @param path Path to the project
-   * @param file Path to the file
-   */
-  async getFileCreatedUpdatedMeta(path, file) {
-    const meta = await Promise.all([
-      this.getFileCreatedTimestamp(path, file),
-      this.getFileLastUpdatedTimestamp(path, file)
-    ]);
-    return {
-      created: meta[0],
-      updated: meta[1]
-    };
-  }
   /**
    * Reads the currently used version of Git
    *
@@ -2643,7 +2588,7 @@ var ProjectService = class extends AbstractCrudService {
       id,
       description: props.description || "",
       settings: Object.assign({}, defaultSettings, props.settings),
-      created: currentTimestamp(),
+      created: datetime(),
       updated: null,
       coreVersion: this.options.version,
       // @todo should be read from package.json to avoid duplicates
@@ -2735,7 +2680,7 @@ var ProjectService = class extends AbstractCrudService {
           default: props.settings?.language.default || prevProjectFile.settings.language.default
         }
       },
-      updated: currentTimestamp()
+      updated: datetime()
     };
     await this.jsonFileService.update(projectFile, filePath, projectFileSchema);
     await this.gitService.add(projectPath, [filePath]);
@@ -3150,19 +3095,19 @@ var ElekIoCore = class {
   // }
 };
 export {
-  BooleanValueDefinitionBaseSchema,
-  NumberValueDefinitionBaseSchema,
-  ReferenceValueDefinitionBaseSchema,
-  StringValueDefinitionBaseSchema,
+  BooleanFieldDefinitionBaseSchema,
+  FieldDefinitionBaseSchema,
+  FieldTypeSchema,
+  FieldWidthSchema,
+  NumberFieldDefinitionBaseSchema,
+  ReferenceFieldDefinitionBaseSchema,
+  StringFieldDefinitionBaseSchema,
   UserTypeSchema,
-  ValueDefinitionBaseSchema,
-  ValueInputTypeSchema,
-  ValueInputWidthSchema,
   ValueTypeSchema,
   assetExportSchema,
+  assetFieldDefinitionSchema,
   assetFileSchema,
   assetSchema,
-  assetValueDefinitionSchema,
   baseFileSchema,
   baseFileWithLanguageSchema,
   baseUserSchema,
@@ -3182,9 +3127,9 @@ export {
   createGitTagSchema,
   createProjectSchema,
   currentBranchProjectSchema,
-  currentTimestamp,
-  dateValueDefinitionSchema,
-  datetimeValueDefinitionSchema,
+  dateFieldDefinitionSchema,
+  datetime,
+  datetimeFieldDefinitionSchema,
   ElekIoCore as default,
   deleteAssetSchema,
   deleteCollectionSchema,
@@ -3197,16 +3142,17 @@ export {
   directValueBaseSchema,
   directValueSchema,
   elekIoCoreOptionsSchema,
-  emailValueDefinitionSchema,
+  emailFieldDefinitionSchema,
   entryExportSchema,
+  entryFieldDefinitionSchema,
   entryFileSchema,
   entrySchema,
-  entryValueDefinitionSchema,
   environmentSchema,
+  fieldDefinitionSchema,
   fileReferenceSchema,
   getChangesProjectSchema,
   getRemoteOriginUrlProjectSchema,
-  getValueContentSchemaFromDefinition,
+  getValueContentSchemaFromFieldDefinition,
   gitCloneOptionsSchema,
   gitCommitIconSchema,
   gitCommitSchema,
@@ -3216,7 +3162,7 @@ export {
   gitSignatureSchema,
   gitSwitchOptionsSchema,
   gitTagSchema,
-  ipValueDefinitionSchema,
+  ipFieldDefinitionSchema,
   listAssetsSchema,
   listBranchesProjectSchema,
   listCollectionsSchema,
@@ -3224,7 +3170,7 @@ export {
   listGitTagsSchema,
   listProjectsSchema,
   localUserSchema,
-  numberValueDefinitionSchema,
+  numberFieldDefinitionSchema,
   objectTypeSchema,
   projectExportSchema,
   projectFileSchema,
@@ -3233,7 +3179,7 @@ export {
   projectSettingsSchema,
   projectStatusSchema,
   projectUpgradeSchema,
-  rangeValueDefinitionSchema,
+  rangeFieldDefinitionSchema,
   readAssetSchema,
   readCollectionSchema,
   readEntrySchema,
@@ -3248,7 +3194,7 @@ export {
   setRemoteOriginUrlProjectSchema,
   setUserSchema,
   slug,
-  stringValueDefinitionSchema,
+  stringFieldDefinitionSchema,
   supportedAssetExtensionSchema,
   supportedAssetMimeTypeSchema,
   supportedAssetTypeSchema,
@@ -3256,11 +3202,11 @@ export {
   supportedLanguageSchema,
   switchBranchProjectSchema,
   synchronizeProjectSchema,
-  telephoneValueDefinitionSchema,
-  textValueDefinitionSchema,
-  textareaValueDefinitionSchema,
-  timeValueDefinitionSchema,
-  toggleValueDefinitionSchema,
+  telephoneFieldDefinitionSchema,
+  textFieldDefinitionSchema,
+  textareaFieldDefinitionSchema,
+  timeFieldDefinitionSchema,
+  toggleFieldDefinitionSchema,
   translatableArrayOf,
   translatableBooleanSchema,
   translatableNumberSchema,
@@ -3270,7 +3216,7 @@ export {
   updateEntrySchema,
   updateProjectSchema,
   upgradeProjectSchema,
-  urlValueDefinitionSchema,
+  urlFieldDefinitionSchema,
   userFileSchema,
   userSchema,
   uuid,
@@ -3281,7 +3227,6 @@ export {
   valueContentReferenceToCollectionSchema,
   valueContentReferenceToEntrySchema,
   valueContentReferenceWithLanguageBase,
-  valueDefinitionSchema,
   valueSchema,
   versionSchema
 };