@elek-io/core 0.14.2 → 0.14.4

package/dist/node/index.node.js

@@ -10,7 +10,7 @@ import Fs7 from "fs-extra";
 // package.json
 var package_default = {
   name: "@elek-io/core",
-  version: "0.14.2",
+  version: "0.14.4",
   description: "Handles core functionality of elek.io Projects like file IO and version control.",
   homepage: "https://elek.io",
   repository: "https://github.com/elek-io/core",
@@ -45,19 +45,19 @@ var package_default = {
     release: "changeset publish"
   },
   dependencies: {
-    "@hono/node-server": "1.15.0",
+    "@hono/node-server": "1.18.1",
     "@hono/swagger-ui": "0.5.2",
-    "@hono/zod-openapi": "0.19.9",
+    "@hono/zod-openapi": "1.1.0",
     "@sindresorhus/slugify": "2.2.1",
-    "fs-extra": "11.3.0",
-    hono: "4.8.4",
+    "fs-extra": "11.3.1",
+    hono: "4.9.0",
     mime: "4.0.7",
     "p-queue": "8.1.0",
     semver: "7.7.2",
     uuid: "11.1.0",
     winston: "3.17.0",
     "winston-daily-rotate-file": "5.0.0",
-    zod: "3.25.74"
+    zod: "4.0.17"
   },
   devDependencies: {
     "@changesets/cli": "2.29.5",
@@ -70,7 +70,7 @@ var package_default = {
     "@types/uuid": "10.0.0",
     "@vitest/coverage-v8": "3.2.4",
     tsup: "8.5.0",
-    typescript: "5.8.3",
+    typescript: "5.9.2",
     vitest: "3.2.4"
   },
   peerDependencies: {
@@ -181,21 +181,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
@@ -345,7 +349,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(),
@@ -426,13 +430,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,
@@ -441,19 +445,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([
@@ -462,16 +466,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({
@@ -520,7 +524,7 @@ var FieldTypeSchema = z7.enum([
   "email",
   // 'password', @todo maybe if there is a usecase
   "url",
-  "ip",
+  "ipv4",
   "date",
   "time",
   "datetime",
@@ -547,60 +551,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,
@@ -608,7 +614,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),
@@ -616,10 +622,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(),
@@ -627,25 +633,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()
@@ -661,13 +667,13 @@ var fieldDefinitionSchema = z7.union([
 ]);
 function getValueContentSchemaFromFieldDefinition(fieldDefinition) {
   switch (fieldDefinition.valueType) {
-    case ValueTypeSchema.Enum.boolean:
+    case ValueTypeSchema.enum.boolean:
       return getBooleanValueContentSchema();
-    case ValueTypeSchema.Enum.number:
+    case ValueTypeSchema.enum.number:
       return getNumberValueContentSchema(fieldDefinition);
-    case ValueTypeSchema.Enum.string:
+    case ValueTypeSchema.enum.string:
       return getStringValueContentSchema(fieldDefinition);
-    case ValueTypeSchema.Enum.reference:
+    case ValueTypeSchema.enum.reference:
       return getReferenceValueContentSchema(fieldDefinition);
     default:
       throw new Error(
@@ -693,35 +699,40 @@ function getNumberValueContentSchema(definition) {
   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);
-  }
+  let schema = null;
   switch (definition.fieldType) {
-    case FieldTypeSchema.Enum.email:
-      schema = schema.email();
+    case FieldTypeSchema.enum.email:
+      schema = z7.email();
+      break;
+    case FieldTypeSchema.enum.url:
+      schema = z7.url();
       break;
-    case FieldTypeSchema.Enum.url:
-      schema = schema.url();
+    case FieldTypeSchema.enum.ipv4:
+      schema = z7.ipv4();
       break;
-    case FieldTypeSchema.Enum.ip:
-      schema = schema.ip();
+    case FieldTypeSchema.enum.date:
+      schema = z7.iso.date();
       break;
-    case FieldTypeSchema.Enum.date:
-      schema = schema.date();
+    case FieldTypeSchema.enum.time:
+      schema = z7.iso.time();
       break;
-    case FieldTypeSchema.Enum.time:
-      schema = schema.time();
+    case FieldTypeSchema.enum.datetime:
+      schema = z7.iso.datetime();
       break;
-    case FieldTypeSchema.Enum.datetime:
-      schema = schema.datetime();
+    case FieldTypeSchema.enum.telephone:
+      schema = z7.e164();
       break;
-    case FieldTypeSchema.Enum.telephone:
+    case FieldTypeSchema.enum.text:
+    case FieldTypeSchema.enum.textarea:
+      schema = z7.string().trim();
       break;
   }
+  if ("min" in definition && definition.min) {
+    schema = schema.min(definition.min);
+  }
+  if ("max" in definition && definition.max) {
+    schema = schema.max(definition.max);
+  }
   if (definition.isRequired === false) {
     return schema.nullable();
   }
@@ -730,12 +741,12 @@ function getStringValueContentSchema(definition) {
 function getReferenceValueContentSchema(definition) {
   let schema;
   switch (definition.fieldType) {
-    case FieldTypeSchema.Enum.asset:
+    case FieldTypeSchema.enum.asset:
       {
         schema = z7.array(valueContentReferenceToAssetSchema);
       }
       break;
-    case FieldTypeSchema.Enum.entry:
+    case FieldTypeSchema.enum.entry:
       {
         schema = z7.array(valueContentReferenceToEntrySchema);
       }
@@ -755,7 +766,7 @@ function getReferenceValueContentSchema(definition) {
 
 // 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
@@ -850,7 +861,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"),
@@ -918,7 +929,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()
@@ -1011,10 +1025,10 @@ var baseUserSchema = gitSignatureSchema.extend({
   })
 });
 var localUserSchema = baseUserSchema.extend({
-  userType: z12.literal(UserTypeSchema.Enum.local)
+  userType: z12.literal(UserTypeSchema.enum.local)
 });
 var cloudUserSchema = baseUserSchema.extend({
-  userType: z12.literal(UserTypeSchema.Enum.cloud),
+  userType: z12.literal(UserTypeSchema.enum.cloud),
   id: uuidSchema
 });
 var userFileSchema = z12.union([localUserSchema, cloudUserSchema]);
@@ -1730,18 +1744,18 @@ var pathTo = {
     return Path.join(pathTo.project(projectId), "project.json");
   },
   // projectLogs: (projectId: string): string => {
-  //   return Path.join(pathTo.project(projectId), projectFolderSchema.Enum.logs);
+  //   return Path.join(pathTo.project(projectId), projectFolderSchema.enum.logs);
   // },
   // public: (projectId: string): string => {
   //   return Path.join(pathTo.project(projectId), 'public');
   // },
   lfs: (projectId) => {
-    return Path.join(pathTo.project(projectId), projectFolderSchema.Enum.lfs);
+    return Path.join(pathTo.project(projectId), projectFolderSchema.enum.lfs);
   },
   collections: (projectId) => {
     return Path.join(
       pathTo.project(projectId),
-      projectFolderSchema.Enum.collections
+      projectFolderSchema.enum.collections
     );
   },
   collection: (projectId, id) => {
@@ -1765,7 +1779,7 @@ var pathTo = {
   assets: (projectId) => {
     return Path.join(
       pathTo.project(projectId),
-      projectFolderSchema.Enum.assets
+      projectFolderSchema.enum.assets
     );
   },
   assetFile: (projectId, id) => {
@@ -1849,20 +1863,20 @@ var AbstractCrudService = class {
    */
   async listReferences(type, projectId, collectionId) {
     switch (type) {
-      case objectTypeSchema.Enum.asset:
+      case objectTypeSchema.enum.asset:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
         return this.getFileReferences(pathTo.lfs(projectId));
       // LFS folder is correct, since we want the extension of the file itself, not the AssetFile (.json)
-      case objectTypeSchema.Enum.project:
+      case objectTypeSchema.enum.project:
         return this.getFolderReferences(pathTo.projects);
-      case objectTypeSchema.Enum.collection:
+      case objectTypeSchema.enum.collection:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
         return this.getFolderReferences(pathTo.collections(projectId));
-      case objectTypeSchema.Enum.entry:
+      case objectTypeSchema.enum.entry:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
@@ -1872,7 +1886,7 @@ var AbstractCrudService = class {
         return this.getFileReferences(
           pathTo.collection(projectId, collectionId)
         );
-      case objectTypeSchema.Enum.sharedValue:
+      case objectTypeSchema.enum.sharedValue:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
@@ -1952,7 +1966,7 @@ var AssetService = class extends AbstractCrudService {
   jsonFileService;
   gitService;
   constructor(options, logService, jsonFileService, gitService) {
-    super(serviceTypeSchema.Enum.Asset, options);
+    super(serviceTypeSchema.enum.Asset, options);
     this.logService = logService;
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
@@ -2111,7 +2125,7 @@ var AssetService = class extends AbstractCrudService {
     const offset = props.offset || 0;
     const limit = props.limit || 15;
     const assetReferences = await this.listReferences(
-      objectTypeSchema.Enum.asset,
+      objectTypeSchema.enum.asset,
       props.projectId
     );
     const partialAssetReferences = assetReferences.slice(offset, limit);
@@ -2132,7 +2146,7 @@ var AssetService = class extends AbstractCrudService {
   }
   async count(props) {
     countAssetsSchema.parse(props);
-    const count = (await this.listReferences(objectTypeSchema.Enum.asset, props.projectId)).length;
+    const count = (await this.listReferences(objectTypeSchema.enum.asset, props.projectId)).length;
     return count;
   }
   /**
@@ -2203,7 +2217,7 @@ var CollectionService = class extends AbstractCrudService {
   jsonFileService;
   gitService;
   constructor(options, jsonFileService, gitService) {
-    super(serviceTypeSchema.Enum.Collection, options);
+    super(serviceTypeSchema.enum.Collection, options);
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
   }
@@ -2319,7 +2333,7 @@ var CollectionService = class extends AbstractCrudService {
     const offset = props.offset || 0;
     const limit = props.limit || 15;
     const collectionReferences = await this.listReferences(
-      objectTypeSchema.Enum.collection,
+      objectTypeSchema.enum.collection,
       props.projectId
     );
     const partialCollectionReferences = collectionReferences.slice(
@@ -2344,7 +2358,7 @@ var CollectionService = class extends AbstractCrudService {
   async count(props) {
     countCollectionsSchema.parse(props);
     const count = (await this.listReferences(
-      objectTypeSchema.Enum.collection,
+      objectTypeSchema.enum.collection,
       props.projectId
     )).length;
     return count;
@@ -2388,7 +2402,7 @@ var EntryService = class extends AbstractCrudService {
   collectionService;
   // private sharedValueService: SharedValueService;
   constructor(options, logService, jsonFileService, gitService, collectionService) {
-    super(serviceTypeSchema.Enum.Entry, options);
+    super(serviceTypeSchema.enum.Entry, options);
     this.logService = logService;
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
@@ -2547,7 +2561,7 @@ var EntryService = class extends AbstractCrudService {
     const offset = props.offset || 0;
     const limit = props.limit || 15;
     const entryReferences = await this.listReferences(
-      objectTypeSchema.Enum.entry,
+      objectTypeSchema.enum.entry,
       props.projectId,
       props.collectionId
     );
@@ -2571,7 +2585,7 @@ var EntryService = class extends AbstractCrudService {
   async count(props) {
     countEntriesSchema.parse(props);
     return (await this.listReferences(
-      objectTypeSchema.Enum.entry,
+      objectTypeSchema.enum.entry,
       props.projectId,
       props.collectionId
     )).length;
@@ -2652,7 +2666,7 @@ import Path2 from "path";
 var GitTagService = class extends AbstractCrudService {
   git;
   constructor(options, git) {
-    super(serviceTypeSchema.Enum.GitTag, options);
+    super(serviceTypeSchema.enum.GitTag, options);
     this.git = git;
   }
   /**
@@ -3324,7 +3338,7 @@ var JsonFileService = class extends AbstractCrudService {
   cache = /* @__PURE__ */ new Map();
   logService;
   constructor(options, logService) {
-    super(serviceTypeSchema.Enum.JsonFile, options);
+    super(serviceTypeSchema.enum.JsonFile, options);
     this.logService = logService;
   }
   /**
@@ -3517,7 +3531,7 @@ var ProjectService = class extends AbstractCrudService {
   collectionService;
   entryService;
   constructor(coreVersion, options, logService, jsonFileService, userService, gitService, assetService, collectionService, entryService) {
-    super(serviceTypeSchema.Enum.Project, options);
+    super(serviceTypeSchema.enum.Project, options);
     this.coreVersion = coreVersion;
     this.logService = logService;
     this.jsonFileService = jsonFileService;
@@ -3561,7 +3575,7 @@ var ProjectService = class extends AbstractCrudService {
       await this.createFolderStructure(projectPath);
       await this.createGitignore(projectPath);
       await this.gitService.init(projectPath, {
-        initialBranch: projectBranchSchema.Enum.production
+        initialBranch: projectBranchSchema.enum.production
       });
       await this.jsonFileService.create(
         projectFile,
@@ -3575,7 +3589,7 @@ var ProjectService = class extends AbstractCrudService {
       });
       await this.gitService.branches.switch(
         projectPath,
-        projectBranchSchema.Enum.work,
+        projectBranchSchema.enum.work,
         {
           isNew: true
         }
@@ -3677,10 +3691,10 @@ var ProjectService = class extends AbstractCrudService {
     const projectPath = pathTo.project(props.id);
     const projectFilePath = pathTo.projectFile(props.id);
     const currentBranch = await this.gitService.branches.current(projectPath);
-    if (currentBranch !== projectBranchSchema.Enum.work) {
+    if (currentBranch !== projectBranchSchema.enum.work) {
       await this.gitService.branches.switch(
         projectPath,
-        projectBranchSchema.Enum.work
+        projectBranchSchema.enum.work
       );
     }
     const currentProjectFile = outdatedProjectSchema.passthrough().parse(await this.jsonFileService.unsafeRead(projectFilePath));
@@ -3740,7 +3754,7 @@ var ProjectService = class extends AbstractCrudService {
       await this.update(migratedProjectFile);
       await this.gitService.branches.switch(
         projectPath,
-        projectBranchSchema.Enum.work
+        projectBranchSchema.enum.work
       );
       await this.gitService.merge(projectPath, upgradeBranchName, {
         squash: true
@@ -3768,7 +3782,7 @@ var ProjectService = class extends AbstractCrudService {
     } catch (error) {
       await this.gitService.branches.switch(
         projectPath,
-        projectBranchSchema.Enum.work
+        projectBranchSchema.enum.work
       );
       await this.gitService.branches.delete(
         projectPath,
@@ -3887,7 +3901,7 @@ var ProjectService = class extends AbstractCrudService {
    */
   async listOutdated() {
     const projectReferences = await this.listReferences(
-      objectTypeSchema.Enum.project
+      objectTypeSchema.enum.project
     );
     const result = await Promise.all(
       projectReferences.map(async (reference) => {
@@ -3910,7 +3924,7 @@ var ProjectService = class extends AbstractCrudService {
     const offset = props?.offset || 0;
     const limit = props?.limit || 15;
     const projectReferences = await this.listReferences(
-      objectTypeSchema.Enum.project
+      objectTypeSchema.enum.project
     );
     const partialProjectReferences = projectReferences.slice(offset, limit);
     const projects = await returnResolved(
@@ -3926,7 +3940,7 @@ var ProjectService = class extends AbstractCrudService {
     };
   }
   async count() {
-    return (await this.listReferences(objectTypeSchema.Enum.project)).length;
+    return (await this.listReferences(objectTypeSchema.enum.project)).length;
   }
   /**
    * Checks if given object is of type Project
@@ -3999,7 +4013,7 @@ var ProjectService = class extends AbstractCrudService {
    * committed
    */
   async createFolderStructure(path) {
-    const folders2 = Object.values(projectFolderSchema.Values);
+    const folders2 = Object.values(projectFolderSchema.enum);
     await Promise.all(
       folders2.map(async (folder) => {
         await Fs6.mkdirp(Path4.join(path, folder));
@@ -4023,9 +4037,9 @@ var ProjectService = class extends AbstractCrudService {
       "!/**/.gitkeep",
       "",
       "# elek.io related ignores"
-      // projectFolderSchema.Enum.theme + '/',
-      // projectFolderSchema.Enum.public + '/',
-      // projectFolderSchema.Enum.logs + '/',
+      // projectFolderSchema.enum.theme + '/',
+      // projectFolderSchema.enum.public + '/',
+      // projectFolderSchema.enum.logs + '/',
     ];
     await Fs6.writeFile(Path4.join(path, ".gitignore"), lines.join(Os2.EOL));
   }
@@ -4125,7 +4139,7 @@ var UserService = class {
     const userFile = {
       ...props
     };
-    if (userFile.userType === UserTypeSchema.Enum.cloud) {
+    if (userFile.userType === UserTypeSchema.enum.cloud) {
     }
     await this.jsonFileService.update(userFile, userFilePath, userFileSchema);
     this.logService.debug("Updated User");
@@ -4331,7 +4345,7 @@ export {
   gitSignatureSchema,
   gitSwitchOptionsSchema,
   gitTagSchema,
-  ipFieldDefinitionSchema,
+  ipv4FieldDefinitionSchema,
   listAssetsSchema,
   listBranchesProjectSchema,
   listCollectionsSchema,