@elek-io/core 0.5.4 → 0.6.0

package/dist/node/index.node.cjs

@@ -1,3409 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.node.ts
-var index_node_exports = {};
-__export(index_node_exports, {
-  BooleanValueDefinitionBaseSchema: () => BooleanValueDefinitionBaseSchema,
-  NumberValueDefinitionBaseSchema: () => NumberValueDefinitionBaseSchema,
-  ReferenceValueDefinitionBaseSchema: () => ReferenceValueDefinitionBaseSchema,
-  StringValueDefinitionBaseSchema: () => StringValueDefinitionBaseSchema,
-  UserTypeSchema: () => UserTypeSchema,
-  ValueDefinitionBaseSchema: () => ValueDefinitionBaseSchema,
-  ValueInputTypeSchema: () => ValueInputTypeSchema,
-  ValueInputWidthSchema: () => ValueInputWidthSchema,
-  ValueTypeSchema: () => ValueTypeSchema,
-  assetExportSchema: () => assetExportSchema,
-  assetFileSchema: () => assetFileSchema,
-  assetSchema: () => assetSchema,
-  assetValueDefinitionSchema: () => assetValueDefinitionSchema,
-  baseFileSchema: () => baseFileSchema,
-  baseFileWithLanguageSchema: () => baseFileWithLanguageSchema,
-  baseUserSchema: () => baseUserSchema,
-  cloneProjectSchema: () => cloneProjectSchema,
-  cloudUserSchema: () => cloudUserSchema,
-  collectionExportSchema: () => collectionExportSchema,
-  collectionFileSchema: () => collectionFileSchema,
-  collectionSchema: () => collectionSchema,
-  constructorElekIoCoreSchema: () => constructorElekIoCoreSchema,
-  countAssetsSchema: () => countAssetsSchema,
-  countCollectionsSchema: () => countCollectionsSchema,
-  countEntriesSchema: () => countEntriesSchema,
-  countGitTagsSchema: () => countGitTagsSchema,
-  createAssetSchema: () => createAssetSchema,
-  createCollectionSchema: () => createCollectionSchema,
-  createEntrySchema: () => createEntrySchema,
-  createGitTagSchema: () => createGitTagSchema,
-  createProjectSchema: () => createProjectSchema,
-  currentBranchProjectSchema: () => currentBranchProjectSchema,
-  currentTimestamp: () => currentTimestamp,
-  dateValueDefinitionSchema: () => dateValueDefinitionSchema,
-  datetimeValueDefinitionSchema: () => datetimeValueDefinitionSchema,
-  default: () => ElekIoCore,
-  deleteAssetSchema: () => deleteAssetSchema,
-  deleteCollectionSchema: () => deleteCollectionSchema,
-  deleteEntrySchema: () => deleteEntrySchema,
-  deleteGitTagSchema: () => deleteGitTagSchema,
-  deleteProjectSchema: () => deleteProjectSchema,
-  directBooleanValueSchema: () => directBooleanValueSchema,
-  directNumberValueSchema: () => directNumberValueSchema,
-  directStringValueSchema: () => directStringValueSchema,
-  directValueBaseSchema: () => directValueBaseSchema,
-  directValueSchema: () => directValueSchema,
-  elekIoCoreOptionsSchema: () => elekIoCoreOptionsSchema,
-  emailValueDefinitionSchema: () => emailValueDefinitionSchema,
-  entryExportSchema: () => entryExportSchema,
-  entryFileSchema: () => entryFileSchema,
-  entrySchema: () => entrySchema,
-  entryValueDefinitionSchema: () => entryValueDefinitionSchema,
-  environmentSchema: () => environmentSchema,
-  fileReferenceSchema: () => fileReferenceSchema,
-  getChangesProjectSchema: () => getChangesProjectSchema,
-  getRemoteOriginUrlProjectSchema: () => getRemoteOriginUrlProjectSchema,
-  getValueContentSchemaFromDefinition: () => getValueContentSchemaFromDefinition,
-  gitCloneOptionsSchema: () => gitCloneOptionsSchema,
-  gitCommitIconSchema: () => gitCommitIconSchema,
-  gitCommitSchema: () => gitCommitSchema,
-  gitInitOptionsSchema: () => gitInitOptionsSchema,
-  gitLogOptionsSchema: () => gitLogOptionsSchema,
-  gitRepositoryPathSchema: () => gitRepositoryPathSchema,
-  gitSignatureSchema: () => gitSignatureSchema,
-  gitSwitchOptionsSchema: () => gitSwitchOptionsSchema,
-  gitTagSchema: () => gitTagSchema,
-  ipValueDefinitionSchema: () => ipValueDefinitionSchema,
-  listAssetsSchema: () => listAssetsSchema,
-  listBranchesProjectSchema: () => listBranchesProjectSchema,
-  listCollectionsSchema: () => listCollectionsSchema,
-  listEntriesSchema: () => listEntriesSchema,
-  listGitTagsSchema: () => listGitTagsSchema,
-  listProjectsSchema: () => listProjectsSchema,
-  localUserSchema: () => localUserSchema,
-  numberValueDefinitionSchema: () => numberValueDefinitionSchema,
-  objectTypeSchema: () => objectTypeSchema,
-  projectExportSchema: () => projectExportSchema,
-  projectFileSchema: () => projectFileSchema,
-  projectFolderSchema: () => projectFolderSchema,
-  projectSchema: () => projectSchema,
-  projectSettingsSchema: () => projectSettingsSchema,
-  projectStatusSchema: () => projectStatusSchema,
-  projectUpgradeSchema: () => projectUpgradeSchema,
-  rangeValueDefinitionSchema: () => rangeValueDefinitionSchema,
-  readAssetSchema: () => readAssetSchema,
-  readCollectionSchema: () => readCollectionSchema,
-  readEntrySchema: () => readEntrySchema,
-  readGitTagSchema: () => readGitTagSchema,
-  readProjectSchema: () => readProjectSchema,
-  referencedValueSchema: () => referencedValueSchema,
-  resolvedReferencedValueSchema: () => resolvedReferencedValueSchema,
-  resolvedValueContentReferenceSchema: () => resolvedValueContentReferenceSchema,
-  resolvedValueSchema: () => resolvedValueSchema,
-  searchProjectSchema: () => searchProjectSchema,
-  serviceTypeSchema: () => serviceTypeSchema,
-  setRemoteOriginUrlProjectSchema: () => setRemoteOriginUrlProjectSchema,
-  setUserSchema: () => setUserSchema,
-  slug: () => slug,
-  stringValueDefinitionSchema: () => stringValueDefinitionSchema,
-  supportedAssetExtensionSchema: () => supportedAssetExtensionSchema,
-  supportedAssetMimeTypeSchema: () => supportedAssetMimeTypeSchema,
-  supportedAssetTypeSchema: () => supportedAssetTypeSchema,
-  supportedIconSchema: () => supportedIconSchema,
-  supportedLanguageSchema: () => supportedLanguageSchema,
-  switchBranchProjectSchema: () => switchBranchProjectSchema,
-  synchronizeProjectSchema: () => synchronizeProjectSchema,
-  telephoneValueDefinitionSchema: () => telephoneValueDefinitionSchema,
-  textValueDefinitionSchema: () => textValueDefinitionSchema,
-  textareaValueDefinitionSchema: () => textareaValueDefinitionSchema,
-  timeValueDefinitionSchema: () => timeValueDefinitionSchema,
-  toggleValueDefinitionSchema: () => toggleValueDefinitionSchema,
-  translatableArrayOf: () => translatableArrayOf,
-  translatableBooleanSchema: () => translatableBooleanSchema,
-  translatableNumberSchema: () => translatableNumberSchema,
-  translatableStringSchema: () => translatableStringSchema,
-  updateAssetSchema: () => updateAssetSchema,
-  updateCollectionSchema: () => updateCollectionSchema,
-  updateEntrySchema: () => updateEntrySchema,
-  updateProjectSchema: () => updateProjectSchema,
-  upgradeProjectSchema: () => upgradeProjectSchema,
-  urlValueDefinitionSchema: () => urlValueDefinitionSchema,
-  userFileSchema: () => userFileSchema,
-  userSchema: () => userSchema,
-  uuid: () => uuid,
-  uuidSchema: () => uuidSchema,
-  valueContentReferenceBase: () => valueContentReferenceBase,
-  valueContentReferenceSchema: () => valueContentReferenceSchema,
-  valueContentReferenceToAssetSchema: () => valueContentReferenceToAssetSchema,
-  valueContentReferenceToCollectionSchema: () => valueContentReferenceToCollectionSchema,
-  valueContentReferenceToEntrySchema: () => valueContentReferenceToEntrySchema,
-  valueContentReferenceWithLanguageBase: () => valueContentReferenceWithLanguageBase,
-  valueDefinitionSchema: () => valueDefinitionSchema,
-  valueSchema: () => valueSchema,
-  versionSchema: () => versionSchema
-});
-module.exports = __toCommonJS(index_node_exports);
-var import_fs_extra7 = __toESM(require("fs-extra"), 1);
-
-// src/schema/assetSchema.ts
-var import_zod3 = __toESM(require("zod"), 1);
-
-// src/schema/baseSchema.ts
-var import_zod = __toESM(require("zod"), 1);
-var environmentSchema = import_zod.default.enum(["production", "development", "test"]);
-var supportedLanguageSchema = import_zod.default.enum([
-  /**
-   * Bulgarian
-   */
-  "bg",
-  //
-  "cs",
-  // Czech
-  "da",
-  // Danish
-  "de",
-  // German
-  "el",
-  // Greek
-  "en",
-  // (US) English
-  "es",
-  // Spanish
-  "et",
-  // Estonian
-  "fi",
-  // Finnish
-  "fr",
-  // French
-  "hu",
-  // Hungarian
-  "it",
-  // Italian
-  "ja",
-  // Japanese
-  "lt",
-  // Lithuanian
-  "lv",
-  // Latvian
-  "nl",
-  // Dutch
-  "pl",
-  // Polish
-  "pt",
-  // Portuguese
-  "ro",
-  // Romanian
-  "ru",
-  // Russian
-  "sk",
-  // Slovak
-  "sl",
-  // Slovenian
-  "sv",
-  // Swedish
-  "zh"
-  // (Simplified) Chinese
-]);
-var supportedIconSchema = import_zod.default.enum(["home", "plus", "foobar"]);
-var supportedAssetMimeTypeSchema = import_zod.default.enum([
-  "image/avif",
-  "image/gif",
-  "image/jpeg",
-  "image/png",
-  "image/svg+xml",
-  "image/webp",
-  "application/pdf",
-  "application/zip",
-  "video/mp4",
-  "video/webm",
-  "audio/webm",
-  "audio/flac"
-]);
-var supportedAssetExtensionSchema = import_zod.default.enum([
-  "avif",
-  "gif",
-  "jpg",
-  "jpeg",
-  "png",
-  "svg",
-  "webp",
-  "pdf",
-  "zip",
-  "mp4",
-  "webm",
-  "flac",
-  "json"
-]);
-var supportedAssetTypeSchema = import_zod.default.object({
-  extension: supportedAssetExtensionSchema,
-  mimeType: supportedAssetMimeTypeSchema
-});
-var objectTypeSchema = import_zod.default.enum([
-  "project",
-  "asset",
-  "collection",
-  "entry",
-  "value",
-  "sharedValue"
-]);
-var versionSchema = import_zod.default.string();
-var uuidSchema = import_zod.default.string().uuid("shared.invalidUuid");
-var translatableStringSchema = import_zod.default.record(
-  supportedLanguageSchema,
-  import_zod.default.string().trim().min(1, "shared.translatableStringRequired")
-);
-var translatableNumberSchema = import_zod.default.record(
-  supportedLanguageSchema,
-  import_zod.default.number({ required_error: "shared.translatableNumberRequired" })
-);
-var translatableBooleanSchema = import_zod.default.record(
-  supportedLanguageSchema,
-  import_zod.default.boolean({ required_error: "shared.translatableBooleanRequired" })
-);
-function translatableArrayOf(schema) {
-  return import_zod.default.record(supportedLanguageSchema, import_zod.default.array(schema));
-}
-
-// src/schema/fileSchema.ts
-var import_zod2 = __toESM(require("zod"), 1);
-var baseFileSchema = import_zod2.default.object({
-  /**
-   * The ID of the file
-   *
-   * The ID is part of the files name.
-   */
-  id: uuidSchema.readonly(),
-  /**
-   * The timestamp of the file being created is set by the service of "objectType" while creating it
-   */
-  created: import_zod2.default.number().readonly(),
-  /**
-   * The timestamp of the file being updated is set by the service of "objectType" while updating it
-   */
-  updated: import_zod2.default.number().nullable()
-});
-var baseFileWithLanguageSchema = baseFileSchema.extend({
-  /**
-   * The language of the file
-   *
-   * The language is part of the files name and together with it's ID the only unique identifier.
-   * That's why the language cannot be changed after creating the file.
-   *
-   * @todo Maybe remove the above restriction by implementing logic to handle changing the files language inside all services
-   */
-  language: supportedLanguageSchema.readonly()
-});
-var fileReferenceSchema = import_zod2.default.object({
-  id: uuidSchema,
-  language: supportedLanguageSchema.optional(),
-  extension: supportedAssetExtensionSchema.optional()
-});
-
-// src/schema/assetSchema.ts
-var assetFileSchema = baseFileWithLanguageSchema.extend({
-  objectType: import_zod3.default.literal(objectTypeSchema.Enum.asset).readonly(),
-  name: import_zod3.default.string(),
-  description: import_zod3.default.string(),
-  extension: supportedAssetExtensionSchema.readonly(),
-  mimeType: supportedAssetMimeTypeSchema.readonly(),
-  /**
-   * Total size in bytes
-   */
-  size: import_zod3.default.number().readonly()
-});
-var assetSchema = assetFileSchema.extend({
-  /**
-   * Absolute path on this filesystem
-   */
-  absolutePath: import_zod3.default.string().readonly()
-});
-var assetExportSchema = assetSchema.extend({});
-var createAssetSchema = assetFileSchema.pick({
-  name: true,
-  description: true,
-  language: true
-}).extend({
-  projectId: uuidSchema.readonly(),
-  /**
-   * Path of the file to add as a new Asset
-   */
-  filePath: import_zod3.default.string().readonly()
-});
-var readAssetSchema = assetFileSchema.pick({
-  id: true,
-  language: true
-}).extend({
-  projectId: uuidSchema.readonly()
-});
-var updateAssetSchema = assetFileSchema.pick({
-  id: true,
-  name: true,
-  description: true,
-  language: true
-}).extend({
-  projectId: uuidSchema.readonly(),
-  /**
-   * Path of the new file to update the Asset with
-   */
-  newFilePath: import_zod3.default.string().readonly().optional()
-});
-var deleteAssetSchema = assetFileSchema.pick({
-  id: true,
-  language: true,
-  extension: true
-}).extend({
-  projectId: uuidSchema.readonly()
-});
-var countAssetsSchema = import_zod3.default.object({ projectId: uuidSchema.readonly() });
-
-// src/schema/collectionSchema.ts
-var import_zod6 = __toESM(require("zod"), 1);
-
-// src/schema/entrySchema.ts
-var import_zod5 = __toESM(require("zod"), 1);
-
-// src/schema/valueSchema.ts
-var import_zod4 = __toESM(require("zod"), 1);
-var ValueTypeSchema = import_zod4.default.enum([
-  "string",
-  "number",
-  "boolean",
-  "reference"
-]);
-var ValueInputTypeSchema = import_zod4.default.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 = import_zod4.default.enum(["12", "6", "4", "3"]);
-var ValueDefinitionBaseSchema = import_zod4.default.object({
-  id: uuidSchema.readonly(),
-  label: translatableStringSchema,
-  description: translatableStringSchema,
-  isRequired: import_zod4.default.boolean(),
-  isDisabled: import_zod4.default.boolean(),
-  isUnique: import_zod4.default.boolean(),
-  inputWidth: ValueInputWidthSchema
-});
-var StringValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend(
-  {
-    valueType: import_zod4.default.literal(ValueTypeSchema.Enum.string),
-    defaultValue: import_zod4.default.string().nullable()
-  }
-);
-var textValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
-  {
-    inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.text),
-    min: import_zod4.default.number().nullable(),
-    max: import_zod4.default.number().nullable()
-  }
-);
-var textareaValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.textarea),
-  min: import_zod4.default.number().nullable(),
-  max: import_zod4.default.number().nullable()
-});
-var emailValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.email),
-  defaultValue: import_zod4.default.string().email().nullable()
-});
-var urlValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.url),
-  defaultValue: import_zod4.default.string().url().nullable()
-});
-var ipValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.ip),
-  defaultValue: import_zod4.default.string().ip().nullable()
-});
-var dateValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
-  {
-    inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.date),
-    defaultValue: import_zod4.default.string().date().nullable()
-  }
-);
-var timeValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
-  {
-    inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.time),
-    defaultValue: import_zod4.default.string().time().nullable()
-  }
-);
-var datetimeValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.datetime),
-  defaultValue: import_zod4.default.string().datetime().nullable()
-});
-var telephoneValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.telephone)
-  // defaultValue: z.string().e164(), @todo when zod v4 releases @see https://github.com/colinhacks/zod/pull/3476
-});
-var stringValueDefinitionSchema = import_zod4.default.union([
-  textValueDefinitionSchema,
-  textareaValueDefinitionSchema,
-  emailValueDefinitionSchema,
-  urlValueDefinitionSchema,
-  ipValueDefinitionSchema,
-  dateValueDefinitionSchema,
-  timeValueDefinitionSchema,
-  datetimeValueDefinitionSchema,
-  telephoneValueDefinitionSchema
-]);
-var NumberValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend(
-  {
-    valueType: import_zod4.default.literal(ValueTypeSchema.Enum.number),
-    min: import_zod4.default.number().nullable(),
-    max: import_zod4.default.number().nullable(),
-    isUnique: import_zod4.default.literal(false),
-    defaultValue: import_zod4.default.number().nullable()
-  }
-);
-var numberValueDefinitionSchema = NumberValueDefinitionBaseSchema.extend({
-  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.number)
-});
-var rangeValueDefinitionSchema = NumberValueDefinitionBaseSchema.extend({
-  inputType: import_zod4.default.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: import_zod4.default.literal(true),
-  min: import_zod4.default.number(),
-  max: import_zod4.default.number(),
-  defaultValue: import_zod4.default.number()
-});
-var BooleanValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend({
-  valueType: import_zod4.default.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: import_zod4.default.literal(true),
-  defaultValue: import_zod4.default.boolean(),
-  isUnique: import_zod4.default.literal(false)
-});
-var toggleValueDefinitionSchema = BooleanValueDefinitionBaseSchema.extend({
-  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.toggle)
-});
-var ReferenceValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend({
-  valueType: import_zod4.default.literal(ValueTypeSchema.Enum.reference)
-});
-var assetValueDefinitionSchema = ReferenceValueDefinitionBaseSchema.extend({
-  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.asset),
-  allowedMimeTypes: import_zod4.default.array(supportedAssetMimeTypeSchema).min(1),
-  min: import_zod4.default.number().nullable(),
-  max: import_zod4.default.number().nullable()
-});
-var entryValueDefinitionSchema = ReferenceValueDefinitionBaseSchema.extend({
-  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.entry),
-  ofCollections: import_zod4.default.array(uuidSchema),
-  min: import_zod4.default.number().nullable(),
-  max: import_zod4.default.number().nullable()
-});
-var valueDefinitionSchema = import_zod4.default.union([
-  stringValueDefinitionSchema,
-  numberValueDefinitionSchema,
-  rangeValueDefinitionSchema,
-  toggleValueDefinitionSchema,
-  assetValueDefinitionSchema,
-  entryValueDefinitionSchema
-  // sharedValueDefinitionSchema,
-]);
-var valueContentReferenceBase = import_zod4.default.object({
-  id: uuidSchema
-});
-var valueContentReferenceWithLanguageBase = valueContentReferenceBase.extend({
-  language: supportedLanguageSchema
-});
-var valueContentReferenceToAssetSchema = valueContentReferenceWithLanguageBase.extend({
-  objectType: import_zod4.default.literal(objectTypeSchema.Enum.asset)
-});
-var valueContentReferenceToCollectionSchema = valueContentReferenceBase.extend({
-  objectType: import_zod4.default.literal(objectTypeSchema.Enum.collection)
-});
-var valueContentReferenceToEntrySchema = valueContentReferenceBase.extend({
-  objectType: import_zod4.default.literal(objectTypeSchema.Enum.entry)
-});
-var valueContentReferenceSchema = import_zod4.default.union([
-  valueContentReferenceToAssetSchema,
-  valueContentReferenceToCollectionSchema,
-  valueContentReferenceToEntrySchema
-  // valueContentReferenceToSharedValueSchema,
-]);
-var resolvedValueContentReferenceSchema = import_zod4.default.union([
-  assetSchema,
-  import_zod4.default.lazy(() => entrySchema)
-  // Circular dependency / recursive type @see https://github.com/colinhacks/zod?tab=readme-ov-file#recursive-types
-  // resolvedValueContentReferenceToSharedValueSchema,
-]);
-var directValueBaseSchema = import_zod4.default.object({
-  objectType: import_zod4.default.literal(objectTypeSchema.Enum.value).readonly(),
-  definitionId: uuidSchema.readonly()
-});
-var directStringValueSchema = directValueBaseSchema.extend({
-  valueType: import_zod4.default.literal(ValueTypeSchema.Enum.string).readonly(),
-  content: translatableStringSchema
-});
-var directNumberValueSchema = directValueBaseSchema.extend({
-  valueType: import_zod4.default.literal(ValueTypeSchema.Enum.number).readonly(),
-  content: translatableNumberSchema
-});
-var directBooleanValueSchema = directValueBaseSchema.extend({
-  valueType: import_zod4.default.literal(ValueTypeSchema.Enum.boolean).readonly(),
-  content: translatableBooleanSchema
-});
-var directValueSchema = import_zod4.default.union([
-  directStringValueSchema,
-  directNumberValueSchema,
-  directBooleanValueSchema
-]);
-var referencedValueSchema = import_zod4.default.object({
-  objectType: import_zod4.default.literal(objectTypeSchema.Enum.value).readonly(),
-  definitionId: uuidSchema.readonly(),
-  valueType: import_zod4.default.literal(ValueTypeSchema.Enum.reference).readonly(),
-  content: translatableArrayOf(valueContentReferenceSchema)
-});
-var valueSchema = import_zod4.default.union([directValueSchema, referencedValueSchema]);
-var resolvedReferencedValueSchema = referencedValueSchema.extend({
-  content: translatableArrayOf(resolvedValueContentReferenceSchema)
-});
-var resolvedValueSchema = import_zod4.default.union([
-  directValueSchema,
-  resolvedReferencedValueSchema
-]);
-function getValueContentSchemaFromDefinition(definition) {
-  switch (definition.valueType) {
-    case ValueTypeSchema.Enum.boolean:
-      return getBooleanValueContentSchema(definition);
-    case ValueTypeSchema.Enum.number:
-      return getNumberValueContentSchema(definition);
-    case ValueTypeSchema.Enum.string:
-      return getStringValueContentSchema(definition);
-    case ValueTypeSchema.Enum.reference:
-      return getReferenceValueContentSchema(definition);
-    default:
-      throw new Error(
-        // @ts-expect-error
-        `Error generating schema for unsupported ValueType "${definition.valueType}"`
-      );
-  }
-}
-function getBooleanValueContentSchema(definition) {
-  return import_zod4.default.boolean();
-}
-function getNumberValueContentSchema(definition) {
-  let schema = import_zod4.default.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 = import_zod4.default.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:
-      schema = schema.email();
-      break;
-    case ValueInputTypeSchema.Enum.url:
-      schema = schema.url();
-      break;
-    case ValueInputTypeSchema.Enum.ip:
-      schema = schema.ip();
-      break;
-    case ValueInputTypeSchema.Enum.date:
-      schema = schema.date();
-      break;
-    case ValueInputTypeSchema.Enum.time:
-      schema = schema.time();
-      break;
-    case ValueInputTypeSchema.Enum.datetime:
-      schema = schema.datetime();
-      break;
-    case ValueInputTypeSchema.Enum.telephone:
-      break;
-  }
-  if (definition.isRequired === false) {
-    return schema.nullable();
-  }
-  return schema.min(1, "shared.stringValueRequired");
-}
-function getReferenceValueContentSchema(definition) {
-  let schema;
-  switch (definition.inputType) {
-    case ValueInputTypeSchema.Enum.asset:
-      {
-        schema = import_zod4.default.array(valueContentReferenceToAssetSchema);
-      }
-      break;
-    case ValueInputTypeSchema.Enum.entry:
-      {
-        schema = import_zod4.default.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/entrySchema.ts
-var entryFileSchema = baseFileSchema.extend({
-  objectType: import_zod5.default.literal(objectTypeSchema.Enum.entry).readonly(),
-  values: import_zod5.default.array(valueSchema)
-});
-var entrySchema = entryFileSchema.extend({
-  values: import_zod5.default.array(import_zod5.default.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: import_zod5.default.array(valueSchema)
-});
-var readEntrySchema = import_zod5.default.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 = import_zod5.default.object({
-  projectId: uuidSchema.readonly(),
-  collectionId: uuidSchema.readonly()
-});
-
-// src/schema/collectionSchema.ts
-var collectionFileSchema = baseFileSchema.extend({
-  objectType: import_zod6.default.literal(objectTypeSchema.Enum.collection).readonly(),
-  name: import_zod6.default.object({
-    singular: translatableStringSchema,
-    plural: translatableStringSchema
-  }),
-  slug: import_zod6.default.object({
-    singular: import_zod6.default.string(),
-    plural: import_zod6.default.string()
-  }),
-  description: translatableStringSchema,
-  icon: supportedIconSchema,
-  valueDefinitions: import_zod6.default.array(valueDefinitionSchema)
-});
-var collectionSchema = collectionFileSchema.extend({});
-var collectionExportSchema = collectionSchema.extend({
-  entries: import_zod6.default.array(entryExportSchema)
-});
-var createCollectionSchema = collectionSchema.omit({
-  id: true,
-  objectType: true,
-  created: true,
-  updated: true
-}).extend({
-  projectId: uuidSchema.readonly()
-});
-var readCollectionSchema = import_zod6.default.object({
-  id: uuidSchema.readonly(),
-  projectId: uuidSchema.readonly()
-});
-var updateCollectionSchema = collectionFileSchema.pick({
-  id: true,
-  name: true,
-  slug: true,
-  description: true,
-  icon: true,
-  valueDefinitions: true
-}).extend({
-  projectId: uuidSchema.readonly()
-});
-var deleteCollectionSchema = readCollectionSchema.extend({});
-var countCollectionsSchema = import_zod6.default.object({
-  projectId: uuidSchema.readonly()
-});
-
-// src/schema/coreSchema.ts
-var import_zod7 = require("zod");
-var elekIoCoreOptionsSchema = import_zod7.z.object({
-  /**
-   * The environment elek.io Core is currently running in
-   */
-  environment: environmentSchema,
-  /**
-   * The current version of elek.io Core
-   */
-  version: versionSchema,
-  file: import_zod7.z.object({
-    json: import_zod7.z.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: import_zod7.z.union([import_zod7.z.number(), import_zod7.z.string()])
-    })
-  })
-});
-var constructorElekIoCoreSchema = elekIoCoreOptionsSchema.omit({
-  version: true
-}).partial({
-  environment: true,
-  file: true
-}).optional();
-
-// src/schema/gitSchema.ts
-var import_zod8 = require("zod");
-var gitRepositoryPathSchema = import_zod8.z.string();
-var gitSignatureSchema = import_zod8.z.object({
-  name: import_zod8.z.string(),
-  email: import_zod8.z.string()
-});
-var gitCommitSchema = import_zod8.z.object({
-  /**
-   * SHA-1 hash of the commit
-   */
-  hash: import_zod8.z.string(),
-  message: import_zod8.z.string(),
-  author: gitSignatureSchema,
-  timestamp: import_zod8.z.number(),
-  tag: import_zod8.z.string().nullable()
-});
-var GitCommitIconNative = /* @__PURE__ */ ((GitCommitIconNative2) => {
-  GitCommitIconNative2["INIT"] = ":tada:";
-  GitCommitIconNative2["CREATE"] = ":heavy_plus_sign:";
-  GitCommitIconNative2["UPDATE"] = ":wrench:";
-  GitCommitIconNative2["DELETE"] = ":fire:";
-  return GitCommitIconNative2;
-})(GitCommitIconNative || {});
-var gitCommitIconSchema = import_zod8.z.nativeEnum(GitCommitIconNative);
-var gitInitOptionsSchema = import_zod8.z.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: import_zod8.z.string()
-});
-var gitCloneOptionsSchema = import_zod8.z.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: import_zod8.z.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: import_zod8.z.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: import_zod8.z.string()
-});
-var gitSwitchOptionsSchema = import_zod8.z.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: import_zod8.z.boolean().optional()
-});
-var gitLogOptionsSchema = import_zod8.z.object({
-  /**
-   * Limit the result to given number of commits
-   */
-  limit: import_zod8.z.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: import_zod8.z.object({
-    /**
-     * From the oldest commit
-     */
-    from: import_zod8.z.string(),
-    /**
-     * To the newest commit
-     *
-     * Defaults to the current HEAD
-     */
-    to: import_zod8.z.string().optional()
-  })
-});
-
-// src/schema/gitTagSchema.ts
-var import_zod9 = require("zod");
-var gitTagSchema = import_zod9.z.object({
-  id: uuidSchema,
-  message: import_zod9.z.string(),
-  author: gitSignatureSchema,
-  timestamp: import_zod9.z.number()
-});
-var createGitTagSchema = gitTagSchema.pick({
-  message: true
-}).extend({
-  path: gitRepositoryPathSchema,
-  hash: gitCommitSchema.shape.hash.optional()
-});
-var readGitTagSchema = import_zod9.z.object({
-  path: gitRepositoryPathSchema,
-  id: uuidSchema.readonly()
-});
-var deleteGitTagSchema = readGitTagSchema.extend({});
-var countGitTagsSchema = import_zod9.z.object({
-  path: gitRepositoryPathSchema
-});
-
-// src/schema/projectSchema.ts
-var import_zod10 = require("zod");
-var projectStatusSchema = import_zod10.z.enum(["foo", "bar", "todo"]);
-var projectSettingsSchema = import_zod10.z.object({
-  language: import_zod10.z.object({
-    default: supportedLanguageSchema,
-    supported: import_zod10.z.array(supportedLanguageSchema)
-  })
-});
-var projectFolderSchema = import_zod10.z.enum([
-  "assets",
-  "collections",
-  "shared-values",
-  "lfs"
-  // 'logs',
-  // 'public',
-  // 'theme',
-]);
-var projectFileSchema = baseFileSchema.extend({
-  objectType: import_zod10.z.literal(objectTypeSchema.Enum.project).readonly(),
-  coreVersion: versionSchema,
-  name: import_zod10.z.string().trim().min(1, "shared.projectNameRequired"),
-  description: import_zod10.z.string().trim().min(1, "shared.projectDescriptionRequired"),
-  version: versionSchema,
-  status: projectStatusSchema,
-  settings: projectSettingsSchema
-});
-var projectSchema = projectFileSchema.extend({});
-var projectExportSchema = projectSchema.extend({
-  assets: import_zod10.z.array(assetExportSchema),
-  collections: import_zod10.z.array(collectionExportSchema)
-});
-var createProjectSchema = projectSchema.pick({
-  name: true,
-  description: true,
-  settings: true
-}).partial({
-  description: true,
-  settings: true
-});
-var readProjectSchema = import_zod10.z.object({
-  id: uuidSchema.readonly()
-});
-var updateProjectSchema = projectSchema.pick({
-  id: true,
-  name: true,
-  description: true,
-  settings: true
-}).partial({
-  name: true,
-  description: true,
-  settings: true
-});
-var upgradeProjectSchema = import_zod10.z.object({
-  id: uuidSchema.readonly()
-});
-var deleteProjectSchema = readProjectSchema.extend({});
-var projectUpgradeSchema = import_zod10.z.object({
-  /**
-   * The Core version the Project will be upgraded to
-   */
-  to: versionSchema.readonly(),
-  /**
-   * Function that will be executed in the process of upgrading a Project
-   */
-  run: import_zod10.z.function().args(projectFileSchema).returns(import_zod10.z.promise(import_zod10.z.void()))
-});
-var cloneProjectSchema = import_zod10.z.object({
-  url: import_zod10.z.string()
-});
-var listBranchesProjectSchema = import_zod10.z.object({
-  id: uuidSchema.readonly()
-});
-var currentBranchProjectSchema = import_zod10.z.object({
-  id: uuidSchema.readonly()
-});
-var switchBranchProjectSchema = import_zod10.z.object({
-  id: uuidSchema.readonly(),
-  branch: import_zod10.z.string(),
-  options: gitSwitchOptionsSchema.optional()
-});
-var getRemoteOriginUrlProjectSchema = import_zod10.z.object({
-  id: uuidSchema.readonly()
-});
-var setRemoteOriginUrlProjectSchema = import_zod10.z.object({
-  id: uuidSchema.readonly(),
-  url: import_zod10.z.string()
-});
-var getChangesProjectSchema = import_zod10.z.object({
-  id: uuidSchema.readonly()
-});
-var synchronizeProjectSchema = import_zod10.z.object({
-  id: uuidSchema.readonly()
-});
-var searchProjectSchema = import_zod10.z.object({
-  id: uuidSchema.readonly(),
-  query: import_zod10.z.string(),
-  language: supportedLanguageSchema,
-  type: import_zod10.z.array(objectTypeSchema).optional()
-});
-
-// src/schema/serviceSchema.ts
-var import_zod11 = require("zod");
-var serviceTypeSchema = import_zod11.z.enum([
-  "Git",
-  "GitTag",
-  "User",
-  "Project",
-  "Asset",
-  "JsonFile",
-  "Search",
-  "Collection",
-  "Entry",
-  "Value"
-]);
-var listSchema = import_zod11.z.object({
-  projectId: uuidSchema,
-  limit: import_zod11.z.number().optional(),
-  offset: import_zod11.z.number().optional()
-});
-var listCollectionsSchema = listSchema;
-var listEntriesSchema = listSchema.extend({
-  collectionId: uuidSchema
-});
-var listAssetsSchema = listSchema;
-var listProjectsSchema = listSchema.omit({
-  projectId: true
-});
-var listGitTagsSchema = import_zod11.z.object({
-  path: gitRepositoryPathSchema
-});
-
-// src/schema/userSchema.ts
-var import_zod12 = __toESM(require("zod"), 1);
-var UserTypeSchema = import_zod12.default.enum(["local", "cloud"]);
-var baseUserSchema = gitSignatureSchema.extend({
-  userType: UserTypeSchema,
-  language: supportedLanguageSchema
-});
-var localUserSchema = baseUserSchema.extend({
-  userType: import_zod12.default.literal(UserTypeSchema.Enum.local)
-});
-var cloudUserSchema = baseUserSchema.extend({
-  userType: import_zod12.default.literal(UserTypeSchema.Enum.cloud),
-  id: uuidSchema
-});
-var userFileSchema = import_zod12.default.union([localUserSchema, cloudUserSchema]);
-var userSchema = userFileSchema;
-var setUserSchema = userSchema;
-
-// src/error/GitError.ts
-var GitError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "GitError";
-  }
-};
-
-// src/error/NoCurrentUserError.ts
-var NoCurrentUserError = class extends Error {
-  constructor() {
-    super("Make sure to set a User via Core before using other methods");
-    this.name = "NoCurrentUserError";
-  }
-};
-
-// src/error/ProjectUpgradeError.ts
-var ProjectUpgradeError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ProjectUpgradeError";
-  }
-};
-
-// src/error/RequiredParameterMissingError.ts
-var RequiredParameterMissingError = class extends Error {
-  constructor(parameter) {
-    super(`Missing required parameter "${parameter}"`);
-    this.name = "RequiredParameterMissingError";
-  }
-};
-
-// src/util/node.ts
-var node_exports = {};
-__export(node_exports, {
-  assignDefaultIfMissing: () => assignDefaultIfMissing,
-  files: () => files,
-  folders: () => folders,
-  isNoError: () => isNoError,
-  notEmpty: () => notEmpty,
-  pathTo: () => pathTo,
-  returnResolved: () => returnResolved,
-  spawnChildProcess: () => spawnChildProcess,
-  workingDirectory: () => workingDirectory
-});
-var import_child_process = require("child_process");
-var import_fs_extra = __toESM(require("fs-extra"), 1);
-var import_os = __toESM(require("os"), 1);
-var import_path = __toESM(require("path"), 1);
-var workingDirectory = import_path.default.join(import_os.default.homedir(), "elek.io");
-var pathTo = {
-  tmp: import_path.default.join(workingDirectory, "tmp"),
-  userFile: import_path.default.join(workingDirectory, "user.json"),
-  // logs: Path.join(workingDirectory, 'logs'),
-  projects: import_path.default.join(workingDirectory, "projects"),
-  project: (projectId) => {
-    return import_path.default.join(pathTo.projects, projectId);
-  },
-  projectFile: (projectId) => {
-    return import_path.default.join(pathTo.project(projectId), "project.json");
-  },
-  // projectLogs: (projectId: string): string => {
-  //   return Path.join(pathTo.project(projectId), projectFolderSchema.Enum.logs);
-  // },
-  // public: (projectId: string): string => {
-  //   return Path.join(pathTo.project(projectId), 'public');
-  // },
-  lfs: (projectId) => {
-    return import_path.default.join(pathTo.project(projectId), projectFolderSchema.Enum.lfs);
-  },
-  collections: (projectId) => {
-    return import_path.default.join(
-      pathTo.project(projectId),
-      projectFolderSchema.Enum.collections
-    );
-  },
-  collection: (projectId, id) => {
-    return import_path.default.join(pathTo.collections(projectId), id);
-  },
-  collectionFile: (projectId, id) => {
-    return import_path.default.join(pathTo.collection(projectId, id), "collection.json");
-  },
-  entries: (projectId, collectionId) => {
-    return import_path.default.join(pathTo.collection(projectId, collectionId));
-  },
-  entryFile: (projectId, collectionId, id) => {
-    return import_path.default.join(pathTo.entries(projectId, collectionId), `${id}.json`);
-  },
-  sharedValues: (projectId) => {
-    return import_path.default.join(pathTo.project(projectId), "shared-values");
-  },
-  sharedValueFile: (projectId, id, language) => {
-    return import_path.default.join(pathTo.sharedValues(projectId), `${id}.${language}.json`);
-  },
-  assets: (projectId) => {
-    return import_path.default.join(
-      pathTo.project(projectId),
-      projectFolderSchema.Enum.assets
-    );
-  },
-  assetFile: (projectId, id, language) => {
-    return import_path.default.join(pathTo.assets(projectId), `${id}.${language}.json`);
-  },
-  asset: (projectId, id, language, extension) => {
-    return import_path.default.join(pathTo.lfs(projectId), `${id}.${language}.${extension}`);
-  }
-};
-function assignDefaultIfMissing(value, defaultsTo) {
-  return Object.assign(defaultsTo, value);
-}
-function notEmpty(value) {
-  if (value === null || value === void 0) {
-    return false;
-  }
-  if (typeof value === "string") {
-    if (value.trim() === "") {
-      return false;
-    }
-  }
-  return true;
-}
-function isNoError(item) {
-  return item instanceof Error !== true;
-}
-async function returnResolved(promises) {
-  const toCheck = [];
-  for (let index = 0; index < promises.length; index++) {
-    const promise = promises[index];
-    if (!promise) {
-      throw new Error(`No promise found at index "${index}"`);
-    }
-    toCheck.push(
-      promise.then((result) => {
-        return result;
-      }).catch((error) => {
-        return new Error(error);
-      })
-    );
-  }
-  const checked = await Promise.all(toCheck);
-  return checked.filter(isNoError);
-}
-function spawnChildProcess(command, args, options) {
-  return new Promise((resolve, reject) => {
-    const childProcess = (0, import_child_process.spawn)(command, args, options);
-    let log = "";
-    childProcess.stdout.on("data", (data) => {
-      log += data;
-    });
-    childProcess.stderr.on("data", (data) => {
-      log += data;
-    });
-    childProcess.on("error", (error) => {
-      throw error;
-    });
-    childProcess.on("exit", (code) => {
-      if (code === 0) {
-        return resolve(log);
-      }
-      return reject(log);
-    });
-  });
-}
-async function folders(path) {
-  const dirent = await import_fs_extra.default.readdir(path, { withFileTypes: true });
-  return dirent.filter((dirent2) => {
-    return dirent2.isDirectory();
-  });
-}
-async function files(path, extension) {
-  const dirent = await import_fs_extra.default.readdir(path, { withFileTypes: true });
-  return dirent.filter((dirent2) => {
-    if (extension && dirent2.isFile() === true) {
-      if (dirent2.name.endsWith(extension)) {
-        return true;
-      }
-      return false;
-    }
-    return dirent2.isFile();
-  });
-}
-
-// src/service/AbstractCrudService.ts
-var AbstractCrudService = class {
-  /**
-   * Do not instantiate directly as this is an abstract class
-   */
-  constructor(type, options) {
-    this.type = type;
-    this.options = options;
-    this.gitMessage = {
-      create: `${gitCommitIconSchema.enum.CREATE} Created ${this.type}`,
-      update: `${gitCommitIconSchema.enum.UPDATE} Updated ${this.type}`,
-      delete: `${gitCommitIconSchema.enum.DELETE} Deleted ${this.type}`
-    };
-  }
-  /**
-   * Returns a list of all file references of given project and type
-   *
-   * @param type File type of the references wanted
-   * @param projectId Project to get all asset references from
-   * @param collectionId Only needed when requesting files of type "Entry"
-   */
-  async listReferences(type, projectId, collectionId) {
-    switch (type) {
-      case objectTypeSchema.Enum.asset:
-        if (!projectId) {
-          throw new RequiredParameterMissingError("projectId");
-        }
-        return this.getFileReferences(pathTo.lfs(projectId));
-      case objectTypeSchema.Enum.project:
-        return this.getFolderReferences(pathTo.projects);
-      case objectTypeSchema.Enum.collection:
-        if (!projectId) {
-          throw new RequiredParameterMissingError("projectId");
-        }
-        return this.getFolderReferences(pathTo.collections(projectId));
-      case objectTypeSchema.Enum.entry:
-        if (!projectId) {
-          throw new RequiredParameterMissingError("projectId");
-        }
-        if (!collectionId) {
-          throw new RequiredParameterMissingError("collectionId");
-        }
-        return this.getFileReferences(
-          pathTo.collection(projectId, collectionId)
-        );
-      case objectTypeSchema.Enum.sharedValue:
-        if (!projectId) {
-          throw new RequiredParameterMissingError("projectId");
-        }
-        return this.getFileReferences(pathTo.sharedValues(projectId));
-      default:
-        throw new Error(`Trying to list files of unsupported type "${type}"`);
-    }
-  }
-  async getFolderReferences(path) {
-    const possibleFolders = await folders(path);
-    const results = possibleFolders.map((possibleFolder) => {
-      const folderReference = {
-        id: possibleFolder.name
-      };
-      try {
-        return fileReferenceSchema.parse(folderReference);
-      } catch (error) {
-        return null;
-      }
-    });
-    return results.filter(notEmpty);
-  }
-  /**
-   * Searches for all files inside given folder,
-   * parses their names and returns them as FileReference
-   *
-   * Ignores files not matching the [id].[language].[extension]
-   * or [id].[extension] format for their names
-   */
-  async getFileReferences(path) {
-    const possibleFiles = await files(path);
-    const results = await Promise.all(
-      possibleFiles.map(async (possibleFile) => {
-        const fileNameArray = possibleFile.name.split(".");
-        const fileReference = {
-          id: fileNameArray[0],
-          language: fileNameArray.length === 3 ? fileNameArray[1] : void 0,
-          extension: fileNameArray.length === 2 ? fileNameArray[1] : fileNameArray[2]
-        };
-        try {
-          return fileReferenceSchema.parse(fileReference);
-        } catch (error) {
-          return null;
-        }
-      })
-    );
-    return results.filter(notEmpty);
-  }
-};
-
-// src/service/AssetService.ts
-var import_fs_extra3 = __toESM(require("fs-extra"), 1);
-var import_is_svg = __toESM(require("is-svg"), 1);
-
-// src/util/shared.ts
-var import_slugify = __toESM(require("slugify"), 1);
-var import_uuid = require("uuid");
-var Slugify = import_slugify.default.default || import_slugify.default;
-function uuid() {
-  return (0, import_uuid.v4)();
-}
-function currentTimestamp() {
-  return Math.floor(Date.now() / 1e3);
-}
-function slug(string) {
-  return Slugify(string, {
-    replacement: "-",
-    // replace spaces with replacement character, defaults to `-`
-    remove: void 0,
-    // 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`
-  });
-}
-
-// src/service/JsonFileService.ts
-var import_fs_extra2 = __toESM(require("fs-extra"), 1);
-var JsonFileService = class extends AbstractCrudService {
-  constructor(options) {
-    super(serviceTypeSchema.Enum.JsonFile, options);
-    this.cache = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Creates a new file on disk. Fails if path already exists
-   *
-   * @param data Data to write into the file
-   * @param path Path to write the file to
-   * @param schema Schema of the file to validate against
-   * @returns Validated content of the file from disk
-   */
-  async create(data, path, schema) {
-    const parsedData = schema.parse(data);
-    const string = this.serialize(parsedData);
-    await import_fs_extra2.default.writeFile(path, string, {
-      flag: "wx",
-      encoding: "utf8"
-    });
-    this.cache.set(path, parsedData);
-    return parsedData;
-  }
-  /**
-   * Reads the content of a file on disk. Fails if path does not exist
-   *
-   * @param path Path to read the file from
-   * @param schema Schema of the file to validate against
-   * @returns Validated content of the file from disk
-   */
-  async read(path, schema) {
-    if (this.cache.has(path)) {
-      return this.cache.get(path);
-    }
-    const data = await import_fs_extra2.default.readFile(path, {
-      flag: "r",
-      encoding: "utf8"
-    });
-    const json = this.deserialize(data);
-    const parsedData = schema.parse(json);
-    this.cache.set(path, parsedData);
-    return parsedData;
-  }
-  /**
-   * Overwrites an existing file on disk
-   *
-   * @todo Check how to error out if the file does not exist already
-   *
-   * @param data Data to write into the file
-   * @param path Path to the file to overwrite
-   * @param schema Schema of the file to validate against
-   * @returns Validated content of the file from disk
-   */
-  async update(data, path, schema) {
-    const parsedData = schema.parse(data);
-    const string = this.serialize(parsedData);
-    await import_fs_extra2.default.writeFile(path, string, {
-      flag: "w",
-      encoding: "utf8"
-    });
-    this.cache.set(path, parsedData);
-    return parsedData;
-  }
-  serialize(data) {
-    return JSON.stringify(data, null, this.options.file.json.indentation);
-  }
-  deserialize(data) {
-    return JSON.parse(data);
-  }
-};
-
-// src/service/AssetService.ts
-var AssetService = class extends AbstractCrudService {
-  constructor(options, jsonFileService, gitService) {
-    super(serviceTypeSchema.Enum.Asset, options);
-    this.jsonFileService = jsonFileService;
-    this.gitService = gitService;
-  }
-  /**
-   * Creates a new Asset
-   */
-  async create(props) {
-    createAssetSchema.parse(props);
-    const id = uuid();
-    const projectPath = pathTo.project(props.projectId);
-    const fileType = await this.getSupportedFileTypeOrThrow(props.filePath);
-    const size = await this.getAssetSize(props.filePath);
-    const assetPath = pathTo.asset(
-      props.projectId,
-      id,
-      props.language,
-      fileType.extension
-    );
-    const assetFilePath = pathTo.assetFile(props.projectId, id, props.language);
-    const assetFile = {
-      ...props,
-      objectType: "asset",
-      id,
-      created: currentTimestamp(),
-      updated: null,
-      extension: fileType.extension,
-      mimeType: fileType.mimeType,
-      size
-    };
-    try {
-      await import_fs_extra3.default.copyFile(props.filePath, assetPath);
-      await this.jsonFileService.create(
-        assetFile,
-        assetFilePath,
-        assetFileSchema
-      );
-    } catch (error) {
-      await this.delete({ ...assetFile, projectId: props.projectId });
-      throw error;
-    }
-    await this.gitService.add(projectPath, [assetFilePath, assetPath]);
-    await this.gitService.commit(projectPath, this.gitMessage.create);
-    return this.toAsset(props.projectId, assetFile);
-  }
-  /**
-   * Returns an Asset by ID and language
-   */
-  async read(props) {
-    readAssetSchema.parse(props);
-    const assetFile = await this.jsonFileService.read(
-      pathTo.assetFile(props.projectId, props.id, props.language),
-      assetFileSchema
-    );
-    return this.toAsset(props.projectId, assetFile);
-  }
-  /**
-   * Updates given Asset
-   *
-   * Use the optional "newFilePath" prop to update the Asset itself
-   */
-  async update(props) {
-    updateAssetSchema.parse(props);
-    const projectPath = pathTo.project(props.projectId);
-    const assetFilePath = pathTo.assetFile(
-      props.projectId,
-      props.id,
-      props.language
-    );
-    const prevAssetFile = await this.read(props);
-    const assetFile = {
-      ...prevAssetFile,
-      ...props,
-      updated: currentTimestamp()
-    };
-    if (props.newFilePath) {
-      const fileType = await this.getSupportedFileTypeOrThrow(
-        props.newFilePath
-      );
-      const size = await this.getAssetSize(props.newFilePath);
-      const prevAssetPath = pathTo.asset(
-        props.projectId,
-        props.id,
-        props.language,
-        prevAssetFile.extension
-      );
-      const assetPath = pathTo.asset(
-        props.projectId,
-        props.id,
-        props.language,
-        fileType.extension
-      );
-      await import_fs_extra3.default.remove(prevAssetPath);
-      await import_fs_extra3.default.copyFile(props.newFilePath, assetPath);
-      assetFile.extension = fileType.extension;
-      assetFile.mimeType = fileType.mimeType;
-      assetFile.size = size;
-    }
-    await this.jsonFileService.update(
-      assetFile,
-      assetFilePath,
-      assetFileSchema
-    );
-    await this.gitService.add(projectPath, [assetFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.update);
-    return this.toAsset(props.projectId, assetFile);
-  }
-  /**
-   * Deletes given Asset
-   */
-  async delete(props) {
-    deleteAssetSchema.parse(props);
-    const projectPath = pathTo.project(props.projectId);
-    const assetFilePath = pathTo.assetFile(
-      props.projectId,
-      props.id,
-      props.language
-    );
-    const assetPath = pathTo.asset(
-      props.projectId,
-      props.id,
-      props.language,
-      props.extension
-    );
-    await import_fs_extra3.default.remove(assetPath);
-    await import_fs_extra3.default.remove(assetFilePath);
-    await this.gitService.add(projectPath, [assetFilePath, assetPath]);
-    await this.gitService.commit(projectPath, this.gitMessage.delete);
-  }
-  async list(props) {
-    listAssetsSchema.parse(props);
-    const offset = props.offset || 0;
-    const limit = props.limit || 15;
-    const assetReferences = await this.listReferences(
-      objectTypeSchema.Enum.asset,
-      props.projectId
-    );
-    const partialAssetReferences = assetReferences.slice(offset, limit);
-    const assets = await returnResolved(
-      partialAssetReferences.map((assetReference) => {
-        if (!assetReference.language) {
-          throw new RequiredParameterMissingError("language");
-        }
-        return this.read({
-          projectId: props.projectId,
-          id: assetReference.id,
-          language: assetReference.language
-        });
-      })
-    );
-    return {
-      total: assetReferences.length,
-      limit,
-      offset,
-      list: assets
-    };
-  }
-  async count(props) {
-    countAssetsSchema.parse(props);
-    const count = (await this.listReferences(objectTypeSchema.Enum.asset, props.projectId)).length;
-    return count;
-  }
-  /**
-   * Checks if given object is of type Asset
-   */
-  isAsset(obj) {
-    return assetSchema.safeParse(obj).success;
-  }
-  /**
-   * Returns the size of an Asset in bytes
-   *
-   * @param path Path of the Asset to get the size from
-   */
-  async getAssetSize(path) {
-    return (await import_fs_extra3.default.stat(path)).size;
-  }
-  /**
-   * Creates an Asset from given AssetFile
-   *
-   * @param projectId   The project's ID
-   * @param assetFile   The AssetFile to convert
-   */
-  async toAsset(projectId, assetFile) {
-    const assetPath = pathTo.asset(
-      projectId,
-      assetFile.id,
-      assetFile.language,
-      assetFile.extension
-    );
-    const asset = {
-      ...assetFile,
-      absolutePath: assetPath
-    };
-    return asset;
-  }
-  /**
-   * Returns the found and supported extension as well as mime type,
-   * otherwise throws an error
-   *
-   * @param filePath Path to the file to check
-   */
-  async getSupportedFileTypeOrThrow(filePath) {
-    const fileSize = (await import_fs_extra3.default.stat(filePath)).size;
-    if (fileSize / 1e3 <= 500) {
-      const fileBuffer = await import_fs_extra3.default.readFile(filePath);
-      if ((0, import_is_svg.default)(fileBuffer.toString()) === true) {
-        return {
-          extension: supportedAssetExtensionSchema.Enum.svg,
-          mimeType: supportedAssetMimeTypeSchema.Enum["image/svg+xml"]
-        };
-      }
-    }
-    const { fileTypeFromFile } = await import("file-type");
-    const fileType = await fileTypeFromFile(filePath);
-    const result = supportedAssetTypeSchema.parse({
-      extension: fileType?.ext,
-      mimeType: fileType?.mime
-    });
-    return result;
-  }
-};
-
-// src/service/CollectionService.ts
-var import_fs_extra4 = __toESM(require("fs-extra"), 1);
-
-// src/service/GitService.ts
-var import_dugite = require("dugite");
-var import_os3 = require("os");
-var import_p_queue = __toESM(require("p-queue"), 1);
-
-// src/service/GitTagService.ts
-var import_os2 = require("os");
-var GitTagService = class extends AbstractCrudService {
-  constructor(options, git) {
-    super(serviceTypeSchema.Enum.GitTag, options);
-    this.git = git;
-  }
-  /**
-   * Creates a new tag
-   *
-   * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---annotate
-   */
-  async create(props) {
-    createGitTagSchema.parse(props);
-    const id = uuid();
-    let args = ["tag", "--annotate", id];
-    if (props.hash) {
-      args = [...args, props.hash];
-    }
-    args = [...args, "-m", props.message];
-    await this.git(props.path, args);
-    const tag = await this.read({ path: props.path, id });
-    return tag;
-  }
-  /**
-   * Returns a tag by ID
-   *
-   * Internally uses list() but only returns the tag with matching ID.
-   */
-  async read(props) {
-    readGitTagSchema.parse(props);
-    const tags = await this.list({ path: props.path });
-    const tag = tags.list.find((tag2) => {
-      return tag2.id === props.id;
-    });
-    if (!tag) {
-      throw new GitError(
-        `Provided tag with UUID "${props.id}" did not match any known tags`
-      );
-    }
-    return tag;
-  }
-  /**
-   * Updating a git tag is not supported.
-   * Please delete the old and create a new one
-   *
-   * @see https://git-scm.com/docs/git-tag#_on_re_tagging
-   */
-  async update() {
-    throw new Error(
-      "Updating a git tag is not supported. Please delete the old and create a new one"
-    );
-  }
-  /**
-   * Deletes a tag
-   *
-   * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---delete
-   *
-   * @param path  Path to the repository
-   * @param id    UUID of the tag to delete
-   */
-  async delete(props) {
-    deleteGitTagSchema.parse(props);
-    const args = ["tag", "--delete", props.id];
-    await this.git(props.path, args);
-  }
-  /**
-   * Gets all local tags or filter them by pattern
-   *
-   * They are sorted by authordate of the commit, not the timestamp 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
-   */
-  async list(props) {
-    listGitTagsSchema.parse(props);
-    let args = ["tag", "--list"];
-    args = [
-      ...args,
-      "--sort=-*authordate",
-      "--format=%(refname:short)|%(subject)|%(*authorname)|%(*authoremail)|%(*authordate:unix)"
-    ];
-    const result = await this.git(props.path, args);
-    const noEmptyLinesArr = result.stdout.split(import_os2.EOL).filter((line) => {
-      return line.trim() !== "";
-    });
-    const lineObjArr = noEmptyLinesArr.map((line) => {
-      const lineArray = line.split("|");
-      return {
-        id: lineArray[0],
-        message: lineArray[1],
-        author: {
-          name: lineArray[2],
-          email: lineArray[3]
-        },
-        timestamp: parseInt(lineArray[4])
-      };
-    });
-    const gitTags = lineObjArr.filter(this.isGitTag.bind(this));
-    return {
-      total: gitTags.length,
-      limit: 0,
-      offset: 0,
-      list: gitTags
-    };
-  }
-  /**
-   * Returns the total number of tags inside given repository
-   *
-   * Internally uses list(), so do not use count()
-   * in conjuncion with it to avoid multiple git calls.
-   *
-   * @param path Path to the repository
-   */
-  async count(props) {
-    countGitTagsSchema.parse(props);
-    const gitTags = await this.list({ path: props.path });
-    return gitTags.total;
-  }
-  /**
-   * Type guard for GitTag
-   *
-   * @param obj The object to check
-   */
-  isGitTag(obj) {
-    return gitTagSchema.safeParse(obj).success;
-  }
-};
-
-// src/service/UserService.ts
-var UserService = class {
-  constructor(jsonFileService) {
-    this.jsonFileService = jsonFileService;
-  }
-  /**
-   * Returns the User currently working with Core
-   */
-  async get() {
-    try {
-      return await this.jsonFileService.read(pathTo.userFile, userFileSchema);
-    } catch (error) {
-      return void 0;
-    }
-  }
-  /**
-   * Sets the User currently working with Core
-   *
-   * By doing so all git operations are done with the signature of this User
-   */
-  async set(props) {
-    setUserSchema.parse(props);
-    const userFilePath = pathTo.userFile;
-    const userFile = {
-      ...props
-    };
-    if (userFile.userType === UserTypeSchema.Enum.cloud) {
-    }
-    await this.jsonFileService.update(userFile, userFilePath, userFileSchema);
-    return userFile;
-  }
-};
-
-// src/service/GitService.ts
-var GitService2 = class {
-  constructor(options, userService) {
-    this.branches = {
-      /**
-       * List branches
-       *
-       * @see https://www.git-scm.com/docs/git-branch
-       *
-       * @param path  Path to the repository
-       */
-      list: async (path) => {
-        const args = ["branch", "--list", "--all"];
-        const result = await this.git(path, args);
-        const normalizedLinesArr = result.stdout.split(import_os3.EOL).filter((line) => {
-          return line.trim() !== "";
-        }).map((line) => {
-          return line.trim().replace("* ", "");
-        });
-        const local = [];
-        const remote = [];
-        normalizedLinesArr.forEach((line) => {
-          if (line.startsWith("remotes/")) {
-            remote.push(line.replace("remotes/", ""));
-          } else {
-            local.push(line);
-          }
-        });
-        return {
-          local,
-          remote
-        };
-      },
-      /**
-       * Returns the name of the current branch. In detached HEAD state, an empty string is returned.
-       *
-       * @see https://www.git-scm.com/docs/git-branch#Documentation/git-branch.txt---show-current
-       *
-       * @param path  Path to the repository
-       */
-      current: async (path) => {
-        const args = ["branch", "--show-current"];
-        const result = await this.git(path, args);
-        return result.stdout.trim();
-      },
-      /**
-       * Switch branches
-       *
-       * @see https://git-scm.com/docs/git-switch/
-       *
-       * @param path    Path to the repository
-       * @param branch  Name of the branch to switch to
-       * @param options Options specific to the switch operation
-       */
-      switch: async (path, branch, options) => {
-        await this.checkBranchOrTagName(path, branch);
-        let args = ["switch"];
-        if (options?.isNew === true) {
-          args = [...args, "--create", branch];
-        } else {
-          args = [...args, branch];
-        }
-        await this.git(path, args);
-      }
-    };
-    this.remotes = {
-      /**
-       * Returns a list of currently tracked remotes
-       *
-       * @see https://git-scm.com/docs/git-remote
-       *
-       * @param path  Path to the repository
-       */
-      list: async (path) => {
-        const args = ["remote"];
-        const result = await this.git(path, args);
-        const normalizedLinesArr = result.stdout.split(import_os3.EOL).filter((line) => {
-          return line.trim() !== "";
-        });
-        return normalizedLinesArr;
-      },
-      /**
-       * Returns true if the `origin` remote exists, otherwise false
-       *
-       * @param path  Path to the repository
-       */
-      hasOrigin: async (path) => {
-        const remotes = await this.remotes.list(path);
-        if (remotes.includes("origin")) {
-          return true;
-        }
-        return false;
-      },
-      /**
-       * Adds the `origin` remote with given URL
-       *
-       * Throws if `origin` remote is added already.
-       *
-       * @see https://git-scm.com/docs/git-remote#Documentation/git-remote.txt-emaddem
-       *
-       * @param path  Path to the repository
-       */
-      addOrigin: async (path, url) => {
-        const args = ["remote", "add", "origin", url];
-        await this.git(path, args);
-      },
-      /**
-       * Returns the current `origin` remote URL
-       *
-       * Throws if no `origin` remote is added yet.
-       *
-       * @see https://git-scm.com/docs/git-remote#Documentation/git-remote.txt-emget-urlem
-       *
-       * @param path  Path to the repository
-       */
-      getOriginUrl: async (path) => {
-        const args = ["remote", "get-url", "origin"];
-        const result = (await this.git(path, args)).stdout.trim();
-        return result.length === 0 ? null : result;
-      },
-      /**
-       * Sets the current `origin` remote URL
-       *
-       * Throws if no `origin` remote is added yet.
-       *
-       * @see https://git-scm.com/docs/git-remote#Documentation/git-remote.txt-emset-urlem
-       *
-       * @param path  Path to the repository
-       */
-      setOriginUrl: async (path, url) => {
-        const args = ["remote", "set-url", "origin", url];
-        await this.git(path, args);
-      }
-    };
-    this.version = null;
-    this.gitPath = null;
-    this.queue = new import_p_queue.default({
-      concurrency: 1
-      // No concurrency because git operations are sequencial
-    });
-    this.gitTagService = new GitTagService(options, this.git);
-    this.userService = userService;
-    this.updateVersion();
-    this.updateGitPath();
-  }
-  /**
-   * CRUD methods to work with git tags
-   */
-  get tags() {
-    return this.gitTagService;
-  }
-  /**
-   * Create an empty Git repository or reinitialize an existing one
-   *
-   * @see https://git-scm.com/docs/git-init
-   *
-   * @param path    Path to initialize in. Fails if path does not exist
-   * @param options Options specific to the init operation
-   */
-  async init(path, options) {
-    let args = ["init"];
-    if (options?.initialBranch) {
-      args = [...args, `--initial-branch=${options.initialBranch}`];
-    }
-    await this.git(path, args);
-    await this.setLocalConfig(path);
-    await this.installLfs(path);
-  }
-  /**
-   * Clone a repository into a directory
-   *
-   * @see https://git-scm.com/docs/git-clone
-   *
-   * @todo Implement progress callback / events
-   *
-   * @param url     The remote repository URL to clone from
-   * @param path    The destination path for the cloned repository.
-   *                Which is only working if the directory is existing and empty.
-   * @param options Options specific to the clone operation
-   */
-  async clone(url, path, options) {
-    let args = ["clone", "--progress"];
-    if (options?.branch) {
-      args = [...args, "--branch", options.branch];
-    }
-    if (options?.depth) {
-      args = [...args, "--depth", options.depth.toString()];
-    }
-    if (options?.singleBranch === true) {
-      args = [...args, "--single-branch"];
-    }
-    await this.git("", [...args, url, path]);
-    await this.setLocalConfig(path);
-  }
-  /**
-   * Add file contents to the index
-   *
-   * @see https://git-scm.com/docs/git-add
-   *
-   * @param path  Path to the repository
-   * @param files Files to add
-   */
-  async add(path, files2) {
-    const args = ["add", "--", ...files2];
-    await this.git(path, args);
-  }
-  /**
-   * Reset current HEAD to the specified state
-   *
-   * @todo maybe add more options
-   * @see https://git-scm.com/docs/git-reset
-   *
-   * @param path    Path to the repository
-   * @param mode    Modifies the working tree depending on given mode
-   * @param commit  Resets the current branch head to this commit / tag
-   */
-  async reset(path, mode, commit) {
-    const args = ["reset", `--${mode}`, commit];
-    await this.git(path, args);
-  }
-  /**
-   * Restore working tree files
-   *
-   * @see https://git-scm.com/docs/git-restore/
-   *
-   * @todo It's probably a good idea to not use restore
-   * for a use case where someone just wants to have a look
-   * and maybe copy something from a deleted file.
-   * We should use `checkout` without `add .` and `commit` for that
-   *
-   * @param path    Path to the repository
-   * @param source  Git commit SHA or tag name to restore to
-   * @param files   Files to restore
-   */
-  // public async restore(
-  //   path: string,
-  //   source: string,
-  //   files: string[]
-  // ): Promise<void> {
-  //   const args = ['restore', `--source=${source}`, ...files];
-  //   await this.git(path, args);
-  // }
-  /**
-   * Download objects and refs from remote `origin`
-   *
-   * @see https://www.git-scm.com/docs/git-fetch
-   *
-   * @param path Path to the repository
-   */
-  async fetch(path) {
-    const args = ["fetch"];
-    await this.git(path, args);
-  }
-  /**
-   * Fetch from and integrate (rebase or merge) with a local branch
-   *
-   * @see https://git-scm.com/docs/git-pull
-   *
-   * @param path Path to the repository
-   */
-  async pull(path) {
-    const args = ["pull"];
-    await this.git(path, args);
-  }
-  /**
-   * Update remote refs along with associated objects to remote `origin`
-   *
-   * @see https://git-scm.com/docs/git-push
-   *
-   * @param path Path to the repository
-   */
-  async push(path, options) {
-    let args = ["push", "origin"];
-    if (options?.all === true) {
-      args = [...args, "--all"];
-    }
-    if (options?.force === true) {
-      args = [...args, "--force"];
-    }
-    await this.git(path, args);
-  }
-  /**
-   * Record changes to the repository
-   *
-   * @see https://git-scm.com/docs/git-commit
-   *
-   * @param path    Path to the repository
-   * @param message A message that describes the changes
-   */
-  async commit(path, message) {
-    const user = await this.userService.get();
-    if (!user) {
-      throw new NoCurrentUserError();
-    }
-    const args = [
-      "commit",
-      `--message=${message}`,
-      `--author=${user.name} <${user.email}>`
-    ];
-    await this.git(path, args);
-  }
-  /**
-   * Gets local commit history
-   *
-   * @see https://git-scm.com/docs/git-log
-   *
-   * @todo Check if there is a need to trim the git commit message of chars
-   * @todo Use this method in a service. Decide if we need a HistoryService for example
-   *
-   * @param path    Path to the repository
-   * @param options Options specific to the log operation
-   */
-  async log(path, options) {
-    let args = ["log"];
-    if (options?.between?.from) {
-      args = [
-        ...args,
-        `${options.between.from}..${options.between.to || "HEAD"}`
-      ];
-    }
-    if (options?.limit) {
-      args = [...args, `--max-count=${options.limit}`];
-    }
-    const result = await this.git(path, [
-      ...args,
-      "--format=%H|%s|%an|%ae|%at|%D"
-    ]);
-    const noEmptyLinesArr = result.stdout.split(import_os3.EOL).filter((line) => {
-      return line.trim() !== "";
-    });
-    const lineObjArr = noEmptyLinesArr.map((line) => {
-      const lineArray = line.split("|");
-      return {
-        hash: lineArray[0],
-        message: lineArray[1],
-        author: {
-          name: lineArray[2],
-          email: lineArray[3]
-        },
-        timestamp: parseInt(lineArray[4]),
-        tag: this.refNameToTagName(lineArray[5])
-      };
-    });
-    return lineObjArr.filter(this.isGitCommit.bind(this));
-  }
-  refNameToTagName(refName) {
-    const tagName = refName.replace("tag: ", "").trim();
-    if (tagName === "" || uuidSchema.safeParse(tagName).success === false) {
-      return null;
-    }
-    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
-   *
-   * This can help debugging
-   */
-  async updateVersion() {
-    const result = await this.git("", ["--version"]);
-    this.version = result.stdout.replace("git version", "").trim();
-  }
-  /**
-   * Reads the path to the executable of Git that is used
-   *
-   * This can help debugging, since dugite is shipping their own executable
-   * but in some cases resolves another executable
-   * @see https://github.com/desktop/dugite/blob/main/lib/git-environment.ts
-   */
-  async updateGitPath() {
-    const result = await this.git("", ["--exec-path"]);
-    this.gitPath = result.stdout.trim();
-  }
-  /**
-   * A reference is used in Git to specify branches and tags.
-   * This method checks if given name matches the required format
-   *
-   * @see https://git-scm.com/docs/git-check-ref-format
-   *
-   * @param path Path to the repository
-   * @param name Name to check
-   */
-  async checkBranchOrTagName(path, name) {
-    await this.git(path, ["check-ref-format", "--allow-onelevel", name]);
-  }
-  /**
-   * Installs LFS support and starts tracking
-   * all files inside the lfs folder
-   *
-   * @param path Path to the repository
-   */
-  async installLfs(path) {
-    await this.git(path, ["lfs", "install"]);
-    await this.git(path, ["lfs", "track", "lfs/*"]);
-  }
-  /**
-   * Sets the git config of given local repository from ElekIoCoreOptions
-   *
-   * @param path Path to the repository
-   */
-  async setLocalConfig(path) {
-    const user = await this.userService.get();
-    if (!user) {
-      throw new NoCurrentUserError();
-    }
-    const userNameArgs = ["config", "--local", "user.name", user.name];
-    const userEmailArgs = ["config", "--local", "user.email", user.email];
-    const autoSetupRemoteArgs = [
-      "config",
-      "--local",
-      "push.autoSetupRemote",
-      "true"
-    ];
-    await this.git(path, userNameArgs);
-    await this.git(path, userEmailArgs);
-    await this.git(path, autoSetupRemoteArgs);
-  }
-  /**
-   * Type guard for GitCommit
-   *
-   * @param obj The object to check
-   */
-  isGitCommit(obj) {
-    return gitCommitSchema.safeParse(obj).success;
-  }
-  /**
-   * Wraps the execution of any git command
-   * to use a FIFO queue for sequential processing
-   *
-   * @param path Path to the repository
-   * @param args Arguments to append after the `git` command
-   */
-  async git(path, args) {
-    const result = await this.queue.add(
-      () => import_dugite.GitProcess.exec(args, path, {
-        env: {
-          // @todo Nasty stuff - remove after update to dugite with git > v2.45.2 once available
-          // @see https://github.com/git-lfs/git-lfs/issues/5749
-          GIT_CLONE_PROTECTION_ACTIVE: "false"
-        }
-      })
-    );
-    if (!result) {
-      throw new GitError(
-        `Git ${this.version} (${this.gitPath}) command "git ${args.join(
-          " "
-        )}" failed to return a result`
-      );
-    }
-    if (result.exitCode !== 0) {
-      throw new GitError(
-        `Git ${this.version} (${this.gitPath}) command "git ${args.join(
-          " "
-        )}" failed with exit code "${result.exitCode}" and message "${result.stderr}"`
-      );
-    }
-    return result;
-  }
-};
-
-// src/service/CollectionService.ts
-var CollectionService = class extends AbstractCrudService {
-  constructor(options, jsonFileService, gitService) {
-    super(serviceTypeSchema.Enum.Collection, options);
-    this.jsonFileService = jsonFileService;
-    this.gitService = gitService;
-  }
-  /**
-   * Creates a new Collection
-   */
-  async create(props) {
-    createCollectionSchema.parse(props);
-    const id = uuid();
-    const projectPath = pathTo.project(props.projectId);
-    const collectionPath = pathTo.collection(props.projectId, id);
-    const collectionFilePath = pathTo.collectionFile(props.projectId, id);
-    const collectionFile = {
-      ...props,
-      objectType: "collection",
-      id,
-      slug: {
-        singular: slug(props.slug.singular),
-        plural: slug(props.slug.plural)
-      },
-      created: currentTimestamp(),
-      updated: null
-    };
-    await import_fs_extra4.default.ensureDir(collectionPath);
-    await this.jsonFileService.create(
-      collectionFile,
-      collectionFilePath,
-      collectionFileSchema
-    );
-    await this.gitService.add(projectPath, [collectionFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.create);
-    return collectionFile;
-  }
-  /**
-   * Returns a Collection by ID
-   */
-  async read(props) {
-    readCollectionSchema.parse(props);
-    const collection = await this.jsonFileService.read(
-      pathTo.collectionFile(props.projectId, props.id),
-      collectionFileSchema
-    );
-    return collection;
-  }
-  /**
-   * Updates given Collection
-   *
-   * @todo finish implementing checks for FieldDefinitions and extract methods
-   *
-   * @param projectId   Project ID of the collection to update
-   * @param collection  Collection to write to disk
-   * @returns           An object containing information about the actions needed to be taken,
-   *                    before given update can be executed or void if the update was executed successfully
-   */
-  async update(props) {
-    updateCollectionSchema.parse(props);
-    const projectPath = pathTo.project(props.projectId);
-    const collectionFilePath = pathTo.collectionFile(props.projectId, props.id);
-    const prevCollectionFile = await this.read(props);
-    const collectionFile = {
-      ...prevCollectionFile,
-      ...props,
-      updated: currentTimestamp()
-    };
-    await this.jsonFileService.update(
-      collectionFile,
-      collectionFilePath,
-      collectionFileSchema
-    );
-    await this.gitService.add(projectPath, [collectionFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.update);
-    return collectionFile;
-  }
-  /**
-   * Deletes given Collection (folder), including it's items
-   *
-   * The Fields that Collection used are not deleted.
-   */
-  async delete(props) {
-    deleteCollectionSchema.parse(props);
-    const projectPath = pathTo.project(props.projectId);
-    const collectionPath = pathTo.collection(props.projectId, props.id);
-    await import_fs_extra4.default.remove(collectionPath);
-    await this.gitService.add(projectPath, [collectionPath]);
-    await this.gitService.commit(projectPath, this.gitMessage.delete);
-  }
-  async list(props) {
-    listCollectionsSchema.parse(props);
-    const offset = props.offset || 0;
-    const limit = props.limit || 15;
-    const collectionReferences = await this.listReferences(
-      objectTypeSchema.Enum.collection,
-      props.projectId
-    );
-    const partialCollectionReferences = collectionReferences.slice(
-      offset,
-      limit
-    );
-    const collections = await returnResolved(
-      partialCollectionReferences.map((reference) => {
-        return this.read({
-          projectId: props.projectId,
-          id: reference.id
-        });
-      })
-    );
-    return {
-      total: collectionReferences.length,
-      limit,
-      offset,
-      list: collections
-    };
-  }
-  async count(props) {
-    countCollectionsSchema.parse(props);
-    const count = (await this.listReferences(
-      objectTypeSchema.Enum.collection,
-      props.projectId
-    )).length;
-    return count;
-  }
-  /**
-   * Checks if given object is of type Collection
-   */
-  isCollection(obj) {
-    return collectionFileSchema.safeParse(obj).success;
-  }
-};
-
-// src/service/EntryService.ts
-var import_fs_extra5 = __toESM(require("fs-extra"), 1);
-var EntryService = class extends AbstractCrudService {
-  // private sharedValueService: SharedValueService;
-  constructor(options, jsonFileService, gitService, collectionService, assetService) {
-    super(serviceTypeSchema.Enum.Entry, options);
-    this.jsonFileService = jsonFileService;
-    this.gitService = gitService;
-    this.collectionService = collectionService;
-    this.assetService = assetService;
-  }
-  /**
-   * Creates a new Entry for given Collection
-   */
-  async create(props) {
-    createEntrySchema.parse(props);
-    const id = uuid();
-    const projectPath = pathTo.project(props.projectId);
-    const entryFilePath = pathTo.entryFile(
-      props.projectId,
-      props.collectionId,
-      id
-    );
-    const collection = await this.collectionService.read({
-      projectId: props.projectId,
-      id: props.collectionId
-    });
-    const entryFile = {
-      objectType: "entry",
-      id,
-      values: props.values,
-      created: currentTimestamp(),
-      updated: null
-    };
-    const entry = await this.toEntry({
-      projectId: props.projectId,
-      collectionId: props.collectionId,
-      entryFile
-    });
-    this.validateValues({
-      collectionId: props.collectionId,
-      valueDefinitions: collection.valueDefinitions,
-      values: entry.values
-    });
-    await this.jsonFileService.create(
-      entryFile,
-      entryFilePath,
-      entryFileSchema
-    );
-    await this.gitService.add(projectPath, [entryFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.create);
-    return entry;
-  }
-  /**
-   * Returns an Entry from given Collection by ID and language
-   */
-  async read(props) {
-    readEntrySchema.parse(props);
-    const entryFile = await this.jsonFileService.read(
-      pathTo.entryFile(props.projectId, props.collectionId, props.id),
-      entryFileSchema
-    );
-    return await this.toEntry({
-      projectId: props.projectId,
-      collectionId: props.collectionId,
-      entryFile
-    });
-  }
-  /**
-   * Updates an Entry of given Collection with new Values and shared Values
-   */
-  async update(props) {
-    updateEntrySchema.parse(props);
-    const projectPath = pathTo.project(props.projectId);
-    const entryFilePath = pathTo.entryFile(
-      props.projectId,
-      props.collectionId,
-      props.id
-    );
-    const collection = await this.collectionService.read({
-      projectId: props.projectId,
-      id: props.collectionId
-    });
-    const prevEntryFile = await this.read({
-      projectId: props.projectId,
-      collectionId: props.collectionId,
-      id: props.id
-    });
-    const entryFile = {
-      ...prevEntryFile,
-      values: props.values,
-      updated: currentTimestamp()
-    };
-    const entry = await this.toEntry({
-      projectId: props.projectId,
-      collectionId: props.collectionId,
-      entryFile
-    });
-    this.validateValues({
-      collectionId: props.collectionId,
-      valueDefinitions: collection.valueDefinitions,
-      values: entry.values
-    });
-    await this.jsonFileService.update(
-      entryFile,
-      entryFilePath,
-      entryFileSchema
-    );
-    await this.gitService.add(projectPath, [entryFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.update);
-    return entry;
-  }
-  /**
-   * Deletes given Entry from it's Collection
-   */
-  async delete(props) {
-    deleteEntrySchema.parse(props);
-    const projectPath = pathTo.project(props.projectId);
-    const entryFilePath = pathTo.entryFile(
-      props.projectId,
-      props.collectionId,
-      props.id
-    );
-    await import_fs_extra5.default.remove(entryFilePath);
-    await this.gitService.add(projectPath, [entryFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.delete);
-  }
-  async list(props) {
-    listEntriesSchema.parse(props);
-    const offset = props.offset || 0;
-    const limit = props.limit || 15;
-    const entryReferences = await this.listReferences(
-      objectTypeSchema.Enum.entry,
-      props.projectId,
-      props.collectionId
-    );
-    const partialEntryReferences = entryReferences.slice(offset, limit);
-    const entries = await returnResolved(
-      partialEntryReferences.map((reference) => {
-        return this.read({
-          projectId: props.projectId,
-          collectionId: props.collectionId,
-          id: reference.id
-        });
-      })
-    );
-    return {
-      total: entryReferences.length,
-      limit,
-      offset,
-      list: entries
-    };
-  }
-  async count(props) {
-    countEntriesSchema.parse(props);
-    return (await this.listReferences(
-      objectTypeSchema.Enum.entry,
-      props.projectId,
-      props.collectionId
-    )).length;
-  }
-  /**
-   * Checks if given object is of type Entry
-   */
-  isEntry(obj) {
-    return entrySchema.safeParse(obj).success;
-  }
-  /**
-   * Returns a Value definition by ID
-   */
-  getValueDefinitionById(props) {
-    const definition = props.valueDefinitions.find((def) => {
-      if (def.id === props.id) {
-        return true;
-      }
-      return false;
-    });
-    if (!definition) {
-      throw new Error(
-        `No definition with ID "${props.id}" found in Collection "${props.collectionId}" for given Value reference`
-      );
-    }
-    return definition;
-  }
-  /**
-   * Validates given Values against it's Collections definitions
-   */
-  validateValues(props) {
-    props.values.map((value) => {
-      const definition = this.getValueDefinitionById({
-        collectionId: props.collectionId,
-        valueDefinitions: props.valueDefinitions,
-        id: value.definitionId
-      });
-      const schema = getValueContentSchemaFromDefinition(definition);
-      try {
-        for (const [language, content] of Object.entries(value.content)) {
-          schema.parse(content);
-        }
-      } catch (error) {
-        console.log("Definition:", definition);
-        console.log("Value:", value);
-        throw error;
-      }
-    });
-  }
-  /**
-   * Validates given shared Value references against it's Collections definitions
-   */
-  // private validateResolvedSharedValues(props: {
-  //   collectionId: string;
-  //   valueDefinitions: ValueDefinition[];
-  //   resolvedSharedValues: ResolvedSharedValueReference[];
-  // }) {
-  //   props.resolvedSharedValues.map((value) => {
-  //     const definition = this.getValueDefinitionById({
-  //       collectionId: props.collectionId,
-  //       valueDefinitions: props.valueDefinitions,
-  //       id: value.definitionId,
-  //     });
-  //     const schema = getValueSchemaFromDefinition(definition);
-  //     schema.parse(value.resolved.content);
-  //   });
-  // }
-  async resolveValueContentReference(props) {
-    switch (props.valueContentReference.objectType) {
-      case objectTypeSchema.Enum.asset:
-        return await this.assetService.read({
-          projectId: props.projectId,
-          id: props.valueContentReference.id,
-          language: props.valueContentReference.language
-        });
-      case objectTypeSchema.Enum.entry:
-        return await this.read({
-          projectId: props.projectId,
-          collectionId: props.collectionId,
-          id: props.valueContentReference.id
-        });
-      default:
-        throw new Error(
-          // @ts-ignore
-          `Tried to resolve unsupported Value reference "${props.valueContentReference.referenceObjectType}"`
-        );
-    }
-  }
-  async resolveValueContentReferences(props) {
-    let resolvedContent = {};
-    for (const language in props.valueReference.content) {
-      const referencesOfLanguage = props.valueReference.content[language];
-      if (!referencesOfLanguage) {
-        throw new Error(
-          `Trying to access content references by language "${language}" failed`
-        );
-      }
-      const resolvedReferencesOfLanguage = await Promise.all(
-        referencesOfLanguage.map(async (reference) => {
-          return await this.resolveValueContentReference({
-            projectId: props.projectId,
-            collectionId: props.collectionId,
-            valueContentReference: reference
-          });
-        })
-      );
-      resolvedContent = {
-        ...resolvedContent,
-        [language]: resolvedReferencesOfLanguage
-      };
-    }
-    return resolvedContent;
-  }
-  /**
-   * Creates an Entry from given EntryFile by resolving it's Values
-   */
-  async toEntry(props) {
-    return {
-      ...props.entryFile,
-      // @ts-ignore @todo fixme - I have no idea why this happens. The types seem to be compatible to me and they work
-      values: await Promise.all(
-        props.entryFile.values.map(async (value) => {
-          if (value.valueType === ValueTypeSchema.Enum.reference) {
-            const resolvedContentReferences = await this.resolveValueContentReferences({
-              projectId: props.projectId,
-              collectionId: props.collectionId,
-              valueReference: value
-            });
-            return {
-              ...value,
-              content: resolvedContentReferences
-            };
-          }
-          return value;
-        })
-      )
-    };
-  }
-};
-
-// src/service/ProjectService.ts
-var import_fs_extra6 = __toESM(require("fs-extra"), 1);
-var import_os4 = __toESM(require("os"), 1);
-var import_path2 = __toESM(require("path"), 1);
-var import_semver = __toESM(require("semver"), 1);
-var ProjectService = class extends AbstractCrudService {
-  constructor(options, jsonFileService, userService, gitService, assetService, collectionService, entryService) {
-    super(serviceTypeSchema.Enum.Project, options);
-    this.branches = {
-      list: async (props) => {
-        listBranchesProjectSchema.parse(props);
-        const projectPath = pathTo.project(props.id);
-        await this.gitService.fetch(projectPath);
-        return await this.gitService.branches.list(projectPath);
-      },
-      current: async (props) => {
-        currentBranchProjectSchema.parse(props);
-        const projectPath = pathTo.project(props.id);
-        return await this.gitService.branches.current(projectPath);
-      },
-      switch: async (props) => {
-        switchBranchProjectSchema.parse(props);
-        const projectPath = pathTo.project(props.id);
-        return await this.gitService.branches.switch(
-          projectPath,
-          props.branch,
-          props.options
-        );
-      }
-    };
-    this.remotes = {
-      getOriginUrl: async (props) => {
-        getRemoteOriginUrlProjectSchema.parse(props);
-        const projectPath = pathTo.project(props.id);
-        return await this.gitService.remotes.getOriginUrl(projectPath);
-      },
-      setOriginUrl: async (props) => {
-        setRemoteOriginUrlProjectSchema.parse(props);
-        const projectPath = pathTo.project(props.id);
-        const hasOrigin = await this.gitService.remotes.hasOrigin(projectPath);
-        if (!hasOrigin) {
-          await this.gitService.remotes.addOrigin(projectPath, props.url);
-        } else {
-          await this.gitService.remotes.setOriginUrl(projectPath, props.url);
-        }
-      }
-    };
-    this.jsonFileService = jsonFileService;
-    this.userService = userService;
-    this.gitService = gitService;
-    this.assetService = assetService;
-    this.collectionService = collectionService;
-    this.entryService = entryService;
-  }
-  /**
-   * Creates a new Project
-   */
-  async create(props) {
-    createProjectSchema.parse(props);
-    const user = await this.userService.get();
-    if (!user) {
-      throw new NoCurrentUserError();
-    }
-    const id = uuid();
-    const defaultSettings = {
-      language: {
-        default: user.language,
-        supported: [user.language]
-      }
-    };
-    const projectFile = {
-      ...props,
-      objectType: "project",
-      id,
-      description: props.description || "",
-      settings: Object.assign({}, defaultSettings, props.settings),
-      created: currentTimestamp(),
-      updated: null,
-      coreVersion: this.options.version,
-      // @todo should be read from package.json to avoid duplicates
-      status: "todo",
-      version: "0.0.1"
-    };
-    const projectPath = pathTo.project(id);
-    await import_fs_extra6.default.ensureDir(projectPath);
-    try {
-      await this.createFolderStructure(projectPath);
-      await this.createGitignore(projectPath);
-      await this.gitService.init(projectPath, { initialBranch: "main" });
-      await this.jsonFileService.create(
-        projectFile,
-        pathTo.projectFile(id),
-        projectFileSchema
-      );
-      await this.gitService.add(projectPath, ["."]);
-      await this.gitService.commit(
-        projectPath,
-        `${gitCommitIconSchema.enum.INIT} Created this new elek.io project`
-      );
-      await this.gitService.branches.switch(projectPath, "stage", {
-        isNew: true
-      });
-    } catch (error) {
-      await this.delete({
-        id
-      });
-      throw error;
-    }
-    return await this.toProject({
-      projectFile
-    });
-  }
-  /**
-   * Clones a Project by URL
-   */
-  async clone(props) {
-    cloneProjectSchema.parse(props);
-    const tmpId = uuid();
-    const tmpProjectPath = import_path2.default.join(pathTo.tmp, tmpId);
-    await this.gitService.clone(props.url, tmpProjectPath);
-    const projectFile = await this.jsonFileService.read(
-      import_path2.default.join(tmpProjectPath, "project.json"),
-      projectFileSchema
-    );
-    const projectPath = pathTo.project(projectFile.id);
-    const alreadyExists = await import_fs_extra6.default.pathExists(projectPath);
-    if (alreadyExists) {
-      throw new Error(
-        `Tried to clone Project "${projectFile.id}" from "${props.url}" - but the Project already exists locally`
-      );
-    }
-    await import_fs_extra6.default.copy(tmpProjectPath, projectPath);
-    await import_fs_extra6.default.remove(tmpProjectPath);
-    return await this.toProject({
-      projectFile
-    });
-  }
-  /**
-   * Returns a Project by ID
-   */
-  async read(props) {
-    readProjectSchema.parse(props);
-    const projectFile = await this.jsonFileService.read(
-      pathTo.projectFile(props.id),
-      projectFileSchema
-    );
-    return await this.toProject({
-      projectFile
-    });
-  }
-  /**
-   * Updates given Project
-   */
-  async update(props) {
-    updateProjectSchema.parse(props);
-    const projectPath = pathTo.project(props.id);
-    const filePath = pathTo.projectFile(props.id);
-    const prevProjectFile = await this.read(props);
-    const projectFile = {
-      ...prevProjectFile,
-      ...props,
-      updated: currentTimestamp()
-    };
-    await this.jsonFileService.update(projectFile, filePath, projectFileSchema);
-    await this.gitService.add(projectPath, [filePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.update);
-    return await this.toProject({
-      projectFile
-    });
-  }
-  /**
-   * Upgrades given Project to the latest version of this client
-   *
-   * Needed when a new core version is requiring changes to existing files or structure.
-   *
-   * @todo Find out why using this.snapshotService is throwing isObjWithKeyAndValueOfString of undefined error in gitService (maybe binding issue)
-   */
-  async upgrade(props) {
-    upgradeProjectSchema.parse(props);
-    const project = await this.read(props);
-    const projectPath = pathTo.project(project.id);
-    if (import_semver.default.gt(project.coreVersion, this.options.version)) {
-      throw new Error(
-        `Failed upgrading project. The projects core version "${project.coreVersion}" is higher than the current core version "${this.options.version}" of this client. A client upgrade is needed beforehand.`
-      );
-    }
-    if (import_semver.default.eq(project.coreVersion, this.options.version)) {
-      return;
-    }
-    const upgradeFiles = await files(
-      import_path2.default.resolve(__dirname, "../upgrade"),
-      "ts"
-    );
-    const upgrades = (await Promise.all(
-      upgradeFiles.map((file) => {
-        return import(import_path2.default.join("../upgrade", file.name));
-      })
-    )).map((upgradeImport) => {
-      return upgradeImport.default;
-    });
-    const sortedUpgrades = upgrades.sort((a, b) => {
-      return import_semver.default.compare(a.to, b.to);
-    }).filter((upgrade) => {
-      if (upgrade.to !== "0.0.0") {
-        return upgrade;
-      }
-    });
-    for (let index = 0; index < sortedUpgrades.length; index++) {
-      const upgrade = sortedUpgrades[index];
-      if (!upgrade) {
-        throw new Error("Expected ProjectUpgrade but got undefined");
-      }
-      const failsafeTag = await this.gitService.tags.create({
-        path: projectPath,
-        message: `Attempting to upgrade Project to Core version "${upgrade.to}"`
-      });
-      try {
-        await upgrade.run(project);
-        project.coreVersion = upgrade.to;
-        await this.update(project);
-        await this.gitService.tags.create({
-          path: projectPath,
-          message: `Upgraded Project to Core version "${upgrade.to}"`
-        });
-        await this.gitService.tags.delete({
-          path: projectPath,
-          id: failsafeTag.id
-        });
-      } catch (error) {
-        await this.gitService.reset(projectPath, "hard", failsafeTag.id);
-        throw new ProjectUpgradeError(
-          `Failed to upgrade Project to Core version "${upgrade.to}"`
-        );
-      }
-    }
-  }
-  /**
-   * Returns the differences of the given Projects current branch
-   * between the local and remote `origin` (commits ahead & behind)
-   *
-   * - `behind` contains a list of commits on the current branch that are available on the remote `origin` but not yet locally
-   * - `ahead` contains a list of commits on the current branch that are available locally but not yet on the remote `origin`
-   */
-  async getChanges(props) {
-    getChangesProjectSchema.parse(props);
-    const projectPath = pathTo.project(props.id);
-    const currentBranch = await this.gitService.branches.current(projectPath);
-    await this.gitService.fetch(projectPath);
-    const behind = await this.gitService.log(projectPath, {
-      between: { from: currentBranch, to: `origin/${currentBranch}` }
-    });
-    const ahead = await this.gitService.log(projectPath, {
-      between: { from: `origin/${currentBranch}`, to: currentBranch }
-    });
-    return {
-      behind,
-      ahead
-    };
-  }
-  /**
-   * Pulls remote changes of `origin` down to the local repository
-   * and then pushes local commits to the upstream branch
-   */
-  async synchronize(props) {
-    synchronizeProjectSchema.parse(props);
-    const projectPath = pathTo.project(props.id);
-    await this.gitService.pull(projectPath);
-    await this.gitService.push(projectPath);
-  }
-  /**
-   * Deletes given Project
-   *
-   * Deletes the whole Project folder including the history, not only the config file.
-   * Use with caution, since a Project that is only available locally could be lost forever.
-   * Or changes that are not pushed to a remote yet, will be lost too.
-   */
-  async delete(props) {
-    deleteProjectSchema.parse(props);
-    await import_fs_extra6.default.remove(pathTo.project(props.id));
-  }
-  async list(props) {
-    if (props) {
-      listProjectsSchema.parse(props);
-    }
-    const offset = props?.offset || 0;
-    const limit = props?.limit || 15;
-    const projectReferences = await this.listReferences(
-      objectTypeSchema.Enum.project
-    );
-    const partialProjectReferences = projectReferences.slice(offset, limit);
-    const projects = await returnResolved(
-      partialProjectReferences.map((reference) => {
-        return this.read({ id: reference.id });
-      })
-    );
-    return {
-      total: projectReferences.length,
-      limit,
-      offset,
-      list: projects
-    };
-  }
-  async count() {
-    return (await this.listReferences(objectTypeSchema.Enum.project)).length;
-  }
-  /**
-   * Checks if given object is of type Project
-   */
-  isProject(obj) {
-    return projectFileSchema.safeParse(obj).success;
-  }
-  /**
-   * Exports given Project to JSON
-   *
-   * @todo do not read everything before writing to disk -> stream into file given via props
-   * @todo performance tests
-   * @todo add progress callback
-   */
-  async exportToJson(projectId) {
-    const project = await this.read({ id: projectId });
-    const assets = (await this.assetService.list({ projectId, limit: 0 })).list;
-    const collections = (await this.collectionService.list({ projectId, limit: 0 })).list;
-    const collectionExport = await Promise.all(
-      collections.map(async (collection) => {
-        const entries = (await this.entryService.list({
-          projectId,
-          collectionId: collection.id,
-          limit: 0
-        })).list;
-        return {
-          ...collection,
-          entries
-        };
-      })
-    );
-    return {
-      ...project,
-      assets,
-      collections: collectionExport
-    };
-  }
-  /**
-   * Creates a Project from given ProjectFile by adding git information
-   */
-  async toProject(props) {
-    return {
-      ...props.projectFile
-    };
-  }
-  /**
-   * Creates the projects folder structure and makes sure to
-   * write empty .gitkeep files inside them to ensure they are
-   * committed
-   */
-  async createFolderStructure(path) {
-    const folders2 = Object.values(projectFolderSchema.Values);
-    await Promise.all(
-      folders2.map(async (folder) => {
-        await import_fs_extra6.default.mkdirp(import_path2.default.join(path, folder));
-        await import_fs_extra6.default.writeFile(import_path2.default.join(path, folder, ".gitkeep"), "");
-      })
-    );
-  }
-  /**
-   * Writes the Projects main .gitignore file to disk
-   *
-   * @todo Add general things to ignore
-   * @see https://github.com/github/gitignore/tree/master/Global
-   */
-  async createGitignore(path) {
-    const lines = [
-      "# Ignore all hidden files and folders...",
-      ".*",
-      "# ...but these",
-      "!/.gitignore",
-      "!/.gitattributes",
-      "!/**/.gitkeep",
-      "",
-      "# elek.io related ignores"
-      // projectFolderSchema.Enum.theme + '/',
-      // projectFolderSchema.Enum.public + '/',
-      // projectFolderSchema.Enum.logs + '/',
-    ];
-    await import_fs_extra6.default.writeFile(import_path2.default.join(path, ".gitignore"), lines.join(import_os4.default.EOL));
-  }
-};
-
-// src/index.node.ts
-var ElekIoCore = class {
-  // private readonly sharedValueService: SharedValueService;
-  constructor(props) {
-    const parsedProps = constructorElekIoCoreSchema.parse(props);
-    const defaults = {
-      environment: "production",
-      version: "0.0.0",
-      file: {
-        json: {
-          indentation: 2
-        }
-      }
-    };
-    this.options = Object.assign({}, defaults, parsedProps);
-    this.jsonFileService = new JsonFileService(this.options);
-    this.userService = new UserService(this.jsonFileService);
-    this.gitService = new GitService2(this.options, this.userService);
-    this.assetService = new AssetService(
-      this.options,
-      this.jsonFileService,
-      this.gitService
-    );
-    this.collectionService = new CollectionService(
-      this.options,
-      this.jsonFileService,
-      this.gitService
-    );
-    this.entryService = new EntryService(
-      this.options,
-      this.jsonFileService,
-      this.gitService,
-      this.collectionService,
-      this.assetService
-      // this.sharedValueService
-    );
-    this.projectService = new ProjectService(
-      this.options,
-      this.jsonFileService,
-      this.userService,
-      this.gitService,
-      this.assetService,
-      this.collectionService,
-      this.entryService
-    );
-    if (this.options.environment !== "production") {
-      console.info(
-        `Initializing inside an "${this.options.environment}" environment`,
-        {
-          ...this.options
-        }
-      );
-    }
-    import_fs_extra7.default.mkdirpSync(pathTo.projects);
-    import_fs_extra7.default.mkdirpSync(pathTo.tmp);
-    import_fs_extra7.default.emptyDirSync(pathTo.tmp);
-  }
-  /**
-   * Utility / helper functions
-   */
-  get util() {
-    return node_exports;
-  }
-  /**
-   * Exposes git functions
-   */
-  get git() {
-    return this.gitService;
-  }
-  /**
-   * Getter and setter methods for the User currently working with Core
-   */
-  get user() {
-    return this.userService;
-  }
-  /**
-   * CRUD methods to work with Projects
-   */
-  get projects() {
-    return this.projectService;
-  }
-  /**
-   * CRUD methods to work with Assets
-   */
-  get assets() {
-    return this.assetService;
-  }
-  /**
-   * CRUD methods to work with Collections
-   */
-  get collections() {
-    return this.collectionService;
-  }
-  /**
-   * CRUD methods to work with Entries
-   */
-  get entries() {
-    return this.entryService;
-  }
-  /**
-   * CRUD methods to work with Values
-   */
-  // public get sharedValues(): SharedValueService {
-  //   return this.sharedValueService;
-  // }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BooleanValueDefinitionBaseSchema,
-  NumberValueDefinitionBaseSchema,
-  ReferenceValueDefinitionBaseSchema,
-  StringValueDefinitionBaseSchema,
-  UserTypeSchema,
-  ValueDefinitionBaseSchema,
-  ValueInputTypeSchema,
-  ValueInputWidthSchema,
-  ValueTypeSchema,
-  assetExportSchema,
-  assetFileSchema,
-  assetSchema,
-  assetValueDefinitionSchema,
-  baseFileSchema,
-  baseFileWithLanguageSchema,
-  baseUserSchema,
-  cloneProjectSchema,
-  cloudUserSchema,
-  collectionExportSchema,
-  collectionFileSchema,
-  collectionSchema,
-  constructorElekIoCoreSchema,
-  countAssetsSchema,
-  countCollectionsSchema,
-  countEntriesSchema,
-  countGitTagsSchema,
-  createAssetSchema,
-  createCollectionSchema,
-  createEntrySchema,
-  createGitTagSchema,
-  createProjectSchema,
-  currentBranchProjectSchema,
-  currentTimestamp,
-  dateValueDefinitionSchema,
-  datetimeValueDefinitionSchema,
-  deleteAssetSchema,
-  deleteCollectionSchema,
-  deleteEntrySchema,
-  deleteGitTagSchema,
-  deleteProjectSchema,
-  directBooleanValueSchema,
-  directNumberValueSchema,
-  directStringValueSchema,
-  directValueBaseSchema,
-  directValueSchema,
-  elekIoCoreOptionsSchema,
-  emailValueDefinitionSchema,
-  entryExportSchema,
-  entryFileSchema,
-  entrySchema,
-  entryValueDefinitionSchema,
-  environmentSchema,
-  fileReferenceSchema,
-  getChangesProjectSchema,
-  getRemoteOriginUrlProjectSchema,
-  getValueContentSchemaFromDefinition,
-  gitCloneOptionsSchema,
-  gitCommitIconSchema,
-  gitCommitSchema,
-  gitInitOptionsSchema,
-  gitLogOptionsSchema,
-  gitRepositoryPathSchema,
-  gitSignatureSchema,
-  gitSwitchOptionsSchema,
-  gitTagSchema,
-  ipValueDefinitionSchema,
-  listAssetsSchema,
-  listBranchesProjectSchema,
-  listCollectionsSchema,
-  listEntriesSchema,
-  listGitTagsSchema,
-  listProjectsSchema,
-  localUserSchema,
-  numberValueDefinitionSchema,
-  objectTypeSchema,
-  projectExportSchema,
-  projectFileSchema,
-  projectFolderSchema,
-  projectSchema,
-  projectSettingsSchema,
-  projectStatusSchema,
-  projectUpgradeSchema,
-  rangeValueDefinitionSchema,
-  readAssetSchema,
-  readCollectionSchema,
-  readEntrySchema,
-  readGitTagSchema,
-  readProjectSchema,
-  referencedValueSchema,
-  resolvedReferencedValueSchema,
-  resolvedValueContentReferenceSchema,
-  resolvedValueSchema,
-  searchProjectSchema,
-  serviceTypeSchema,
-  setRemoteOriginUrlProjectSchema,
-  setUserSchema,
-  slug,
-  stringValueDefinitionSchema,
-  supportedAssetExtensionSchema,
-  supportedAssetMimeTypeSchema,
-  supportedAssetTypeSchema,
-  supportedIconSchema,
-  supportedLanguageSchema,
-  switchBranchProjectSchema,
-  synchronizeProjectSchema,
-  telephoneValueDefinitionSchema,
-  textValueDefinitionSchema,
-  textareaValueDefinitionSchema,
-  timeValueDefinitionSchema,
-  toggleValueDefinitionSchema,
-  translatableArrayOf,
-  translatableBooleanSchema,
-  translatableNumberSchema,
-  translatableStringSchema,
-  updateAssetSchema,
-  updateCollectionSchema,
-  updateEntrySchema,
-  updateProjectSchema,
-  upgradeProjectSchema,
-  urlValueDefinitionSchema,
-  userFileSchema,
-  userSchema,
-  uuid,
-  uuidSchema,
-  valueContentReferenceBase,
-  valueContentReferenceSchema,
-  valueContentReferenceToAssetSchema,
-  valueContentReferenceToCollectionSchema,
-  valueContentReferenceToEntrySchema,
-  valueContentReferenceWithLanguageBase,
-  valueDefinitionSchema,
-  valueSchema,
-  versionSchema
-});
-//# sourceMappingURL=index.node.cjs.map