@elek-io/core 0.9.1 → 0.10.0

package/dist/browser/index.browser.js

@@ -1,9 +1,8 @@
 // src/schema/assetSchema.ts
-import z3 from "zod";
+import z4 from "zod";
 
 // src/schema/baseSchema.ts
 import z from "zod";
-var environmentSchema = z.enum(["production", "development", "test"]);
 var supportedLanguageSchema = z.enum([
   /**
    * Bulgarian
@@ -99,6 +98,7 @@ var objectTypeSchema = z.enum([
   "value",
   "sharedValue"
 ]);
+var logLevelSchema = z.enum(["error", "warn", "info", "debug"]);
 var versionSchema = z.string();
 var uuidSchema = z.string().uuid("shared.invalidUuid");
 var translatableStringSchema = z.record(
@@ -120,6 +120,10 @@ function translatableArrayOf(schema) {
 // src/schema/fileSchema.ts
 import z2 from "zod";
 var baseFileSchema = z2.object({
+  /**
+   * The object type of the file
+   */
+  objectType: objectTypeSchema.readonly(),
   /**
    * The ID of the file
    *
@@ -152,23 +156,108 @@ var fileReferenceSchema = z2.object({
   extension: supportedAssetExtensionSchema.optional()
 });
 
+// src/schema/gitSchema.ts
+import { z as z3 } from "zod";
+var gitRepositoryPathSchema = z3.string();
+var gitSignatureSchema = z3.object({
+  name: z3.string(),
+  email: z3.string()
+});
+var gitCommitSchema = z3.object({
+  /**
+   * SHA-1 hash of the commit
+   */
+  hash: z3.string(),
+  message: z3.string(),
+  author: gitSignatureSchema,
+  datetime: z3.string().datetime(),
+  tag: z3.string().nullable()
+});
+var GitCommitIconNative = /* @__PURE__ */ ((GitCommitIconNative2) => {
+  GitCommitIconNative2["INIT"] = ":tada:";
+  GitCommitIconNative2["CREATE"] = ":heavy_plus_sign:";
+  GitCommitIconNative2["UPDATE"] = ":wrench:";
+  GitCommitIconNative2["DELETE"] = ":heavy_minus_sign:";
+  return GitCommitIconNative2;
+})(GitCommitIconNative || {});
+var gitCommitIconSchema = z3.nativeEnum(GitCommitIconNative);
+var gitInitOptionsSchema = z3.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: z3.string()
+});
+var gitCloneOptionsSchema = z3.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: z3.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: z3.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: z3.string()
+});
+var gitSwitchOptionsSchema = z3.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: z3.boolean().optional()
+});
+var gitLogOptionsSchema = z3.object({
+  /**
+   * Limit the result to given number of commits
+   */
+  limit: z3.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: z3.object({
+    /**
+     * From the oldest commit
+     */
+    from: z3.string(),
+    /**
+     * To the newest commit
+     *
+     * Defaults to the current HEAD
+     */
+    to: z3.string().optional()
+  }),
+  /**
+   * Only shows commits of given file
+   */
+  filePath: z3.string().optional()
+});
+
 // src/schema/assetSchema.ts
 var assetFileSchema = baseFileSchema.extend({
-  objectType: z3.literal(objectTypeSchema.Enum.asset).readonly(),
-  name: z3.string(),
-  description: z3.string(),
+  objectType: z4.literal(objectTypeSchema.Enum.asset).readonly(),
+  name: z4.string(),
+  description: z4.string(),
   extension: supportedAssetExtensionSchema.readonly(),
   mimeType: supportedAssetMimeTypeSchema.readonly(),
   /**
    * Total size in bytes
    */
-  size: z3.number().readonly()
+  size: z4.number().readonly()
 });
 var assetSchema = assetFileSchema.extend({
   /**
    * Absolute path on this filesystem
    */
-  absolutePath: z3.string().readonly()
+  absolutePath: z4.string().readonly(),
+  /**
+   * Commit history of this Asset
+   */
+  history: z4.array(gitCommitSchema)
 });
 var assetExportSchema = assetSchema.extend({});
 var createAssetSchema = assetFileSchema.pick({
@@ -179,12 +268,20 @@ var createAssetSchema = assetFileSchema.pick({
   /**
    * Path of the file to add as a new Asset
    */
-  filePath: z3.string().readonly()
+  filePath: z4.string().readonly()
 });
 var readAssetSchema = assetFileSchema.pick({
   id: true
 }).extend({
-  projectId: uuidSchema.readonly()
+  projectId: uuidSchema.readonly(),
+  commitHash: z4.string().optional().readonly()
+});
+var saveAssetSchema = assetFileSchema.pick({
+  id: true
+}).extend({
+  projectId: uuidSchema.readonly(),
+  filePath: z4.string().readonly(),
+  commitHash: z4.string().optional().readonly()
 });
 var updateAssetSchema = assetFileSchema.pick({
   id: true,
@@ -195,7 +292,7 @@ var updateAssetSchema = assetFileSchema.pick({
   /**
    * Path of the new file to update the Asset with
    */
-  newFilePath: z3.string().readonly().optional()
+  newFilePath: z4.string().readonly().optional()
 });
 var deleteAssetSchema = assetFileSchema.pick({
   id: true,
@@ -203,92 +300,96 @@ var deleteAssetSchema = assetFileSchema.pick({
 }).extend({
   projectId: uuidSchema.readonly()
 });
-var countAssetsSchema = z3.object({ projectId: uuidSchema.readonly() });
+var countAssetsSchema = z4.object({ projectId: uuidSchema.readonly() });
 
 // src/schema/collectionSchema.ts
-import z7 from "zod";
+import z8 from "zod";
 
 // src/schema/entrySchema.ts
-import z5 from "zod";
+import z6 from "zod";
 
 // src/schema/valueSchema.ts
-import z4 from "zod";
-var ValueTypeSchema = z4.enum([
+import z5 from "zod";
+var ValueTypeSchema = z5.enum([
   "string",
   "number",
   "boolean",
   "reference"
 ]);
-var valueContentReferenceBase = z4.object({
+var valueContentReferenceBase = z5.object({
   id: uuidSchema
 });
 var valueContentReferenceWithLanguageBase = valueContentReferenceBase.extend({
   language: supportedLanguageSchema
 });
 var valueContentReferenceToAssetSchema = valueContentReferenceBase.extend({
-  objectType: z4.literal(objectTypeSchema.Enum.asset)
+  objectType: z5.literal(objectTypeSchema.Enum.asset)
 });
 var valueContentReferenceToCollectionSchema = valueContentReferenceBase.extend({
-  objectType: z4.literal(objectTypeSchema.Enum.collection)
+  objectType: z5.literal(objectTypeSchema.Enum.collection)
 });
 var valueContentReferenceToEntrySchema = valueContentReferenceBase.extend({
-  objectType: z4.literal(objectTypeSchema.Enum.entry)
+  objectType: z5.literal(objectTypeSchema.Enum.entry)
 });
-var valueContentReferenceSchema = z4.union([
+var valueContentReferenceSchema = z5.union([
   valueContentReferenceToAssetSchema,
   valueContentReferenceToCollectionSchema,
   valueContentReferenceToEntrySchema
   // valueContentReferenceToSharedValueSchema,
 ]);
-var resolvedValueContentReferenceSchema = z4.union([
+var resolvedValueContentReferenceSchema = z5.union([
   assetSchema,
-  z4.lazy(() => entrySchema)
+  z5.lazy(() => entrySchema)
   // Circular dependency / recursive type @see https://github.com/colinhacks/zod?tab=readme-ov-file#recursive-types
   // resolvedValueContentReferenceToSharedValueSchema,
 ]);
-var directValueBaseSchema = z4.object({
-  objectType: z4.literal(objectTypeSchema.Enum.value).readonly(),
+var directValueBaseSchema = z5.object({
+  objectType: z5.literal(objectTypeSchema.Enum.value).readonly(),
   fieldDefinitionId: uuidSchema.readonly()
 });
 var directStringValueSchema = directValueBaseSchema.extend({
-  valueType: z4.literal(ValueTypeSchema.Enum.string).readonly(),
+  valueType: z5.literal(ValueTypeSchema.Enum.string).readonly(),
   content: translatableStringSchema
 });
 var directNumberValueSchema = directValueBaseSchema.extend({
-  valueType: z4.literal(ValueTypeSchema.Enum.number).readonly(),
+  valueType: z5.literal(ValueTypeSchema.Enum.number).readonly(),
   content: translatableNumberSchema
 });
 var directBooleanValueSchema = directValueBaseSchema.extend({
-  valueType: z4.literal(ValueTypeSchema.Enum.boolean).readonly(),
+  valueType: z5.literal(ValueTypeSchema.Enum.boolean).readonly(),
   content: translatableBooleanSchema
 });
-var directValueSchema = z4.union([
+var directValueSchema = z5.union([
   directStringValueSchema,
   directNumberValueSchema,
   directBooleanValueSchema
 ]);
-var referencedValueSchema = z4.object({
-  objectType: z4.literal(objectTypeSchema.Enum.value).readonly(),
+var referencedValueSchema = z5.object({
+  objectType: z5.literal(objectTypeSchema.Enum.value).readonly(),
   fieldDefinitionId: uuidSchema.readonly(),
-  valueType: z4.literal(ValueTypeSchema.Enum.reference).readonly(),
+  valueType: z5.literal(ValueTypeSchema.Enum.reference).readonly(),
   content: translatableArrayOf(valueContentReferenceSchema)
 });
-var valueSchema = z4.union([directValueSchema, referencedValueSchema]);
+var valueSchema = z5.union([directValueSchema, referencedValueSchema]);
 var resolvedReferencedValueSchema = referencedValueSchema.extend({
   content: translatableArrayOf(resolvedValueContentReferenceSchema)
 });
-var resolvedValueSchema = z4.union([
+var resolvedValueSchema = z5.union([
   directValueSchema,
   resolvedReferencedValueSchema
 ]);
 
 // src/schema/entrySchema.ts
 var entryFileSchema = baseFileSchema.extend({
-  objectType: z5.literal(objectTypeSchema.Enum.entry).readonly(),
-  values: z5.array(valueSchema)
+  objectType: z6.literal(objectTypeSchema.Enum.entry).readonly(),
+  values: z6.array(valueSchema)
 });
 var entrySchema = entryFileSchema.extend({
-  values: z5.array(z5.lazy(() => resolvedValueSchema))
+  values: z6.array(z6.lazy(() => resolvedValueSchema)),
+  /**
+   * Commit history of this Entry
+   */
+  history: z6.array(gitCommitSchema)
 });
 var entryExportSchema = entrySchema.extend({});
 var createEntrySchema = entryFileSchema.omit({
@@ -299,14 +400,15 @@ var createEntrySchema = entryFileSchema.omit({
 }).extend({
   projectId: uuidSchema.readonly(),
   collectionId: uuidSchema.readonly(),
-  values: z5.array(valueSchema)
+  values: z6.array(valueSchema)
 });
-var readEntrySchema = z5.object({
+var readEntrySchema = z6.object({
   id: uuidSchema.readonly(),
   projectId: uuidSchema.readonly(),
-  collectionId: uuidSchema.readonly()
+  collectionId: uuidSchema.readonly(),
+  commitHash: z6.string().optional().readonly()
 });
-var updateEntrySchema = entrySchema.omit({
+var updateEntrySchema = entryFileSchema.omit({
   objectType: true,
   created: true,
   updated: true
@@ -315,14 +417,14 @@ var updateEntrySchema = entrySchema.omit({
   collectionId: uuidSchema.readonly()
 });
 var deleteEntrySchema = readEntrySchema.extend({});
-var countEntriesSchema = z5.object({
+var countEntriesSchema = z6.object({
   projectId: uuidSchema.readonly(),
   collectionId: uuidSchema.readonly()
 });
 
 // src/schema/fieldSchema.ts
-import { z as z6 } from "zod";
-var FieldTypeSchema = z6.enum([
+import { z as z7 } from "zod";
+var FieldTypeSchema = z7.enum([
   // String Values
   "text",
   "textarea",
@@ -344,67 +446,67 @@ var FieldTypeSchema = z6.enum([
   "entry"
   // 'sharedValue', // @todo
 ]);
-var FieldWidthSchema = z6.enum(["12", "6", "4", "3"]);
-var FieldDefinitionBaseSchema = z6.object({
+var FieldWidthSchema = z7.enum(["12", "6", "4", "3"]);
+var FieldDefinitionBaseSchema = z7.object({
   id: uuidSchema.readonly(),
   label: translatableStringSchema,
   description: translatableStringSchema,
-  isRequired: z6.boolean(),
-  isDisabled: z6.boolean(),
-  isUnique: z6.boolean(),
+  isRequired: z7.boolean(),
+  isDisabled: z7.boolean(),
+  isUnique: z7.boolean(),
   inputWidth: FieldWidthSchema
 });
 var StringFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend(
   {
-    valueType: z6.literal(ValueTypeSchema.Enum.string),
-    defaultValue: z6.string().nullable()
+    valueType: z7.literal(ValueTypeSchema.Enum.string),
+    defaultValue: z7.string().nullable()
   }
 );
 var textFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend(
   {
-    fieldType: z6.literal(FieldTypeSchema.Enum.text),
-    min: z6.number().nullable(),
-    max: z6.number().nullable()
+    fieldType: z7.literal(FieldTypeSchema.Enum.text),
+    min: z7.number().nullable(),
+    max: z7.number().nullable()
   }
 );
 var textareaFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.textarea),
-  min: z6.number().nullable(),
-  max: z6.number().nullable()
+  fieldType: z7.literal(FieldTypeSchema.Enum.textarea),
+  min: z7.number().nullable(),
+  max: z7.number().nullable()
 });
 var emailFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.email),
-  defaultValue: z6.string().email().nullable()
+  fieldType: z7.literal(FieldTypeSchema.Enum.email),
+  defaultValue: z7.string().email().nullable()
 });
 var urlFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.url),
-  defaultValue: z6.string().url().nullable()
+  fieldType: z7.literal(FieldTypeSchema.Enum.url),
+  defaultValue: z7.string().url().nullable()
 });
 var ipFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.ip),
-  defaultValue: z6.string().ip().nullable()
+  fieldType: z7.literal(FieldTypeSchema.Enum.ip),
+  defaultValue: z7.string().ip().nullable()
 });
 var dateFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend(
   {
-    fieldType: z6.literal(FieldTypeSchema.Enum.date),
-    defaultValue: z6.string().date().nullable()
+    fieldType: z7.literal(FieldTypeSchema.Enum.date),
+    defaultValue: z7.string().date().nullable()
   }
 );
 var timeFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend(
   {
-    fieldType: z6.literal(FieldTypeSchema.Enum.time),
-    defaultValue: z6.string().time().nullable()
+    fieldType: z7.literal(FieldTypeSchema.Enum.time),
+    defaultValue: z7.string().time().nullable()
   }
 );
 var datetimeFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.datetime),
-  defaultValue: z6.string().datetime().nullable()
+  fieldType: z7.literal(FieldTypeSchema.Enum.datetime),
+  defaultValue: z7.string().datetime().nullable()
 });
 var telephoneFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.telephone)
+  fieldType: z7.literal(FieldTypeSchema.Enum.telephone)
   // defaultValue: z.string().e164(), @todo when zod v4 releases @see https://github.com/colinhacks/zod/pull/3476
 });
-var stringFieldDefinitionSchema = z6.union([
+var stringFieldDefinitionSchema = z7.union([
   textFieldDefinitionSchema,
   textareaFieldDefinitionSchema,
   emailFieldDefinitionSchema,
@@ -417,50 +519,50 @@ var stringFieldDefinitionSchema = z6.union([
 ]);
 var NumberFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend(
   {
-    valueType: z6.literal(ValueTypeSchema.Enum.number),
-    min: z6.number().nullable(),
-    max: z6.number().nullable(),
-    isUnique: z6.literal(false),
-    defaultValue: z6.number().nullable()
+    valueType: z7.literal(ValueTypeSchema.Enum.number),
+    min: z7.number().nullable(),
+    max: z7.number().nullable(),
+    isUnique: z7.literal(false),
+    defaultValue: z7.number().nullable()
   }
 );
 var numberFieldDefinitionSchema = NumberFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.number)
+  fieldType: z7.literal(FieldTypeSchema.Enum.number)
 });
 var rangeFieldDefinitionSchema = NumberFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.range),
+  fieldType: z7.literal(FieldTypeSchema.Enum.range),
   // Overwrite from nullable to required because a range needs min, max and default to work and is required, since it always returns a number
-  isRequired: z6.literal(true),
-  min: z6.number(),
-  max: z6.number(),
-  defaultValue: z6.number()
+  isRequired: z7.literal(true),
+  min: z7.number(),
+  max: z7.number(),
+  defaultValue: z7.number()
 });
 var BooleanFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({
-  valueType: z6.literal(ValueTypeSchema.Enum.boolean),
+  valueType: z7.literal(ValueTypeSchema.Enum.boolean),
   // Overwrite from nullable to required because a boolean needs a default to work and is required, since it always is either true or false
-  isRequired: z6.literal(true),
-  defaultValue: z6.boolean(),
-  isUnique: z6.literal(false)
+  isRequired: z7.literal(true),
+  defaultValue: z7.boolean(),
+  isUnique: z7.literal(false)
 });
 var toggleFieldDefinitionSchema = BooleanFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.toggle)
+  fieldType: z7.literal(FieldTypeSchema.Enum.toggle)
 });
 var ReferenceFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({
-  valueType: z6.literal(ValueTypeSchema.Enum.reference)
+  valueType: z7.literal(ValueTypeSchema.Enum.reference)
 });
 var assetFieldDefinitionSchema = ReferenceFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.asset),
-  allowedMimeTypes: z6.array(supportedAssetMimeTypeSchema).min(1),
-  min: z6.number().nullable(),
-  max: z6.number().nullable()
+  fieldType: z7.literal(FieldTypeSchema.Enum.asset),
+  allowedMimeTypes: z7.array(supportedAssetMimeTypeSchema).min(1),
+  min: z7.number().nullable(),
+  max: z7.number().nullable()
 });
 var entryFieldDefinitionSchema = ReferenceFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.entry),
-  ofCollections: z6.array(uuidSchema),
-  min: z6.number().nullable(),
-  max: z6.number().nullable()
+  fieldType: z7.literal(FieldTypeSchema.Enum.entry),
+  ofCollections: z7.array(uuidSchema),
+  min: z7.number().nullable(),
+  max: z7.number().nullable()
 });
-var fieldDefinitionSchema = z6.union([
+var fieldDefinitionSchema = z7.union([
   stringFieldDefinitionSchema,
   numberFieldDefinitionSchema,
   rangeFieldDefinitionSchema,
@@ -487,10 +589,10 @@ function getValueContentSchemaFromFieldDefinition(fieldDefinition) {
   }
 }
 function getBooleanValueContentSchema() {
-  return z6.boolean();
+  return z7.boolean();
 }
 function getNumberValueContentSchema(definition) {
-  let schema = z6.number();
+  let schema = z7.number();
   if (definition.min) {
     schema = schema.min(definition.min);
   }
@@ -503,7 +605,7 @@ function getNumberValueContentSchema(definition) {
   return schema;
 }
 function getStringValueContentSchema(definition) {
-  let schema = z6.string().trim();
+  let schema = z7.string().trim();
   if ("min" in definition && definition.min) {
     schema = schema.min(definition.min);
   }
@@ -542,12 +644,12 @@ function getReferenceValueContentSchema(definition) {
   switch (definition.fieldType) {
     case FieldTypeSchema.Enum.asset:
       {
-        schema = z6.array(valueContentReferenceToAssetSchema);
+        schema = z7.array(valueContentReferenceToAssetSchema);
       }
       break;
     case FieldTypeSchema.Enum.entry:
       {
-        schema = z6.array(valueContentReferenceToEntrySchema);
+        schema = z7.array(valueContentReferenceToEntrySchema);
       }
       break;
   }
@@ -565,24 +667,29 @@ function getReferenceValueContentSchema(definition) {
 
 // src/schema/collectionSchema.ts
 var collectionFileSchema = baseFileSchema.extend({
-  objectType: z7.literal(objectTypeSchema.Enum.collection).readonly(),
-  name: z7.object({
+  objectType: z8.literal(objectTypeSchema.Enum.collection).readonly(),
+  name: z8.object({
     singular: translatableStringSchema,
     plural: translatableStringSchema
   }),
-  slug: z7.object({
-    singular: z7.string(),
-    plural: z7.string()
+  slug: z8.object({
+    singular: z8.string(),
+    plural: z8.string()
   }),
   description: translatableStringSchema,
   icon: supportedIconSchema,
-  fieldDefinitions: z7.array(fieldDefinitionSchema)
+  fieldDefinitions: z8.array(fieldDefinitionSchema)
+});
+var collectionSchema = collectionFileSchema.extend({
+  /**
+   * Commit history of this Collection
+   */
+  history: z8.array(gitCommitSchema)
 });
-var collectionSchema = collectionFileSchema.extend({});
 var collectionExportSchema = collectionSchema.extend({
-  entries: z7.array(entryExportSchema)
+  entries: z8.array(entryExportSchema)
 });
-var createCollectionSchema = collectionSchema.omit({
+var createCollectionSchema = collectionFileSchema.omit({
   id: true,
   objectType: true,
   created: true,
@@ -590,9 +697,10 @@ var createCollectionSchema = collectionSchema.omit({
 }).extend({
   projectId: uuidSchema.readonly()
 });
-var readCollectionSchema = z7.object({
+var readCollectionSchema = z8.object({
   id: uuidSchema.readonly(),
-  projectId: uuidSchema.readonly()
+  projectId: uuidSchema.readonly(),
+  commitHash: z8.string().optional().readonly()
 });
 var updateCollectionSchema = collectionFileSchema.pick({
   id: true,
@@ -605,115 +713,34 @@ var updateCollectionSchema = collectionFileSchema.pick({
   projectId: uuidSchema.readonly()
 });
 var deleteCollectionSchema = readCollectionSchema.extend({});
-var countCollectionsSchema = z7.object({
+var countCollectionsSchema = z8.object({
   projectId: uuidSchema.readonly()
 });
 
 // src/schema/coreSchema.ts
-import { z as z8 } from "zod";
-var elekIoCoreOptionsSchema = z8.object({
-  /**
-   * The environment elek.io Core is currently running in
-   */
-  environment: environmentSchema,
-  /**
-   * The current version of elek.io Core
-   */
-  version: versionSchema,
-  file: z8.object({
-    json: z8.object({
-      /**
-       * If set, adds indentation with spaces (number) or escape character (string)
-       * and line break characters to saved JSON files on disk, to make them easier to read.
-       * Defaults to 2 spaces of indentation.
-       */
-      indentation: z8.union([z8.number(), z8.string()])
-    })
-  })
-});
-var constructorElekIoCoreSchema = elekIoCoreOptionsSchema.omit({
-  version: true
-}).partial({
-  environment: true,
-  file: true
-}).optional();
-
-// src/schema/gitSchema.ts
 import { z as z9 } from "zod";
-var gitRepositoryPathSchema = z9.string();
-var gitSignatureSchema = z9.object({
-  name: z9.string(),
-  email: z9.string()
-});
-var gitCommitSchema = z9.object({
-  /**
-   * SHA-1 hash of the commit
-   */
-  hash: z9.string(),
-  message: z9.string(),
-  author: gitSignatureSchema,
-  datetime: z9.string().datetime(),
-  tag: z9.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 = z9.nativeEnum(GitCommitIconNative);
-var gitInitOptionsSchema = z9.object({
-  /**
-   * Use the specified name for the initial branch in the newly created repository. If not specified, fall back to the default name (currently master, but this is subject to change in the future; the name can be customized via the init.defaultBranch configuration variable).
-   */
-  initialBranch: z9.string()
-});
-var gitCloneOptionsSchema = z9.object({
-  /**
-   * Create a shallow clone with a history truncated to the specified number of commits. Implies --single-branch unless --no-single-branch is given to fetch the histories near the tips of all branches. If you want to clone submodules shallowly, also pass --shallow-submodules.
-   */
-  depth: z9.number(),
-  /**
-   * Clone only the history leading to the tip of a single branch, either specified by the --branch option or the primary branch remote’s HEAD points at. Further fetches into the resulting repository will only update the remote-tracking branch for the branch this option was used for the initial cloning. If the HEAD at the remote did not point at any branch when --single-branch clone was made, no remote-tracking branch is created.
-   */
-  singleBranch: z9.boolean(),
-  /**
-   * Instead of pointing the newly created HEAD to the branch pointed to by the cloned repository’s HEAD, point to <name> branch instead. In a non-bare repository, this is the branch that will be checked out. --branch can also take tags and detaches the HEAD at that commit in the resulting repository.
-   */
-  branch: z9.string()
-});
-var gitSwitchOptionsSchema = z9.object({
-  /**
-   * If true, creates a new local branch and then switches to it
-   *
-   * @see https://git-scm.com/docs/git-switch#Documentation/git-switch.txt---createltnew-branchgt
-   */
-  isNew: z9.boolean().optional()
-});
-var gitLogOptionsSchema = z9.object({
-  /**
-   * Limit the result to given number of commits
-   */
-  limit: z9.number().optional(),
-  /**
-   * Only list commits that are between given SHAs or tag names
-   *
-   * Note that the commits of from and to are not included in the result
-   */
-  between: z9.object({
+var elekIoCoreOptionsSchema = z9.object({
+  log: z9.object({
     /**
-     * From the oldest commit
+     * The lowest level that should be logged
+     *
+     * @default 'info'
      */
-    from: z9.string(),
+    level: logLevelSchema
+  }),
+  file: z9.object({
     /**
-     * To the newest commit
+     * If set to true, caches files in memory to speed up access
      *
-     * Defaults to the current HEAD
+     * @default true
      */
-    to: z9.string().optional()
+    cache: z9.boolean()
   })
 });
+var constructorElekIoCoreSchema = elekIoCoreOptionsSchema.partial({
+  log: true,
+  file: true
+}).optional();
 
 // src/schema/gitTagSchema.ts
 import { z as z10 } from "zod";
@@ -765,7 +792,22 @@ var projectFileSchema = baseFileSchema.extend({
   status: projectStatusSchema,
   settings: projectSettingsSchema
 });
-var projectSchema = projectFileSchema.extend({});
+var projectSchema = projectFileSchema.extend({
+  /**
+   * Commit history of this Project
+   */
+  history: z11.array(gitCommitSchema),
+  /**
+   * Full commit history of this Project
+   * including all Assets, Collections, Entries and other files
+   */
+  fullHistory: z11.array(gitCommitSchema)
+});
+var outdatedProjectSchema = projectFileSchema.pick({
+  id: true,
+  name: true,
+  coreVersion: true
+});
 var projectExportSchema = projectSchema.extend({
   assets: z11.array(assetExportSchema),
   collections: z11.array(collectionExportSchema)
@@ -779,7 +821,8 @@ var createProjectSchema = projectSchema.pick({
   settings: true
 });
 var readProjectSchema = z11.object({
-  id: uuidSchema.readonly()
+  id: uuidSchema.readonly(),
+  commitHash: z11.string().optional().readonly()
 });
 var updateProjectSchema = projectSchema.pick({
   id: true,
@@ -792,7 +835,11 @@ var updateProjectSchema = projectSchema.pick({
   settings: true
 });
 var upgradeProjectSchema = z11.object({
-  id: uuidSchema.readonly()
+  id: uuidSchema.readonly(),
+  /**
+   * Force the upgrade even if the Project is up-to-date
+   */
+  force: z11.boolean().optional()
 });
 var deleteProjectSchema = readProjectSchema.extend({});
 var projectUpgradeSchema = z11.object({
@@ -967,7 +1014,6 @@ export {
   entryFieldDefinitionSchema,
   entryFileSchema,
   entrySchema,
-  environmentSchema,
   fieldDefinitionSchema,
   fileReferenceSchema,
   getChangesProjectSchema,
@@ -990,8 +1036,10 @@ export {
   listGitTagsSchema,
   listProjectsSchema,
   localUserSchema,
+  logLevelSchema,
   numberFieldDefinitionSchema,
   objectTypeSchema,
+  outdatedProjectSchema,
   projectExportSchema,
   projectFileSchema,
   projectFolderSchema,
@@ -1009,6 +1057,7 @@ export {
   resolvedReferencedValueSchema,
   resolvedValueContentReferenceSchema,
   resolvedValueSchema,
+  saveAssetSchema,
   searchProjectSchema,
   serviceTypeSchema,
   setRemoteOriginUrlProjectSchema,