@elek-io/core 0.14.3 → 0.15.0

package/dist/browser/index.browser.js

@@ -67,21 +67,25 @@ var objectTypeSchema = z.enum([
 ]);
 var logLevelSchema = z.enum(["error", "warn", "info", "debug"]);
 var versionSchema = z.string();
-var uuidSchema = z.string().uuid("shared.invalidUuid");
-var translatableStringSchema = z.record(
+var uuidSchema = z.uuid("shared.invalidUuid");
+var translatableStringSchema = z.partialRecord(
   supportedLanguageSchema,
   z.string().trim().min(1, "shared.translatableStringRequired")
 );
-var translatableNumberSchema = z.record(
+var translatableNumberSchema = z.partialRecord(
   supportedLanguageSchema,
-  z.number({ required_error: "shared.translatableNumberRequired" })
+  z.number({
+    error: (error) => error.input === void 0 ? "shared.translatableNumberRequired" : "shared.translatableNumberNotANumber"
+  })
 );
-var translatableBooleanSchema = z.record(
+var translatableBooleanSchema = z.partialRecord(
   supportedLanguageSchema,
-  z.boolean({ required_error: "shared.translatableBooleanRequired" })
+  z.boolean({
+    error: (error) => error.input === void 0 ? "shared.translatableBooleanRequired" : "shared.translatableBooleanNotABoolean"
+  })
 );
 function translatableArrayOf(schema) {
-  return z.record(supportedLanguageSchema, z.array(schema));
+  return z.partialRecord(supportedLanguageSchema, z.array(schema));
 }
 
 // src/schema/fileSchema.ts
@@ -231,7 +235,7 @@ var countGitTagsSchema = z3.object({
 
 // src/schema/assetSchema.ts
 var assetFileSchema = baseFileSchema.extend({
-  objectType: z4.literal(objectTypeSchema.Enum.asset).readonly(),
+  objectType: z4.literal(objectTypeSchema.enum.asset).readonly(),
   name: z4.string(),
   description: z4.string(),
   extension: z4.string().readonly(),
@@ -312,13 +316,13 @@ var valueContentReferenceBase = z5.object({
   id: uuidSchema
 });
 var valueContentReferenceToAssetSchema = valueContentReferenceBase.extend({
-  objectType: z5.literal(objectTypeSchema.Enum.asset)
+  objectType: z5.literal(objectTypeSchema.enum.asset)
 });
 var valueContentReferenceToCollectionSchema = valueContentReferenceBase.extend({
-  objectType: z5.literal(objectTypeSchema.Enum.collection)
+  objectType: z5.literal(objectTypeSchema.enum.collection)
 });
 var valueContentReferenceToEntrySchema = valueContentReferenceBase.extend({
-  objectType: z5.literal(objectTypeSchema.Enum.entry)
+  objectType: z5.literal(objectTypeSchema.enum.entry)
 });
 var valueContentReferenceSchema = z5.union([
   valueContentReferenceToAssetSchema,
@@ -327,19 +331,19 @@ var valueContentReferenceSchema = z5.union([
   // valueContentReferenceToSharedValueSchema,
 ]);
 var directValueBaseSchema = z5.object({
-  objectType: z5.literal(objectTypeSchema.Enum.value).readonly(),
+  objectType: z5.literal(objectTypeSchema.enum.value).readonly(),
   fieldDefinitionId: uuidSchema.readonly()
 });
 var directStringValueSchema = directValueBaseSchema.extend({
-  valueType: z5.literal(ValueTypeSchema.Enum.string).readonly(),
+  valueType: z5.literal(ValueTypeSchema.enum.string).readonly(),
   content: translatableStringSchema
 });
 var directNumberValueSchema = directValueBaseSchema.extend({
-  valueType: z5.literal(ValueTypeSchema.Enum.number).readonly(),
+  valueType: z5.literal(ValueTypeSchema.enum.number).readonly(),
   content: translatableNumberSchema
 });
 var directBooleanValueSchema = directValueBaseSchema.extend({
-  valueType: z5.literal(ValueTypeSchema.Enum.boolean).readonly(),
+  valueType: z5.literal(ValueTypeSchema.enum.boolean).readonly(),
   content: translatableBooleanSchema
 });
 var directValueSchema = z5.union([
@@ -348,16 +352,16 @@ var directValueSchema = z5.union([
   directBooleanValueSchema
 ]);
 var referencedValueSchema = z5.object({
-  objectType: z5.literal(objectTypeSchema.Enum.value).readonly(),
+  objectType: z5.literal(objectTypeSchema.enum.value).readonly(),
   fieldDefinitionId: uuidSchema.readonly(),
-  valueType: z5.literal(ValueTypeSchema.Enum.reference).readonly(),
+  valueType: z5.literal(ValueTypeSchema.enum.reference).readonly(),
   content: translatableArrayOf(valueContentReferenceSchema)
 });
 var valueSchema = z5.union([directValueSchema, referencedValueSchema]);
 
 // src/schema/entrySchema.ts
 var entryFileSchema = baseFileSchema.extend({
-  objectType: z6.literal(objectTypeSchema.Enum.entry).readonly(),
+  objectType: z6.literal(objectTypeSchema.enum.entry).readonly(),
   values: z6.array(valueSchema)
 });
 var entrySchema = entryFileSchema.extend({
@@ -406,7 +410,7 @@ var FieldTypeSchema = z7.enum([
   "email",
   // 'password', @todo maybe if there is a usecase
   "url",
-  "ip",
+  "ipv4",
   "date",
   "time",
   "datetime",
@@ -425,7 +429,7 @@ var FieldWidthSchema = z7.enum(["12", "6", "4", "3"]);
 var FieldDefinitionBaseSchema = z7.object({
   id: uuidSchema.readonly(),
   label: translatableStringSchema,
-  description: translatableStringSchema,
+  description: translatableStringSchema.nullable(),
   isRequired: z7.boolean(),
   isDisabled: z7.boolean(),
   isUnique: z7.boolean(),
@@ -433,60 +437,62 @@ var FieldDefinitionBaseSchema = z7.object({
 });
 var StringFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend(
   {
-    valueType: z7.literal(ValueTypeSchema.Enum.string),
+    valueType: z7.literal(ValueTypeSchema.enum.string),
     defaultValue: z7.string().nullable()
   }
 );
 var textFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend(
   {
-    fieldType: z7.literal(FieldTypeSchema.Enum.text),
+    fieldType: z7.literal(FieldTypeSchema.enum.text),
     min: z7.number().nullable(),
     max: z7.number().nullable()
   }
 );
 var textareaFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.textarea),
+  fieldType: z7.literal(FieldTypeSchema.enum.textarea),
   min: z7.number().nullable(),
   max: z7.number().nullable()
 });
 var emailFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.email),
-  defaultValue: z7.string().email().nullable()
+  fieldType: z7.literal(FieldTypeSchema.enum.email),
+  defaultValue: z7.email().nullable()
 });
 var urlFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.url),
-  defaultValue: z7.string().url().nullable()
-});
-var ipFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.ip),
-  defaultValue: z7.string().ip().nullable()
+  fieldType: z7.literal(FieldTypeSchema.enum.url),
+  defaultValue: z7.url().nullable()
 });
+var ipv4FieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend(
+  {
+    fieldType: z7.literal(FieldTypeSchema.enum.ipv4),
+    defaultValue: z7.ipv4().nullable()
+  }
+);
 var dateFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend(
   {
-    fieldType: z7.literal(FieldTypeSchema.Enum.date),
-    defaultValue: z7.string().date().nullable()
+    fieldType: z7.literal(FieldTypeSchema.enum.date),
+    defaultValue: z7.iso.date().nullable()
   }
 );
 var timeFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend(
   {
-    fieldType: z7.literal(FieldTypeSchema.Enum.time),
-    defaultValue: z7.string().time().nullable()
+    fieldType: z7.literal(FieldTypeSchema.enum.time),
+    defaultValue: z7.iso.time().nullable()
   }
 );
 var datetimeFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.datetime),
-  defaultValue: z7.string().datetime().nullable()
+  fieldType: z7.literal(FieldTypeSchema.enum.datetime),
+  defaultValue: z7.iso.datetime().nullable()
 });
 var telephoneFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.telephone)
-  // defaultValue: z.string().e164(), @todo when zod v4 releases @see https://github.com/colinhacks/zod/pull/3476
+  fieldType: z7.literal(FieldTypeSchema.enum.telephone),
+  defaultValue: z7.e164().nullable()
 });
 var stringFieldDefinitionSchema = z7.union([
   textFieldDefinitionSchema,
   textareaFieldDefinitionSchema,
   emailFieldDefinitionSchema,
   urlFieldDefinitionSchema,
-  ipFieldDefinitionSchema,
+  ipv4FieldDefinitionSchema,
   dateFieldDefinitionSchema,
   timeFieldDefinitionSchema,
   datetimeFieldDefinitionSchema,
@@ -494,7 +500,7 @@ var stringFieldDefinitionSchema = z7.union([
 ]);
 var NumberFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend(
   {
-    valueType: z7.literal(ValueTypeSchema.Enum.number),
+    valueType: z7.literal(ValueTypeSchema.enum.number),
     min: z7.number().nullable(),
     max: z7.number().nullable(),
     isUnique: z7.literal(false),
@@ -502,10 +508,10 @@ var NumberFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend(
   }
 );
 var numberFieldDefinitionSchema = NumberFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.number)
+  fieldType: z7.literal(FieldTypeSchema.enum.number)
 });
 var rangeFieldDefinitionSchema = NumberFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.range),
+  fieldType: z7.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: z7.literal(true),
   min: z7.number(),
@@ -513,25 +519,25 @@ var rangeFieldDefinitionSchema = NumberFieldDefinitionBaseSchema.extend({
   defaultValue: z7.number()
 });
 var BooleanFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({
-  valueType: z7.literal(ValueTypeSchema.Enum.boolean),
+  valueType: z7.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: z7.literal(true),
   defaultValue: z7.boolean(),
   isUnique: z7.literal(false)
 });
 var toggleFieldDefinitionSchema = BooleanFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.toggle)
+  fieldType: z7.literal(FieldTypeSchema.enum.toggle)
 });
 var ReferenceFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({
-  valueType: z7.literal(ValueTypeSchema.Enum.reference)
+  valueType: z7.literal(ValueTypeSchema.enum.reference)
 });
 var assetFieldDefinitionSchema = ReferenceFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.asset),
+  fieldType: z7.literal(FieldTypeSchema.enum.asset),
   min: z7.number().nullable(),
   max: z7.number().nullable()
 });
 var entryFieldDefinitionSchema = ReferenceFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.entry),
+  fieldType: z7.literal(FieldTypeSchema.enum.entry),
   ofCollections: z7.array(uuidSchema),
   min: z7.number().nullable(),
   max: z7.number().nullable()
@@ -545,103 +551,10 @@ var fieldDefinitionSchema = z7.union([
   entryFieldDefinitionSchema
   // sharedValueDefinitionSchema,
 ]);
-function getValueContentSchemaFromFieldDefinition(fieldDefinition) {
-  switch (fieldDefinition.valueType) {
-    case ValueTypeSchema.Enum.boolean:
-      return getBooleanValueContentSchema();
-    case ValueTypeSchema.Enum.number:
-      return getNumberValueContentSchema(fieldDefinition);
-    case ValueTypeSchema.Enum.string:
-      return getStringValueContentSchema(fieldDefinition);
-    case ValueTypeSchema.Enum.reference:
-      return getReferenceValueContentSchema(fieldDefinition);
-    default:
-      throw new Error(
-        // @ts-expect-error
-        `Error generating schema for unsupported ValueType "${fieldDefinition.valueType}"`
-      );
-  }
-}
-function getBooleanValueContentSchema() {
-  return z7.boolean();
-}
-function getNumberValueContentSchema(definition) {
-  let schema = z7.number();
-  if (definition.min) {
-    schema = schema.min(definition.min);
-  }
-  if (definition.max) {
-    schema = schema.max(definition.max);
-  }
-  if (definition.isRequired === false) {
-    return schema.nullable();
-  }
-  return schema;
-}
-function getStringValueContentSchema(definition) {
-  let schema = z7.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.fieldType) {
-    case FieldTypeSchema.Enum.email:
-      schema = schema.email();
-      break;
-    case FieldTypeSchema.Enum.url:
-      schema = schema.url();
-      break;
-    case FieldTypeSchema.Enum.ip:
-      schema = schema.ip();
-      break;
-    case FieldTypeSchema.Enum.date:
-      schema = schema.date();
-      break;
-    case FieldTypeSchema.Enum.time:
-      schema = schema.time();
-      break;
-    case FieldTypeSchema.Enum.datetime:
-      schema = schema.datetime();
-      break;
-    case FieldTypeSchema.Enum.telephone:
-      break;
-  }
-  if (definition.isRequired === false) {
-    return schema.nullable();
-  }
-  return schema.min(1, "shared.stringValueRequired");
-}
-function getReferenceValueContentSchema(definition) {
-  let schema;
-  switch (definition.fieldType) {
-    case FieldTypeSchema.Enum.asset:
-      {
-        schema = z7.array(valueContentReferenceToAssetSchema);
-      }
-      break;
-    case FieldTypeSchema.Enum.entry:
-      {
-        schema = z7.array(valueContentReferenceToEntrySchema);
-      }
-      break;
-  }
-  if (definition.isRequired) {
-    schema = schema.min(1, "shared.referenceRequired");
-  }
-  if (definition.min) {
-    schema = schema.min(definition.min);
-  }
-  if (definition.max) {
-    schema = schema.max(definition.max);
-  }
-  return schema;
-}
 
 // src/schema/collectionSchema.ts
 var collectionFileSchema = baseFileSchema.extend({
-  objectType: z8.literal(objectTypeSchema.Enum.collection).readonly(),
+  objectType: z8.literal(objectTypeSchema.enum.collection).readonly(),
   name: z8.object({
     singular: translatableStringSchema,
     plural: translatableStringSchema
@@ -736,7 +649,7 @@ var projectFolderSchema = z10.enum([
 ]);
 var projectBranchSchema = z10.enum(["production", "work"]);
 var projectFileSchema = baseFileSchema.extend({
-  objectType: z10.literal(objectTypeSchema.Enum.project).readonly(),
+  objectType: z10.literal(objectTypeSchema.enum.project).readonly(),
   coreVersion: versionSchema,
   name: z10.string().trim().min(1, "shared.projectNameRequired"),
   description: z10.string().trim().min(1, "shared.projectDescriptionRequired"),
@@ -804,7 +717,10 @@ 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: z10.function({
+    input: [projectFileSchema],
+    output: z10.promise(z10.void())
+  })
 });
 var cloneProjectSchema = z10.object({
   url: z10.string()
@@ -840,9 +756,182 @@ var searchProjectSchema = z10.object({
   type: z10.array(objectTypeSchema).optional()
 });
 
+// src/schema/schemaFromFieldDefinition.ts
+import z11 from "zod";
+function getBooleanValueContentSchemaFromFieldDefinition() {
+  return z11.boolean();
+}
+function getNumberValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  let schema = z11.number();
+  if (fieldDefinition.min) {
+    schema = schema.min(fieldDefinition.min);
+  }
+  if (fieldDefinition.max) {
+    schema = schema.max(fieldDefinition.max);
+  }
+  if (fieldDefinition.isRequired === false) {
+    return schema.nullable();
+  }
+  return schema;
+}
+function getStringValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  let schema = null;
+  switch (fieldDefinition.fieldType) {
+    case FieldTypeSchema.enum.email:
+      schema = z11.email();
+      break;
+    case FieldTypeSchema.enum.url:
+      schema = z11.url();
+      break;
+    case FieldTypeSchema.enum.ipv4:
+      schema = z11.ipv4();
+      break;
+    case FieldTypeSchema.enum.date:
+      schema = z11.iso.date();
+      break;
+    case FieldTypeSchema.enum.time:
+      schema = z11.iso.time();
+      break;
+    case FieldTypeSchema.enum.datetime:
+      schema = z11.iso.datetime();
+      break;
+    case FieldTypeSchema.enum.telephone:
+      schema = z11.e164();
+      break;
+    case FieldTypeSchema.enum.text:
+    case FieldTypeSchema.enum.textarea:
+      schema = z11.string().trim();
+      break;
+  }
+  if ("min" in fieldDefinition && fieldDefinition.min) {
+    schema = schema.min(fieldDefinition.min);
+  }
+  if ("max" in fieldDefinition && fieldDefinition.max) {
+    schema = schema.max(fieldDefinition.max);
+  }
+  if (fieldDefinition.isRequired === false) {
+    return schema.nullable();
+  }
+  return schema.min(1, "shared.stringValueRequired");
+}
+function getReferenceValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  let schema;
+  switch (fieldDefinition.fieldType) {
+    case FieldTypeSchema.enum.asset:
+      {
+        schema = z11.array(valueContentReferenceToAssetSchema);
+      }
+      break;
+    case FieldTypeSchema.enum.entry:
+      {
+        schema = z11.array(valueContentReferenceToEntrySchema);
+      }
+      break;
+  }
+  if (fieldDefinition.isRequired) {
+    schema = schema.min(1, "shared.referenceRequired");
+  }
+  if (fieldDefinition.min) {
+    schema = schema.min(fieldDefinition.min);
+  }
+  if (fieldDefinition.max) {
+    schema = schema.max(fieldDefinition.max);
+  }
+  return schema;
+}
+function getTranslatableStringValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  return z11.partialRecord(
+    supportedLanguageSchema,
+    getStringValueContentSchemaFromFieldDefinition(fieldDefinition)
+  );
+}
+function getTranslatableNumberValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  return z11.partialRecord(
+    supportedLanguageSchema,
+    getNumberValueContentSchemaFromFieldDefinition(fieldDefinition)
+  );
+}
+function getTranslatableBooleanValueContentSchemaFromFieldDefinition() {
+  return z11.partialRecord(
+    supportedLanguageSchema,
+    getBooleanValueContentSchemaFromFieldDefinition()
+  );
+}
+function getTranslatableReferenceValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  return z11.partialRecord(
+    supportedLanguageSchema,
+    getReferenceValueContentSchemaFromFieldDefinition(fieldDefinition)
+  );
+}
+function getValueSchemaFromFieldDefinition(fieldDefinition) {
+  switch (fieldDefinition.valueType) {
+    case ValueTypeSchema.enum.boolean:
+      return directBooleanValueSchema.extend({
+        content: getTranslatableBooleanValueContentSchemaFromFieldDefinition()
+      });
+    case ValueTypeSchema.enum.number:
+      return directNumberValueSchema.extend({
+        content: getTranslatableNumberValueContentSchemaFromFieldDefinition(
+          fieldDefinition
+        )
+      });
+    case ValueTypeSchema.enum.string:
+      return directStringValueSchema.extend({
+        content: getTranslatableStringValueContentSchemaFromFieldDefinition(
+          fieldDefinition
+        )
+      });
+    case ValueTypeSchema.enum.reference:
+      return referencedValueSchema.extend({
+        content: getTranslatableReferenceValueContentSchemaFromFieldDefinition(
+          fieldDefinition
+        )
+      });
+    default:
+      throw new Error(
+        // @ts-expect-error Code cannot be reached, but if we add a new ValueType and forget to update this function, we want to be notified about it
+        `Error generating schema for unsupported ValueType "${fieldDefinition.valueType}"`
+      );
+  }
+}
+function getCreateEntrySchemaFromFieldDefinitions(fieldDefinitions, values) {
+  const schema = {
+    ...createEntrySchema,
+    values: values.map((value) => {
+      const fieldDefinition = fieldDefinitions.find(
+        (fieldDefinition2) => fieldDefinition2.id === value.fieldDefinitionId
+      );
+      if (!fieldDefinition) {
+        throw new Error(
+          `Field definition with ID "${value.fieldDefinitionId}" not found`
+        );
+      }
+      return getValueSchemaFromFieldDefinition(fieldDefinition);
+    })
+  };
+  return schema;
+}
+function getUpdateEntrySchemaFromFieldDefinitions(fieldDefinitions, values) {
+  const schema = {
+    ...updateEntrySchema,
+    values: values.map((value) => {
+      const fieldDefinition = fieldDefinitions.find(
+        (fieldDefinition2) => fieldDefinition2.id === value.fieldDefinitionId
+      );
+      if (!fieldDefinition) {
+        throw new Error(
+          `Field definition with ID "${value.fieldDefinitionId}" not found`
+        );
+      }
+      return getValueSchemaFromFieldDefinition(fieldDefinition);
+    })
+  };
+  return schema;
+}
+
 // 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",
@@ -855,17 +944,17 @@ var serviceTypeSchema = z11.enum([
   "Value"
 ]);
 function paginatedListOf(schema) {
-  return z11.object({
-    total: z11.number(),
-    limit: z11.number(),
-    offset: z11.number(),
-    list: z11.array(schema)
+  return z12.object({
+    total: z12.number(),
+    limit: z12.number(),
+    offset: z12.number(),
+    list: z12.array(schema)
   });
 }
-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({
@@ -875,35 +964,35 @@ var listAssetsSchema = listSchema;
 var listProjectsSchema = listSchema.omit({
   projectId: true
 });
-var listGitTagsSchema = z11.object({
-  path: z11.string()
+var listGitTagsSchema = z12.object({
+  path: z12.string()
 });
 
 // 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,
-  localApi: z12.object({
+  localApi: z13.object({
     /**
      * If set to true the local API is started whenever Core is initialized
      */
-    isEnabled: z12.boolean(),
+    isEnabled: z13.boolean(),
     /**
      * The port the local API uses
      */
-    port: z12.number()
+    port: z13.number()
   })
 });
 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;
 
@@ -980,8 +1069,10 @@ export {
   fieldDefinitionSchema,
   fileReferenceSchema,
   getChangesProjectSchema,
+  getCreateEntrySchemaFromFieldDefinitions,
   getRemoteOriginUrlProjectSchema,
-  getValueContentSchemaFromFieldDefinition,
+  getUpdateEntrySchemaFromFieldDefinitions,
+  getValueSchemaFromFieldDefinition,
   gitCloneOptionsSchema,
   gitCommitSchema,
   gitInitOptionsSchema,
@@ -991,7 +1082,7 @@ export {
   gitSignatureSchema,
   gitSwitchOptionsSchema,
   gitTagSchema,
-  ipFieldDefinitionSchema,
+  ipv4FieldDefinitionSchema,
   listAssetsSchema,
   listBranchesProjectSchema,
   listCollectionsSchema,