@elek-io/core 0.3.1 → 0.4.0

package/dist/index.js

@@ -5,29 +5,9 @@ var __export = (target, all) => {
 };
 
 // src/index.ts
-import {
-  constructorElekIoCoreSchema
-} from "@elek-io/shared";
 import Fs7 from "fs-extra";
 
 // src/service/AssetService.ts
-import {
-  assetFileSchema,
-  assetSchema,
-  countAssetsSchema,
-  createAssetSchema,
-  currentTimestamp,
-  deleteAssetSchema,
-  listAssetsSchema,
-  objectTypeSchema as objectTypeSchema2,
-  readAssetSchema,
-  serviceTypeSchema as serviceTypeSchema3,
-  supportedAssetExtensionSchema,
-  supportedAssetMimeTypeSchema,
-  supportedAssetTypeSchema,
-  updateAssetSchema,
-  uuid as uuid2
-} from "@elek-io/shared";
 import Fs3 from "fs-extra";
 import IsSvg from "is-svg";
 
@@ -39,10 +19,332 @@ var RequiredParameterMissingError = class extends Error {
   }
 };
 
+// src/schema/assetSchema.ts
+import z3 from "zod";
+
+// src/schema/baseSchema.ts
+import z from "zod";
+var environmentSchema = z.enum(["production", "development", "test"]);
+var supportedLanguageSchema = z.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 = z.enum(["home", "plus", "foobar"]);
+var supportedAssetMimeTypeSchema = z.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 = z.enum([
+  "avif",
+  "gif",
+  "jpg",
+  "jpeg",
+  "png",
+  "svg",
+  "webp",
+  "pdf",
+  "zip",
+  "mp4",
+  "webm",
+  "flac",
+  "json"
+]);
+var supportedAssetTypeSchema = z.object({
+  extension: supportedAssetExtensionSchema,
+  mimeType: supportedAssetMimeTypeSchema
+});
+var objectTypeSchema = z.enum([
+  "project",
+  "asset",
+  "collection",
+  "entry",
+  "value",
+  "sharedValue"
+]);
+var versionSchema = z.string();
+var uuidSchema = z.string().uuid("shared.invalidUuid");
+var translatableStringSchema = z.record(
+  supportedLanguageSchema,
+  z.string().trim().min(1, "shared.translatableStringRequired")
+);
+var translatableNumberSchema = z.record(
+  supportedLanguageSchema,
+  z.number({ required_error: "shared.translatableNumberRequired" })
+);
+var translatableBooleanSchema = z.record(
+  supportedLanguageSchema,
+  z.boolean({ required_error: "shared.translatableBooleanRequired" })
+);
+function translatableArrayOf(schema) {
+  return z.record(supportedLanguageSchema, z.array(schema));
+}
+
+// src/schema/fileSchema.ts
+import z2 from "zod";
+var baseFileSchema = z2.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: z2.number().readonly(),
+  /**
+   * The timestamp of the file being updated is set by the service of "objectType" while updating it
+   */
+  updated: z2.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 = z2.object({
+  id: uuidSchema,
+  language: supportedLanguageSchema.optional(),
+  extension: supportedAssetExtensionSchema.optional()
+});
+
+// src/schema/assetSchema.ts
+var assetFileSchema = baseFileWithLanguageSchema.extend({
+  objectType: z3.literal(objectTypeSchema.Enum.asset).readonly(),
+  name: z3.string(),
+  description: z3.string(),
+  extension: supportedAssetExtensionSchema.readonly(),
+  mimeType: supportedAssetMimeTypeSchema.readonly(),
+  /**
+   * Total size in bytes
+   */
+  size: z3.number().readonly()
+});
+var assetSchema = assetFileSchema.extend({
+  /**
+   * Absolute path on this filesystem
+   */
+  absolutePath: z3.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: z3.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: z3.string().readonly().optional()
+});
+var deleteAssetSchema = assetFileSchema.pick({
+  id: true,
+  language: true,
+  extension: true
+}).extend({
+  projectId: uuidSchema.readonly()
+});
+var countAssetsSchema = z3.object({ projectId: uuidSchema.readonly() });
+
+// src/schema/serviceSchema.ts
+import { z as z5 } from "zod";
+
+// src/schema/gitSchema.ts
+import { z as z4 } from "zod";
+var gitRepositoryPathSchema = z4.string();
+var gitSignatureSchema = z4.object({
+  name: z4.string(),
+  email: z4.string()
+});
+var gitCommitSchema = z4.object({
+  /**
+   * SHA-1 hash of the commit
+   */
+  hash: z4.string(),
+  message: z4.string(),
+  author: gitSignatureSchema,
+  timestamp: z4.number(),
+  tag: z4.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 = z4.nativeEnum(GitCommitIconNative);
+var gitInitOptionsSchema = z4.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: z4.string()
+});
+var gitCloneOptionsSchema = z4.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: z4.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: z4.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: z4.string()
+});
+var gitSwitchOptionsSchema = z4.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: z4.boolean().optional()
+});
+var gitLogOptionsSchema = z4.object({
+  /**
+   * Limit the result to given number of commits
+   */
+  limit: z4.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: z4.object({
+    /**
+     * From the oldest commit
+     */
+    from: z4.string(),
+    /**
+     * To the newest commit
+     *
+     * Defaults to the current HEAD
+     */
+    to: z4.string().optional()
+  })
+});
+
+// src/schema/serviceSchema.ts
+var serviceTypeSchema = z5.enum([
+  "Git",
+  "GitTag",
+  "User",
+  "Project",
+  "Asset",
+  "JsonFile",
+  "Search",
+  "Collection",
+  "Entry",
+  "Value"
+]);
+var listSchema = z5.object({
+  projectId: uuidSchema,
+  limit: z5.number().optional(),
+  offset: z5.number().optional()
+});
+var listCollectionsSchema = listSchema;
+var listEntriesSchema = listSchema.extend({
+  collectionId: uuidSchema
+});
+var listAssetsSchema = listSchema;
+var listProjectsSchema = listSchema.omit({
+  projectId: true
+});
+var listGitTagsSchema = z5.object({
+  path: gitRepositoryPathSchema
+});
+
 // src/util/index.ts
 var util_exports = {};
 __export(util_exports, {
   assignDefaultIfMissing: () => assignDefaultIfMissing,
+  currentTimestamp: () => currentTimestamp,
   files: () => files,
   folders: () => folders,
   fromPath: () => fromPath,
@@ -52,15 +354,543 @@ __export(util_exports, {
   notEmpty: () => notEmpty,
   pathTo: () => pathTo,
   returnResolved: () => returnResolved,
+  slug: () => slug,
   spawnChildProcess: () => spawnChildProcess,
+  uuid: () => uuid,
   workingDirectory: () => workingDirectory
 });
-import { projectFolderSchema, uuidSchema } from "@elek-io/shared";
 import { spawn } from "child_process";
 import Fs from "fs-extra";
 import { filter, flatten, groupBy, uniq } from "lodash-es";
 import Os from "os";
 import Path from "path";
+import slugify from "slugify";
+import { v4 as generateUuid } from "uuid";
+
+// src/schema/projectSchema.ts
+import { z as z9 } from "zod";
+
+// src/schema/collectionSchema.ts
+import z8 from "zod";
+
+// src/schema/entrySchema.ts
+import z7 from "zod";
+
+// src/schema/valueSchema.ts
+import z6 from "zod";
+var ValueTypeSchema = z6.enum([
+  "string",
+  "number",
+  "boolean",
+  "reference"
+]);
+var ValueInputTypeSchema = z6.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 = z6.enum(["12", "6", "4", "3"]);
+var ValueDefinitionBaseSchema = z6.object({
+  id: uuidSchema.readonly(),
+  label: translatableStringSchema,
+  description: translatableStringSchema,
+  isRequired: z6.boolean(),
+  isDisabled: z6.boolean(),
+  isUnique: z6.boolean(),
+  inputWidth: ValueInputWidthSchema
+});
+var StringValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend(
+  {
+    valueType: z6.literal(ValueTypeSchema.Enum.string),
+    defaultValue: z6.string().nullable()
+  }
+);
+var textValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
+  {
+    inputType: z6.literal(ValueInputTypeSchema.Enum.text),
+    min: z6.number().nullable(),
+    max: z6.number().nullable()
+  }
+);
+var textareaValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: z6.literal(ValueInputTypeSchema.Enum.textarea),
+  min: z6.number().nullable(),
+  max: z6.number().nullable()
+});
+var emailValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: z6.literal(ValueInputTypeSchema.Enum.email),
+  defaultValue: z6.string().email().nullable()
+});
+var urlValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: z6.literal(ValueInputTypeSchema.Enum.url),
+  defaultValue: z6.string().url().nullable()
+});
+var ipValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: z6.literal(ValueInputTypeSchema.Enum.ip),
+  defaultValue: z6.string().ip().nullable()
+});
+var dateValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
+  {
+    inputType: z6.literal(ValueInputTypeSchema.Enum.date),
+    defaultValue: z6.string().date().nullable()
+  }
+);
+var timeValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
+  {
+    inputType: z6.literal(ValueInputTypeSchema.Enum.time),
+    defaultValue: z6.string().time().nullable()
+  }
+);
+var datetimeValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: z6.literal(ValueInputTypeSchema.Enum.datetime),
+  defaultValue: z6.string().datetime().nullable()
+});
+var telephoneValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: z6.literal(ValueInputTypeSchema.Enum.telephone)
+  // defaultValue: z.string().e164(), @todo when zod v4 releases @see https://github.com/colinhacks/zod/pull/3476
+});
+var stringValueDefinitionSchema = z6.union([
+  textValueDefinitionSchema,
+  textareaValueDefinitionSchema,
+  emailValueDefinitionSchema,
+  urlValueDefinitionSchema,
+  ipValueDefinitionSchema,
+  dateValueDefinitionSchema,
+  timeValueDefinitionSchema,
+  datetimeValueDefinitionSchema,
+  telephoneValueDefinitionSchema
+]);
+var NumberValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend(
+  {
+    valueType: z6.literal(ValueTypeSchema.Enum.number),
+    min: z6.number().nullable(),
+    max: z6.number().nullable(),
+    isUnique: z6.literal(false),
+    defaultValue: z6.number().nullable()
+  }
+);
+var numberValueDefinitionSchema = NumberValueDefinitionBaseSchema.extend({
+  inputType: z6.literal(ValueInputTypeSchema.Enum.number)
+});
+var rangeValueDefinitionSchema = NumberValueDefinitionBaseSchema.extend({
+  inputType: z6.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: z6.literal(true),
+  min: z6.number(),
+  max: z6.number(),
+  defaultValue: z6.number()
+});
+var BooleanValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend({
+  valueType: z6.literal(ValueTypeSchema.Enum.boolean),
+  // Overwrite from nullable to required because a boolean needs a default to work and is required, since it always is either true or false
+  isRequired: z6.literal(true),
+  defaultValue: z6.boolean(),
+  isUnique: z6.literal(false)
+});
+var toggleValueDefinitionSchema = BooleanValueDefinitionBaseSchema.extend({
+  inputType: z6.literal(ValueInputTypeSchema.Enum.toggle)
+});
+var ReferenceValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend({
+  valueType: z6.literal(ValueTypeSchema.Enum.reference)
+});
+var assetValueDefinitionSchema = ReferenceValueDefinitionBaseSchema.extend({
+  inputType: z6.literal(ValueInputTypeSchema.Enum.asset),
+  allowedMimeTypes: z6.array(supportedAssetMimeTypeSchema).min(1),
+  min: z6.number().nullable(),
+  max: z6.number().nullable()
+});
+var entryValueDefinitionSchema = ReferenceValueDefinitionBaseSchema.extend({
+  inputType: z6.literal(ValueInputTypeSchema.Enum.entry),
+  ofCollections: z6.array(uuidSchema),
+  min: z6.number().nullable(),
+  max: z6.number().nullable()
+});
+var valueDefinitionSchema = z6.union([
+  stringValueDefinitionSchema,
+  numberValueDefinitionSchema,
+  rangeValueDefinitionSchema,
+  toggleValueDefinitionSchema,
+  assetValueDefinitionSchema,
+  entryValueDefinitionSchema
+  // sharedValueDefinitionSchema,
+]);
+var valueContentReferenceBase = z6.object({
+  id: uuidSchema
+});
+var valueContentReferenceWithLanguageBase = valueContentReferenceBase.extend({
+  language: supportedLanguageSchema
+});
+var valueContentReferenceToAssetSchema = valueContentReferenceWithLanguageBase.extend({
+  objectType: z6.literal(objectTypeSchema.Enum.asset)
+});
+var valueContentReferenceToCollectionSchema = valueContentReferenceBase.extend({
+  objectType: z6.literal(objectTypeSchema.Enum.collection)
+});
+var valueContentReferenceToEntrySchema = valueContentReferenceBase.extend({
+  objectType: z6.literal(objectTypeSchema.Enum.entry)
+});
+var valueContentReferenceSchema = z6.union([
+  valueContentReferenceToAssetSchema,
+  valueContentReferenceToCollectionSchema,
+  valueContentReferenceToEntrySchema
+  // valueContentReferenceToSharedValueSchema,
+]);
+var resolvedValueContentReferenceSchema = z6.union([
+  assetSchema,
+  z6.lazy(() => entrySchema)
+  // Circular dependency / recursive type @see https://github.com/colinhacks/zod?tab=readme-ov-file#recursive-types
+  // resolvedValueContentReferenceToSharedValueSchema,
+]);
+var directValueBaseSchema = z6.object({
+  objectType: z6.literal(objectTypeSchema.Enum.value).readonly(),
+  definitionId: uuidSchema.readonly()
+});
+var directStringValueSchema = directValueBaseSchema.extend({
+  valueType: z6.literal(ValueTypeSchema.Enum.string).readonly(),
+  content: translatableStringSchema
+});
+var directNumberValueSchema = directValueBaseSchema.extend({
+  valueType: z6.literal(ValueTypeSchema.Enum.number).readonly(),
+  content: translatableNumberSchema
+});
+var directBooleanValueSchema = directValueBaseSchema.extend({
+  valueType: z6.literal(ValueTypeSchema.Enum.boolean).readonly(),
+  content: translatableBooleanSchema
+});
+var directValueSchema = z6.union([
+  directStringValueSchema,
+  directNumberValueSchema,
+  directBooleanValueSchema
+]);
+var referencedValueSchema = z6.object({
+  objectType: z6.literal(objectTypeSchema.Enum.value).readonly(),
+  definitionId: uuidSchema.readonly(),
+  valueType: z6.literal(ValueTypeSchema.Enum.reference).readonly(),
+  content: translatableArrayOf(valueContentReferenceSchema)
+});
+var valueSchema = z6.union([directValueSchema, referencedValueSchema]);
+var resolvedReferencedValueSchema = referencedValueSchema.extend({
+  content: translatableArrayOf(resolvedValueContentReferenceSchema)
+});
+var resolvedValueSchema = z6.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 z6.boolean();
+}
+function getNumberValueContentSchema(definition) {
+  let schema = z6.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 = z6.string().trim();
+  if ("min" in definition && definition.min) {
+    schema = schema.min(definition.min);
+  }
+  if ("max" in definition && definition.max) {
+    schema = schema.max(definition.max);
+  }
+  switch (definition.inputType) {
+    case ValueInputTypeSchema.Enum.email:
+      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 = z6.array(valueContentReferenceToAssetSchema);
+      }
+      break;
+    case ValueInputTypeSchema.Enum.entry:
+      {
+        schema = z6.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: z7.literal(objectTypeSchema.Enum.entry).readonly(),
+  values: z7.array(valueSchema)
+});
+var entrySchema = entryFileSchema.extend({
+  values: z7.array(z7.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: z7.array(valueSchema)
+});
+var readEntrySchema = z7.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 = z7.object({
+  projectId: uuidSchema.readonly(),
+  collectionId: uuidSchema.readonly()
+});
+
+// src/schema/collectionSchema.ts
+var collectionFileSchema = baseFileSchema.extend({
+  objectType: z8.literal(objectTypeSchema.Enum.collection).readonly(),
+  name: z8.object({
+    singular: translatableStringSchema,
+    plural: translatableStringSchema
+  }),
+  slug: z8.object({
+    singular: z8.string(),
+    plural: z8.string()
+  }),
+  description: translatableStringSchema,
+  icon: supportedIconSchema,
+  valueDefinitions: z8.array(valueDefinitionSchema)
+});
+var collectionSchema = collectionFileSchema.extend({});
+var collectionExportSchema = collectionSchema.extend({
+  entries: z8.array(entryExportSchema)
+});
+var createCollectionSchema = collectionSchema.omit({
+  id: true,
+  objectType: true,
+  created: true,
+  updated: true
+}).extend({
+  projectId: uuidSchema.readonly()
+});
+var readCollectionSchema = z8.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 = z8.object({
+  projectId: uuidSchema.readonly()
+});
+
+// src/schema/projectSchema.ts
+var projectStatusSchema = z9.enum(["foo", "bar", "todo"]);
+var projectSettingsSchema = z9.object({
+  language: z9.object({
+    default: supportedLanguageSchema,
+    supported: z9.array(supportedLanguageSchema)
+  })
+});
+var projectFolderSchema = z9.enum([
+  "assets",
+  "collections",
+  "shared-values",
+  "lfs"
+  // 'logs',
+  // 'public',
+  // 'theme',
+]);
+var projectFileSchema = baseFileSchema.extend({
+  objectType: z9.literal(objectTypeSchema.Enum.project).readonly(),
+  coreVersion: versionSchema,
+  name: z9.string().trim().min(1, "shared.projectNameRequired"),
+  description: z9.string().trim().min(1, "shared.projectDescriptionRequired"),
+  version: versionSchema,
+  status: projectStatusSchema,
+  settings: projectSettingsSchema
+});
+var projectSchema = projectFileSchema.extend({});
+var projectExportSchema = projectSchema.extend({
+  assets: z9.array(assetExportSchema),
+  collections: z9.array(collectionExportSchema)
+});
+var createProjectSchema = projectSchema.pick({
+  name: true,
+  description: true,
+  settings: true
+}).partial({
+  description: true,
+  settings: true
+});
+var readProjectSchema = z9.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 = z9.object({
+  id: uuidSchema.readonly()
+});
+var deleteProjectSchema = readProjectSchema.extend({});
+var projectUpgradeSchema = z9.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: z9.function().args(projectFileSchema).returns(z9.promise(z9.void()))
+});
+var cloneProjectSchema = z9.object({
+  url: z9.string()
+});
+var listBranchesProjectSchema = z9.object({
+  id: uuidSchema.readonly()
+});
+var currentBranchProjectSchema = z9.object({
+  id: uuidSchema.readonly()
+});
+var switchBranchProjectSchema = z9.object({
+  id: uuidSchema.readonly(),
+  branch: z9.string(),
+  options: gitSwitchOptionsSchema.optional()
+});
+var getRemoteOriginUrlProjectSchema = z9.object({
+  id: uuidSchema.readonly()
+});
+var setRemoteOriginUrlProjectSchema = z9.object({
+  id: uuidSchema.readonly(),
+  url: z9.string()
+});
+var getChangesProjectSchema = z9.object({
+  id: uuidSchema.readonly()
+});
+var synchronizeProjectSchema = z9.object({
+  id: uuidSchema.readonly()
+});
+var searchProjectSchema = z9.object({
+  id: uuidSchema.readonly(),
+  query: z9.string(),
+  language: supportedLanguageSchema,
+  type: z9.array(objectTypeSchema).optional()
+});
+
+// src/util/index.ts
+var Slugify = slugify.default || slugify;
+function uuid() {
+  return generateUuid();
+}
+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`
+  });
+}
 var workingDirectory = Path.join(Os.homedir(), "elek.io");
 var pathTo = {
   tmp: Path.join(workingDirectory, "tmp"),
@@ -230,12 +1060,6 @@ function getDuplicates(arr, key) {
 }
 
 // src/service/AbstractCrudService.ts
-import {
-  fileReferenceSchema,
-  gitCommitIconSchema,
-  objectTypeSchema
-} from "@elek-io/shared";
-import { orderBy, remove } from "lodash-es";
 var AbstractCrudService = class {
   /**
    * Do not instantiate directly as this is an abstract class
@@ -249,53 +1073,6 @@ var AbstractCrudService = class {
       delete: `${gitCommitIconSchema.enum.DELETE} Deleted ${this.type}`
     };
   }
-  /**
-   * Returns the filtered, sorted and paginated version of given list
-   *
-   * @todo Sorting and filtering requires all models to be loaded
-   * from disk. This results in a huge memory spike before the
-   * filtering and pagination takes effect - removing most of it again.
-   * This approach is still better than returning everything and
-   * letting the frontend handle it, since the memory usage would then be constant.
-   * But this still could fill the memory limit of node.js (default 1,4 GB).
-   *
-   * @param list Array to filter, sort and paginate
-   * @param sort Array of sort objects containing information about what to sort and how
-   * @param filter Filter all object values of `list` by this string
-   * @param limit Limit the result to this amount. If 0 is given, no limit is applied
-   * @param offset Start at this index instead of 0
-   */
-  async paginate(list, sort = [], filter2 = "", limit = 15, offset = 0) {
-    let result = list;
-    const total = list.length;
-    const normalizedFilter = filter2.trim().toLowerCase();
-    if (normalizedFilter !== "") {
-      remove(result, (model) => {
-        let key;
-        for (key in model) {
-          const value = model[key];
-          if (String(value).toLowerCase().includes(normalizedFilter)) {
-            return false;
-          }
-        }
-        return true;
-      });
-    }
-    if (sort.length !== 0) {
-      const keys = sort.map((value) => value.by);
-      const orders = sort.map((value) => value.order);
-      result = orderBy(result, keys, orders);
-    }
-    if (limit !== 0) {
-      result = result.slice(offset, offset + limit);
-    }
-    return {
-      total,
-      limit,
-      offset,
-      list: result
-    };
-  }
   /**
    * Returns a list of all file references of given project and type
    *
@@ -379,11 +1156,8 @@ var AbstractCrudService = class {
 };
 
 // src/service/GitService.ts
-import {
-  gitCommitSchema,
-  uuidSchema as uuidSchema2
-} from "@elek-io/shared";
 import { GitProcess } from "dugite";
+import { EOL as EOL2 } from "os";
 import PQueue from "p-queue";
 
 // src/error/GitError.ts
@@ -403,16 +1177,32 @@ var NoCurrentUserError = class extends Error {
 };
 
 // src/service/GitTagService.ts
-import {
-  countGitTagsSchema,
-  createGitTagSchema,
-  deleteGitTagSchema,
-  gitTagSchema,
-  listGitTagsSchema,
-  readGitTagSchema,
-  serviceTypeSchema,
-  uuid
-} from "@elek-io/shared";
+import { EOL } from "os";
+
+// src/schema/gitTagSchema.ts
+import { z as z10 } from "zod";
+var gitTagSchema = z10.object({
+  id: uuidSchema,
+  message: z10.string(),
+  author: gitSignatureSchema,
+  timestamp: z10.number()
+});
+var createGitTagSchema = gitTagSchema.pick({
+  message: true
+}).extend({
+  path: gitRepositoryPathSchema,
+  hash: gitCommitSchema.shape.hash.optional()
+});
+var readGitTagSchema = z10.object({
+  path: gitRepositoryPathSchema,
+  id: uuidSchema.readonly()
+});
+var deleteGitTagSchema = readGitTagSchema.extend({});
+var countGitTagsSchema = z10.object({
+  path: gitRepositoryPathSchema
+});
+
+// src/service/GitTagService.ts
 var GitTagService = class extends AbstractCrudService {
   constructor(options, git) {
     super(serviceTypeSchema.Enum.GitTag, options);
@@ -438,22 +1228,20 @@ var GitTagService = class extends AbstractCrudService {
   /**
    * Returns a tag by ID
    *
-   * Internally uses list() with id as pattern.
+   * 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, filter: props.id });
-    if (tags.total === 0) {
+    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`
       );
     }
-    if (tags.total > 1) {
-      throw new GitError(
-        `Provided tag with UUID "${props.id}" matched multiple known tags`
-      );
-    }
-    return tags.list[0];
+    return tag;
   }
   /**
    * Updating a git tag is not supported.
@@ -496,8 +1284,8 @@ var GitTagService = class extends AbstractCrudService {
       "--format=%(refname:short)|%(subject)|%(*authorname)|%(*authoremail)|%(*authordate:unix)"
     ];
     const result = await this.git(props.path, args);
-    const noEmptyLinesArr = result.stdout.split("\n").filter((line) => {
-      return line !== "";
+    const noEmptyLinesArr = result.stdout.split(EOL).filter((line) => {
+      return line.trim() !== "";
     });
     const lineObjArr = noEmptyLinesArr.map((line) => {
       const lineArray = line.split("|");
@@ -508,17 +1296,16 @@ var GitTagService = class extends AbstractCrudService {
           name: lineArray[2],
           email: lineArray[3]
         },
-        timestamp: typeof lineArray[4] === "string" ? parseInt(lineArray[4]) : void 0
+        timestamp: parseInt(lineArray[4])
       };
     });
     const gitTags = lineObjArr.filter(this.isGitTag.bind(this));
-    return this.paginate(
-      gitTags,
-      props?.sort,
-      props?.filter,
-      props?.limit,
-      props?.offset
-    );
+    return {
+      total: gitTags.length,
+      limit: 0,
+      offset: 0,
+      list: gitTags
+    };
   }
   /**
    * Returns the total number of tags inside given repository
@@ -543,21 +1330,29 @@ var GitTagService = class extends AbstractCrudService {
   }
 };
 
-// src/service/UserService.ts
-import {
-  UserTypeSchema,
-  setUserSchema,
-  userFileSchema
-} from "@elek-io/shared";
+// src/schema/userSchema.ts
+import z11 from "zod";
+var UserTypeSchema = z11.enum(["local", "cloud"]);
+var baseUserSchema = gitSignatureSchema.extend({
+  userType: UserTypeSchema,
+  language: supportedLanguageSchema
+});
+var localUserSchema = baseUserSchema.extend({
+  userType: z11.literal(UserTypeSchema.Enum.local)
+});
+var cloudUserSchema = baseUserSchema.extend({
+  userType: z11.literal(UserTypeSchema.Enum.cloud),
+  id: uuidSchema
+});
+var userFileSchema = z11.union([localUserSchema, cloudUserSchema]);
+var userSchema = userFileSchema;
+var setUserSchema = userSchema;
 
 // src/service/JsonFileService.ts
-import {
-  serviceTypeSchema as serviceTypeSchema2
-} from "@elek-io/shared";
 import Fs2 from "fs-extra";
 var JsonFileService = class extends AbstractCrudService {
   constructor(options) {
-    super(serviceTypeSchema2.Enum.JsonFile, options);
+    super(serviceTypeSchema.Enum.JsonFile, options);
     this.cache = /* @__PURE__ */ new Map();
   }
   /**
@@ -665,13 +1460,147 @@ var UserService = class {
 // src/service/GitService.ts
 var GitService2 = class {
   constructor(options, userService) {
-    this.version = void 0;
+    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(EOL2).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(EOL2).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 PQueue({
       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
@@ -679,13 +1608,6 @@ var GitService2 = class {
   get tags() {
     return this.gitTagService;
   }
-  /**
-   * Reads the currently used version of Git
-   */
-  async getVersion() {
-    const result = await this.git("", ["--version"]);
-    this.version = result.stdout.replace("git version", "").trim();
-  }
   /**
    * Create an empty Git repository or reinitialize an existing one
    *
@@ -726,7 +1648,7 @@ var GitService2 = class {
     if (options?.singleBranch === true) {
       args = [...args, "--single-branch"];
     }
-    await this.git(path, [...args, url, "."]);
+    await this.git("", [...args, url, path]);
     await this.setLocalConfig(path);
   }
   /**
@@ -741,25 +1663,6 @@ var GitService2 = class {
     const args = ["add", "--", ...files2];
     await this.git(path, args);
   }
-  /**
-   * Switch branches
-   *
-   * @see https://git-scm.com/docs/git-switch/
-   *
-   * @param path    Path to the repository
-   * @param name    Name of the branch to switch to
-   * @param options Options specific to the switch operation
-   */
-  async switch(path, name, options) {
-    await this.checkBranchOrTagName(path, name);
-    let args = ["switch"];
-    if (options?.isNew === true) {
-      args = [...args, "--create", name];
-    } else {
-      args = [...args, name];
-    }
-    await this.git(path, args);
-  }
   /**
    * Reset current HEAD to the specified state
    *
@@ -797,7 +1700,18 @@ var GitService2 = class {
   //   await this.git(path, args);
   // }
   /**
-   * Fetch from and integrate with another repository or a local branch
+   * 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
    *
@@ -807,6 +1721,23 @@ var GitService2 = class {
     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
    *
@@ -843,7 +1774,7 @@ var GitService2 = class {
     if (options?.between?.from) {
       args = [
         ...args,
-        `${options.between.from}...${options.between.to || "HEAD"}`
+        `${options.between.from}..${options.between.to || "HEAD"}`
       ];
     }
     if (options?.limit) {
@@ -853,8 +1784,8 @@ var GitService2 = class {
       ...args,
       "--format=%H|%s|%an|%ae|%at|%D"
     ]);
-    const noEmptyLinesArr = result.stdout.split("\n").filter((line) => {
-      return line !== "";
+    const noEmptyLinesArr = result.stdout.split(EOL2).filter((line) => {
+      return line.trim() !== "";
     });
     const lineObjArr = noEmptyLinesArr.map((line) => {
       const lineArray = line.split("|");
@@ -872,10 +1803,9 @@ var GitService2 = class {
     return lineObjArr.filter(this.isGitCommit.bind(this));
   }
   refNameToTagName(refName) {
-    let tagName = "";
-    tagName = refName.replace("tag: ", "");
-    if (tagName.trim() === "" || uuidSchema2.safeParse(tagName).success === false) {
-      tagName = void 0;
+    const tagName = refName.replace("tag: ", "").trim();
+    if (tagName === "" || uuidSchema.safeParse(tagName).success === false) {
+      return null;
     }
     return tagName;
   }
@@ -935,6 +1865,26 @@ var GitService2 = class {
       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
@@ -969,8 +1919,15 @@ var GitService2 = class {
     }
     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
@@ -988,14 +1945,29 @@ var GitService2 = class {
    * @param args Arguments to append after the `git` command
    */
   async git(path, args) {
-    const result = await this.queue.add(() => GitProcess.exec(args, path));
+    const result = await this.queue.add(
+      () => 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}) command "git ${args.join(
+        `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;
   }
 };
@@ -1003,7 +1975,7 @@ var GitService2 = class {
 // src/service/AssetService.ts
 var AssetService = class extends AbstractCrudService {
   constructor(options, jsonFileService, gitService) {
-    super(serviceTypeSchema3.Enum.Asset, options);
+    super(serviceTypeSchema.Enum.Asset, options);
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
   }
@@ -1012,7 +1984,7 @@ var AssetService = class extends AbstractCrudService {
    */
   async create(props) {
     createAssetSchema.parse(props);
-    const id = uuid2();
+    const id = uuid();
     const projectPath = pathTo.project(props.projectId);
     const fileType = await this.getSupportedFileTypeOrThrow(props.filePath);
     const size = await this.getAssetSize(props.filePath);
@@ -1032,6 +2004,7 @@ var AssetService = class extends AbstractCrudService {
       objectType: "asset",
       id,
       created: currentTimestamp(),
+      updated: null,
       extension: fileType.extension,
       mimeType: fileType.mimeType,
       size
@@ -1137,12 +2110,15 @@ var AssetService = class extends AbstractCrudService {
   }
   async list(props) {
     listAssetsSchema.parse(props);
+    const offset = props.offset || 0;
+    const limit = props.limit || 15;
     const assetReferences = await this.listReferences(
-      objectTypeSchema2.Enum.asset,
+      objectTypeSchema.Enum.asset,
       props.projectId
     );
-    const list = await returnResolved(
-      assetReferences.map((assetReference) => {
+    const partialAssetReferences = assetReferences.slice(offset, limit);
+    const assets = await returnResolved(
+      partialAssetReferences.map((assetReference) => {
         if (!assetReference.language) {
           throw new RequiredParameterMissingError("language");
         }
@@ -1153,18 +2129,16 @@ var AssetService = class extends AbstractCrudService {
         });
       })
     );
-    const paginatedResult = this.paginate(
-      list,
-      props.sort,
-      props.filter,
-      props.limit,
-      props.offset
-    );
-    return paginatedResult;
+    return {
+      total: assetReferences.length,
+      limit,
+      offset,
+      list: assets
+    };
   }
   async count(props) {
     countAssetsSchema.parse(props);
-    const count = (await this.listReferences(objectTypeSchema2.Enum.asset, props.projectId)).length;
+    const count = (await this.listReferences(objectTypeSchema.Enum.asset, props.projectId)).length;
     return count;
   }
   /**
@@ -1228,24 +2202,10 @@ var AssetService = class extends AbstractCrudService {
 };
 
 // src/service/CollectionService.ts
-import {
-  collectionFileSchema,
-  countCollectionsSchema,
-  createCollectionSchema,
-  currentTimestamp as currentTimestamp2,
-  deleteCollectionSchema,
-  listCollectionsSchema,
-  objectTypeSchema as objectTypeSchema3,
-  readCollectionSchema,
-  serviceTypeSchema as serviceTypeSchema4,
-  slug,
-  updateCollectionSchema,
-  uuid as uuid3
-} from "@elek-io/shared";
 import Fs4 from "fs-extra";
 var CollectionService = class extends AbstractCrudService {
   constructor(options, jsonFileService, gitService) {
-    super(serviceTypeSchema4.Enum.Collection, options);
+    super(serviceTypeSchema.Enum.Collection, options);
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
   }
@@ -1254,13 +2214,10 @@ var CollectionService = class extends AbstractCrudService {
    */
   async create(props) {
     createCollectionSchema.parse(props);
-    const id = uuid3();
+    const id = uuid();
     const projectPath = pathTo.project(props.projectId);
     const collectionPath = pathTo.collection(props.projectId, id);
-    const collectionFilePath = pathTo.collectionFile(
-      props.projectId,
-      id
-    );
+    const collectionFilePath = pathTo.collectionFile(props.projectId, id);
     const collectionFile = {
       ...props,
       objectType: "collection",
@@ -1269,7 +2226,8 @@ var CollectionService = class extends AbstractCrudService {
         singular: slug(props.slug.singular),
         plural: slug(props.slug.plural)
       },
-      created: currentTimestamp2()
+      created: currentTimestamp(),
+      updated: null
     };
     await Fs4.ensureDir(collectionPath);
     await this.jsonFileService.create(
@@ -1313,7 +2271,7 @@ var CollectionService = class extends AbstractCrudService {
     const collectionFile = {
       ...prevCollectionFile,
       ...props,
-      updated: currentTimestamp2()
+      updated: currentTimestamp()
     };
     await this.jsonFileService.update(
       collectionFile,
@@ -1332,40 +2290,42 @@ var CollectionService = class extends AbstractCrudService {
   async delete(props) {
     deleteCollectionSchema.parse(props);
     const projectPath = pathTo.project(props.projectId);
-    const collectionPath = pathTo.collection(
-      props.projectId,
-      props.id
-    );
+    const collectionPath = pathTo.collection(props.projectId, props.id);
     await Fs4.remove(collectionPath);
     await this.gitService.add(projectPath, [collectionPath]);
     await this.gitService.commit(projectPath, this.gitMessage.delete);
   }
   async list(props) {
     listCollectionsSchema.parse(props);
-    const references = await this.listReferences(
-      objectTypeSchema3.Enum.collection,
+    const offset = props.offset || 0;
+    const limit = props.limit || 15;
+    const collectionReferences = await this.listReferences(
+      objectTypeSchema.Enum.collection,
       props.projectId
     );
-    const list = await returnResolved(
-      references.map((reference) => {
+    const partialCollectionReferences = collectionReferences.slice(
+      offset,
+      limit
+    );
+    const collections = await returnResolved(
+      partialCollectionReferences.map((reference) => {
         return this.read({
           projectId: props.projectId,
           id: reference.id
         });
       })
     );
-    return this.paginate(
-      list,
-      props.sort,
-      props.filter,
-      props.limit,
-      props.offset
-    );
+    return {
+      total: collectionReferences.length,
+      limit,
+      offset,
+      list: collections
+    };
   }
   async count(props) {
     countCollectionsSchema.parse(props);
     const count = (await this.listReferences(
-      objectTypeSchema3.Enum.collection,
+      objectTypeSchema.Enum.collection,
       props.projectId
     )).length;
     return count;
@@ -1379,27 +2339,11 @@ var CollectionService = class extends AbstractCrudService {
 };
 
 // src/service/EntryService.ts
-import {
-  ValueTypeSchema,
-  countEntriesSchema,
-  createEntrySchema,
-  currentTimestamp as currentTimestamp3,
-  deleteEntrySchema,
-  entryFileSchema,
-  entrySchema,
-  getValueContentSchemaFromDefinition,
-  listEntriesSchema,
-  objectTypeSchema as objectTypeSchema4,
-  readEntrySchema,
-  serviceTypeSchema as serviceTypeSchema5,
-  updateEntrySchema,
-  uuid as uuid4
-} from "@elek-io/shared";
 import Fs5 from "fs-extra";
 var EntryService = class extends AbstractCrudService {
   // private sharedValueService: SharedValueService;
   constructor(options, jsonFileService, gitService, collectionService, assetService) {
-    super(serviceTypeSchema5.Enum.Entry, options);
+    super(serviceTypeSchema.Enum.Entry, options);
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
     this.collectionService = collectionService;
@@ -1410,7 +2354,7 @@ var EntryService = class extends AbstractCrudService {
    */
   async create(props) {
     createEntrySchema.parse(props);
-    const id = uuid4();
+    const id = uuid();
     const projectPath = pathTo.project(props.projectId);
     const entryFilePath = pathTo.entryFile(
       props.projectId,
@@ -1425,7 +2369,8 @@ var EntryService = class extends AbstractCrudService {
       objectType: "entry",
       id,
       values: props.values,
-      created: currentTimestamp3()
+      created: currentTimestamp(),
+      updated: null
     };
     const entry = await this.toEntry({
       projectId: props.projectId,
@@ -1484,7 +2429,7 @@ var EntryService = class extends AbstractCrudService {
     const entryFile = {
       ...prevEntryFile,
       values: props.values,
-      updated: currentTimestamp3()
+      updated: currentTimestamp()
     };
     const entry = await this.toEntry({
       projectId: props.projectId,
@@ -1522,13 +2467,16 @@ var EntryService = class extends AbstractCrudService {
   }
   async list(props) {
     listEntriesSchema.parse(props);
-    const references = await this.listReferences(
-      objectTypeSchema4.Enum.entry,
+    const offset = props.offset || 0;
+    const limit = props.limit || 15;
+    const entryReferences = await this.listReferences(
+      objectTypeSchema.Enum.entry,
       props.projectId,
       props.collectionId
     );
-    const list = await returnResolved(
-      references.map((reference) => {
+    const partialEntryReferences = entryReferences.slice(offset, limit);
+    const entries = await returnResolved(
+      partialEntryReferences.map((reference) => {
         return this.read({
           projectId: props.projectId,
           collectionId: props.collectionId,
@@ -1536,18 +2484,17 @@ var EntryService = class extends AbstractCrudService {
         });
       })
     );
-    return this.paginate(
-      list,
-      props.sort,
-      props.filter,
-      props.limit,
-      props.offset
-    );
+    return {
+      total: entryReferences.length,
+      limit,
+      offset,
+      list: entries
+    };
   }
   async count(props) {
     countEntriesSchema.parse(props);
     return (await this.listReferences(
-      objectTypeSchema4.Enum.entry,
+      objectTypeSchema.Enum.entry,
       props.projectId,
       props.collectionId
     )).length;
@@ -1587,12 +2534,8 @@ var EntryService = class extends AbstractCrudService {
       });
       const schema = getValueContentSchemaFromDefinition(definition);
       try {
-        if (value.valueType === "reference") {
-          schema.parse(value.content);
-        } else {
-          for (const [language, content] of Object.entries(value.content)) {
-            schema.parse(content);
-          }
+        for (const [language, content] of Object.entries(value.content)) {
+          schema.parse(content);
         }
       } catch (error) {
         console.log("Definition:", definition);
@@ -1620,17 +2563,18 @@ var EntryService = class extends AbstractCrudService {
   //   });
   // }
   async resolveValueContentReference(props) {
-    switch (props.valueContentReference.referenceObjectType) {
-      case objectTypeSchema4.Enum.asset:
-        return this.resolveValueContentReferenceToAsset({
+    switch (props.valueContentReference.objectType) {
+      case objectTypeSchema.Enum.asset:
+        return await this.assetService.read({
           projectId: props.projectId,
-          valueContentReferenceToAsset: props.valueContentReference
+          id: props.valueContentReference.id,
+          language: props.valueContentReference.language
         });
-      case objectTypeSchema4.Enum.entry:
-        return this.resolveValueContentReferenceToEntry({
+      case objectTypeSchema.Enum.entry:
+        return await this.read({
           projectId: props.projectId,
           collectionId: props.collectionId,
-          valueContentReferenceToEntry: props.valueContentReference
+          id: props.valueContentReference.id
         });
       default:
         throw new Error(
@@ -1639,98 +2583,59 @@ var EntryService = class extends AbstractCrudService {
         );
     }
   }
-  async resolveValueContentReferenceToAsset(props) {
-    const resolvedReferences = await Promise.all(
-      props.valueContentReferenceToAsset.references.map(async (reference) => {
-        const resolvedAsset = await this.assetService.read({
-          projectId: props.projectId,
-          id: reference.id,
-          language: reference.language
-        });
-        return resolvedAsset;
-      })
-    );
-    return {
-      ...props.valueContentReferenceToAsset,
-      references: resolvedReferences
-    };
-  }
-  async resolveValueContentReferenceToEntry(props) {
-    const resolvedReferences = await Promise.all(
-      props.valueContentReferenceToEntry.references.map(async (reference) => {
-        const resolvedEntry = await this.read({
-          projectId: props.projectId,
-          collectionId: props.collectionId,
-          id: reference.id
-        });
-        return resolvedEntry;
-      })
-    );
-    return {
-      ...props.valueContentReferenceToEntry,
-      references: resolvedReferences
-    };
+  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;
   }
-  // private async resolveValueContentReferenceToSharedValue(props: {
-  //   projectId: string;
-  //   valueContentReferenceToSharedValue: ValueContentReferenceToSharedValue;
-  // }): Promise<ResolvedValueContentReferenceToSharedValue> {
-  //   const resolvedSharedValue = await this.sharedValueService.read({
-  //     projectId: props.projectId,
-  //     id: props.valueContentReferenceToSharedValue.references.id,
-  //     language: props.valueContentReferenceToSharedValue.references.language,
-  //   });
-  //   return {
-  //     ...props.valueContentReferenceToSharedValue,
-  //     references: {
-  //       ...props.valueContentReferenceToSharedValue.references,
-  //       resolved: resolvedSharedValue,
-  //     },
-  //   };
-  // }
   /**
    * Creates an Entry from given EntryFile by resolving it's Values
    */
   async toEntry(props) {
-    const entry = {
+    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 resolvedValueContentReference = await this.resolveValueContentReference({
+            const resolvedContentReferences = await this.resolveValueContentReferences({
               projectId: props.projectId,
               collectionId: props.collectionId,
-              valueContentReference: value.content
+              valueReference: value
             });
             return {
               ...value,
-              content: resolvedValueContentReference
+              content: resolvedContentReferences
             };
           }
           return value;
         })
       )
     };
-    return entry;
   }
 };
 
 // src/service/ProjectService.ts
-import {
-  createProjectSchema,
-  currentTimestamp as currentTimestamp4,
-  deleteProjectSchema,
-  gitCommitIconSchema as gitCommitIconSchema2,
-  listProjectsSchema,
-  objectTypeSchema as objectTypeSchema5,
-  projectFileSchema,
-  projectFolderSchema as projectFolderSchema2,
-  readProjectSchema,
-  serviceTypeSchema as serviceTypeSchema7,
-  updateProjectSchema,
-  upgradeProjectSchema,
-  uuid as uuid5
-} from "@elek-io/shared";
 import Fs6 from "fs-extra";
 import Os2 from "os";
 import Path2 from "path";
@@ -1744,83 +2649,52 @@ var ProjectUpgradeError = class extends Error {
   }
 };
 
-// src/service/SearchService.ts
-import {
-  serviceTypeSchema as serviceTypeSchema6
-} from "@elek-io/shared";
-var SearchService = class extends AbstractCrudService {
-  constructor(options, assetService, collectionService) {
-    super(serviceTypeSchema6.enum.Search, options);
-    this.assetService = assetService;
-    this.collectionService = collectionService;
-  }
-  /**
-   * Search all models inside the project for given query
-   *
-   * @todo Implement SearchOptions parameter
-   *
-   * @param project Project to search in
-   * @param query Query to search for
-   */
-  async search(projectId, query, objectType) {
-    const results = [];
-    const normalizedQuery = query.trim();
-    if (normalizedQuery === "") {
-      return results;
-    }
-    const paginatedLists = (await Promise.all([this.assetService.list({ projectId, filter: query })])).flat();
-    paginatedLists.forEach((paginatedList) => {
-      paginatedList.list.flat().forEach((file) => {
-        const result = {
-          id: file.id,
-          language: file.language,
-          name: file.name,
-          type: file.objectType,
-          matches: []
-        };
-        for (const [key, value] of Object.entries(file)) {
-          const valueString = String(value);
-          if (valueString.toLowerCase().includes(normalizedQuery.toLowerCase())) {
-            const matchStart = valueString.toLowerCase().indexOf(normalizedQuery.toLowerCase());
-            const matchEnd = matchStart + normalizedQuery.length;
-            result.matches.push({
-              key,
-              prefix: this.truncate(
-                valueString.substring(0, matchStart),
-                "start"
-              ),
-              match: valueString.substring(matchStart, matchEnd),
-              suffix: this.truncate(
-                valueString.substring(matchEnd, valueString.length),
-                "end"
-              )
-            });
-          }
-        }
-        if (result.matches.length > 0) {
-          results.push(result);
-        }
-      });
-    });
-    return results;
-  }
-  truncate(value, at, limit = 15) {
-    if (at === "start") {
-      return `${value.substring(value.length - limit, value.length)}`;
-    } else {
-      return `${value.substring(0, limit)}`;
-    }
-  }
-};
-
 // src/service/ProjectService.ts
 var ProjectService = class extends AbstractCrudService {
-  constructor(options, jsonFileService, userService, gitService, searchService, assetService, collectionService, entryService) {
-    super(serviceTypeSchema7.Enum.Project, options);
+  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.searchService = searchService;
     this.assetService = assetService;
     this.collectionService = collectionService;
     this.entryService = entryService;
@@ -1834,7 +2708,7 @@ var ProjectService = class extends AbstractCrudService {
     if (!user) {
       throw new NoCurrentUserError();
     }
-    const id = uuid5();
+    const id = uuid();
     const defaultSettings = {
       language: {
         default: user.language,
@@ -1847,7 +2721,8 @@ var ProjectService = class extends AbstractCrudService {
       id,
       description: props.description || "",
       settings: Object.assign({}, defaultSettings, props.settings),
-      created: currentTimestamp4(),
+      created: currentTimestamp(),
+      updated: null,
       coreVersion: this.options.version,
       // @todo should be read from package.json to avoid duplicates
       status: "todo",
@@ -1867,16 +2742,45 @@ var ProjectService = class extends AbstractCrudService {
       await this.gitService.add(projectPath, ["."]);
       await this.gitService.commit(
         projectPath,
-        `${gitCommitIconSchema2.enum.INIT} Created this new elek.io project`
+        `${gitCommitIconSchema.enum.INIT} Created this new elek.io project`
       );
-      await this.gitService.switch(projectPath, "stage", { isNew: true });
+      await this.gitService.branches.switch(projectPath, "stage", {
+        isNew: true
+      });
     } catch (error) {
       await this.delete({
         id
       });
       throw error;
     }
-    return projectFile;
+    return await this.toProject({
+      projectFile
+    });
+  }
+  /**
+   * Clones a Project by URL
+   */
+  async clone(props) {
+    cloneProjectSchema.parse(props);
+    const tmpId = uuid();
+    const tmpProjectPath = Path2.join(pathTo.tmp, tmpId);
+    await this.gitService.clone(props.url, tmpProjectPath);
+    const projectFile = await this.jsonFileService.read(
+      Path2.join(tmpProjectPath, "project.json"),
+      projectFileSchema
+    );
+    const projectPath = pathTo.project(projectFile.id);
+    const alreadyExists = await Fs6.pathExists(projectPath);
+    if (alreadyExists) {
+      throw new Error(
+        `Tried to clone Project "${projectFile.id}" from "${props.url}" - but the Project already exists locally`
+      );
+    }
+    await Fs6.copy(tmpProjectPath, projectPath);
+    await Fs6.remove(tmpProjectPath);
+    return await this.toProject({
+      projectFile
+    });
   }
   /**
    * Returns a Project by ID
@@ -1887,7 +2791,9 @@ var ProjectService = class extends AbstractCrudService {
       pathTo.projectFile(props.id),
       projectFileSchema
     );
-    return projectFile;
+    return await this.toProject({
+      projectFile
+    });
   }
   /**
    * Updates given Project
@@ -1900,12 +2806,14 @@ var ProjectService = class extends AbstractCrudService {
     const projectFile = {
       ...prevProjectFile,
       ...props,
-      updated: currentTimestamp4()
+      updated: currentTimestamp()
     };
     await this.jsonFileService.update(projectFile, filePath, projectFileSchema);
     await this.gitService.add(projectPath, [filePath]);
     await this.gitService.commit(projectPath, this.gitMessage.update);
-    return projectFile;
+    return await this.toProject({
+      projectFile
+    });
   }
   /**
    * Upgrades given Project to the latest version of this client
@@ -1973,6 +2881,39 @@ var ProjectService = class extends AbstractCrudService {
       }
     }
   }
+  /**
+   * 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
    *
@@ -1988,32 +2929,26 @@ var ProjectService = class extends AbstractCrudService {
     if (props) {
       listProjectsSchema.parse(props);
     }
-    const references = await this.listReferences(objectTypeSchema5.Enum.project);
-    const list = await returnResolved(
-      references.map((reference) => {
+    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 this.paginate(
-      list,
-      props?.sort,
-      props?.filter,
-      props?.limit,
-      props?.offset
-    );
+    return {
+      total: projectReferences.length,
+      limit,
+      offset,
+      list: projects
+    };
   }
   async count() {
-    return (await this.listReferences(objectTypeSchema5.Enum.project)).length;
-  }
-  /**
-   * Search all models inside the project for given query
-   *
-   * @param projectId Project ID to search in
-   * @param query     Query to search for
-   * @param type      (Optional) specify the type to search for
-   */
-  async search(projectId, query, type) {
-    return this.searchService.search(projectId, query, type);
+    return (await this.listReferences(objectTypeSchema.Enum.project)).length;
   }
   /**
    * Checks if given object is of type Project
@@ -2051,13 +2986,21 @@ var ProjectService = class extends AbstractCrudService {
       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(projectFolderSchema2.Values);
+    const folders2 = Object.values(projectFolderSchema.Values);
     await Promise.all(
       folders2.map(async (folder) => {
         await Fs6.mkdirp(Path2.join(path, folder));
@@ -2089,6 +3032,35 @@ var ProjectService = class extends AbstractCrudService {
   }
 };
 
+// src/schema/coreSchema.ts
+import { z as z12 } from "zod";
+var elekIoCoreOptionsSchema = z12.object({
+  /**
+   * The environment elek.io Core is currently running in
+   */
+  environment: environmentSchema,
+  /**
+   * The current version of elek.io Core
+   */
+  version: versionSchema,
+  file: z12.object({
+    json: z12.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: z12.union([z12.number(), z12.string()])
+    })
+  })
+});
+var constructorElekIoCoreSchema = elekIoCoreOptionsSchema.omit({
+  version: true
+}).partial({
+  environment: true,
+  file: true
+}).optional();
+
 // src/index.ts
 var ElekIoCore = class {
   // private readonly sharedValueService: SharedValueService;
@@ -2125,17 +3097,11 @@ var ElekIoCore = class {
       this.assetService
       // this.sharedValueService
     );
-    this.searchService = new SearchService(
-      this.options,
-      this.assetService,
-      this.collectionService
-    );
     this.projectService = new ProjectService(
       this.options,
       this.jsonFileService,
       this.userService,
       this.gitService,
-      this.searchService,
       this.assetService,
       this.collectionService,
       this.entryService
@@ -2159,7 +3125,13 @@ var ElekIoCore = class {
     return util_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;