@elek-io/core 0.4.1 → 0.5.0

package/dist/browser/index.browser.cjs

@@ -0,0 +1,1082 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.browser.ts
+var index_browser_exports = {};
+__export(index_browser_exports, {
+  BooleanValueDefinitionBaseSchema: () => BooleanValueDefinitionBaseSchema,
+  NumberValueDefinitionBaseSchema: () => NumberValueDefinitionBaseSchema,
+  ReferenceValueDefinitionBaseSchema: () => ReferenceValueDefinitionBaseSchema,
+  StringValueDefinitionBaseSchema: () => StringValueDefinitionBaseSchema,
+  UserTypeSchema: () => UserTypeSchema,
+  ValueDefinitionBaseSchema: () => ValueDefinitionBaseSchema,
+  ValueInputTypeSchema: () => ValueInputTypeSchema,
+  ValueInputWidthSchema: () => ValueInputWidthSchema,
+  ValueTypeSchema: () => ValueTypeSchema,
+  assetExportSchema: () => assetExportSchema,
+  assetFileSchema: () => assetFileSchema,
+  assetSchema: () => assetSchema,
+  assetValueDefinitionSchema: () => assetValueDefinitionSchema,
+  baseFileSchema: () => baseFileSchema,
+  baseFileWithLanguageSchema: () => baseFileWithLanguageSchema,
+  baseUserSchema: () => baseUserSchema,
+  cloneProjectSchema: () => cloneProjectSchema,
+  cloudUserSchema: () => cloudUserSchema,
+  collectionExportSchema: () => collectionExportSchema,
+  collectionFileSchema: () => collectionFileSchema,
+  collectionSchema: () => collectionSchema,
+  constructorElekIoCoreSchema: () => constructorElekIoCoreSchema,
+  countAssetsSchema: () => countAssetsSchema,
+  countCollectionsSchema: () => countCollectionsSchema,
+  countEntriesSchema: () => countEntriesSchema,
+  countGitTagsSchema: () => countGitTagsSchema,
+  createAssetSchema: () => createAssetSchema,
+  createCollectionSchema: () => createCollectionSchema,
+  createEntrySchema: () => createEntrySchema,
+  createGitTagSchema: () => createGitTagSchema,
+  createProjectSchema: () => createProjectSchema,
+  currentBranchProjectSchema: () => currentBranchProjectSchema,
+  currentTimestamp: () => currentTimestamp,
+  dateValueDefinitionSchema: () => dateValueDefinitionSchema,
+  datetimeValueDefinitionSchema: () => datetimeValueDefinitionSchema,
+  deleteAssetSchema: () => deleteAssetSchema,
+  deleteCollectionSchema: () => deleteCollectionSchema,
+  deleteEntrySchema: () => deleteEntrySchema,
+  deleteGitTagSchema: () => deleteGitTagSchema,
+  deleteProjectSchema: () => deleteProjectSchema,
+  directBooleanValueSchema: () => directBooleanValueSchema,
+  directNumberValueSchema: () => directNumberValueSchema,
+  directStringValueSchema: () => directStringValueSchema,
+  directValueBaseSchema: () => directValueBaseSchema,
+  directValueSchema: () => directValueSchema,
+  elekIoCoreOptionsSchema: () => elekIoCoreOptionsSchema,
+  emailValueDefinitionSchema: () => emailValueDefinitionSchema,
+  entryExportSchema: () => entryExportSchema,
+  entryFileSchema: () => entryFileSchema,
+  entrySchema: () => entrySchema,
+  entryValueDefinitionSchema: () => entryValueDefinitionSchema,
+  environmentSchema: () => environmentSchema,
+  fileReferenceSchema: () => fileReferenceSchema,
+  getChangesProjectSchema: () => getChangesProjectSchema,
+  getRemoteOriginUrlProjectSchema: () => getRemoteOriginUrlProjectSchema,
+  getValueContentSchemaFromDefinition: () => getValueContentSchemaFromDefinition,
+  gitCloneOptionsSchema: () => gitCloneOptionsSchema,
+  gitCommitIconSchema: () => gitCommitIconSchema,
+  gitCommitSchema: () => gitCommitSchema,
+  gitInitOptionsSchema: () => gitInitOptionsSchema,
+  gitLogOptionsSchema: () => gitLogOptionsSchema,
+  gitRepositoryPathSchema: () => gitRepositoryPathSchema,
+  gitSignatureSchema: () => gitSignatureSchema,
+  gitSwitchOptionsSchema: () => gitSwitchOptionsSchema,
+  gitTagSchema: () => gitTagSchema,
+  ipValueDefinitionSchema: () => ipValueDefinitionSchema,
+  listAssetsSchema: () => listAssetsSchema,
+  listBranchesProjectSchema: () => listBranchesProjectSchema,
+  listCollectionsSchema: () => listCollectionsSchema,
+  listEntriesSchema: () => listEntriesSchema,
+  listGitTagsSchema: () => listGitTagsSchema,
+  listProjectsSchema: () => listProjectsSchema,
+  localUserSchema: () => localUserSchema,
+  numberValueDefinitionSchema: () => numberValueDefinitionSchema,
+  objectTypeSchema: () => objectTypeSchema,
+  projectExportSchema: () => projectExportSchema,
+  projectFileSchema: () => projectFileSchema,
+  projectFolderSchema: () => projectFolderSchema,
+  projectSchema: () => projectSchema,
+  projectSettingsSchema: () => projectSettingsSchema,
+  projectStatusSchema: () => projectStatusSchema,
+  projectUpgradeSchema: () => projectUpgradeSchema,
+  rangeValueDefinitionSchema: () => rangeValueDefinitionSchema,
+  readAssetSchema: () => readAssetSchema,
+  readCollectionSchema: () => readCollectionSchema,
+  readEntrySchema: () => readEntrySchema,
+  readGitTagSchema: () => readGitTagSchema,
+  readProjectSchema: () => readProjectSchema,
+  referencedValueSchema: () => referencedValueSchema,
+  resolvedReferencedValueSchema: () => resolvedReferencedValueSchema,
+  resolvedValueContentReferenceSchema: () => resolvedValueContentReferenceSchema,
+  resolvedValueSchema: () => resolvedValueSchema,
+  searchProjectSchema: () => searchProjectSchema,
+  serviceTypeSchema: () => serviceTypeSchema,
+  setRemoteOriginUrlProjectSchema: () => setRemoteOriginUrlProjectSchema,
+  setUserSchema: () => setUserSchema,
+  slug: () => slug,
+  stringValueDefinitionSchema: () => stringValueDefinitionSchema,
+  supportedAssetExtensionSchema: () => supportedAssetExtensionSchema,
+  supportedAssetMimeTypeSchema: () => supportedAssetMimeTypeSchema,
+  supportedAssetTypeSchema: () => supportedAssetTypeSchema,
+  supportedIconSchema: () => supportedIconSchema,
+  supportedLanguageSchema: () => supportedLanguageSchema,
+  switchBranchProjectSchema: () => switchBranchProjectSchema,
+  synchronizeProjectSchema: () => synchronizeProjectSchema,
+  telephoneValueDefinitionSchema: () => telephoneValueDefinitionSchema,
+  textValueDefinitionSchema: () => textValueDefinitionSchema,
+  textareaValueDefinitionSchema: () => textareaValueDefinitionSchema,
+  timeValueDefinitionSchema: () => timeValueDefinitionSchema,
+  toggleValueDefinitionSchema: () => toggleValueDefinitionSchema,
+  translatableArrayOf: () => translatableArrayOf,
+  translatableBooleanSchema: () => translatableBooleanSchema,
+  translatableNumberSchema: () => translatableNumberSchema,
+  translatableStringSchema: () => translatableStringSchema,
+  updateAssetSchema: () => updateAssetSchema,
+  updateCollectionSchema: () => updateCollectionSchema,
+  updateEntrySchema: () => updateEntrySchema,
+  updateProjectSchema: () => updateProjectSchema,
+  upgradeProjectSchema: () => upgradeProjectSchema,
+  urlValueDefinitionSchema: () => urlValueDefinitionSchema,
+  userFileSchema: () => userFileSchema,
+  userSchema: () => userSchema,
+  uuid: () => uuid,
+  uuidSchema: () => uuidSchema,
+  valueContentReferenceBase: () => valueContentReferenceBase,
+  valueContentReferenceSchema: () => valueContentReferenceSchema,
+  valueContentReferenceToAssetSchema: () => valueContentReferenceToAssetSchema,
+  valueContentReferenceToCollectionSchema: () => valueContentReferenceToCollectionSchema,
+  valueContentReferenceToEntrySchema: () => valueContentReferenceToEntrySchema,
+  valueContentReferenceWithLanguageBase: () => valueContentReferenceWithLanguageBase,
+  valueDefinitionSchema: () => valueDefinitionSchema,
+  valueSchema: () => valueSchema,
+  versionSchema: () => versionSchema
+});
+module.exports = __toCommonJS(index_browser_exports);
+
+// src/schema/assetSchema.ts
+var import_zod3 = __toESM(require("zod"), 1);
+
+// src/schema/baseSchema.ts
+var import_zod = __toESM(require("zod"), 1);
+var environmentSchema = import_zod.default.enum(["production", "development", "test"]);
+var supportedLanguageSchema = import_zod.default.enum([
+  /**
+   * Bulgarian
+   */
+  "bg",
+  //
+  "cs",
+  // Czech
+  "da",
+  // Danish
+  "de",
+  // German
+  "el",
+  // Greek
+  "en",
+  // (US) English
+  "es",
+  // Spanish
+  "et",
+  // Estonian
+  "fi",
+  // Finnish
+  "fr",
+  // French
+  "hu",
+  // Hungarian
+  "it",
+  // Italian
+  "ja",
+  // Japanese
+  "lt",
+  // Lithuanian
+  "lv",
+  // Latvian
+  "nl",
+  // Dutch
+  "pl",
+  // Polish
+  "pt",
+  // Portuguese
+  "ro",
+  // Romanian
+  "ru",
+  // Russian
+  "sk",
+  // Slovak
+  "sl",
+  // Slovenian
+  "sv",
+  // Swedish
+  "zh"
+  // (Simplified) Chinese
+]);
+var supportedIconSchema = import_zod.default.enum(["home", "plus", "foobar"]);
+var supportedAssetMimeTypeSchema = import_zod.default.enum([
+  "image/avif",
+  "image/gif",
+  "image/jpeg",
+  "image/png",
+  "image/svg+xml",
+  "image/webp",
+  "application/pdf",
+  "application/zip",
+  "video/mp4",
+  "video/webm",
+  "audio/webm",
+  "audio/flac"
+]);
+var supportedAssetExtensionSchema = import_zod.default.enum([
+  "avif",
+  "gif",
+  "jpg",
+  "jpeg",
+  "png",
+  "svg",
+  "webp",
+  "pdf",
+  "zip",
+  "mp4",
+  "webm",
+  "flac",
+  "json"
+]);
+var supportedAssetTypeSchema = import_zod.default.object({
+  extension: supportedAssetExtensionSchema,
+  mimeType: supportedAssetMimeTypeSchema
+});
+var objectTypeSchema = import_zod.default.enum([
+  "project",
+  "asset",
+  "collection",
+  "entry",
+  "value",
+  "sharedValue"
+]);
+var versionSchema = import_zod.default.string();
+var uuidSchema = import_zod.default.string().uuid("shared.invalidUuid");
+var translatableStringSchema = import_zod.default.record(
+  supportedLanguageSchema,
+  import_zod.default.string().trim().min(1, "shared.translatableStringRequired")
+);
+var translatableNumberSchema = import_zod.default.record(
+  supportedLanguageSchema,
+  import_zod.default.number({ required_error: "shared.translatableNumberRequired" })
+);
+var translatableBooleanSchema = import_zod.default.record(
+  supportedLanguageSchema,
+  import_zod.default.boolean({ required_error: "shared.translatableBooleanRequired" })
+);
+function translatableArrayOf(schema) {
+  return import_zod.default.record(supportedLanguageSchema, import_zod.default.array(schema));
+}
+
+// src/schema/fileSchema.ts
+var import_zod2 = __toESM(require("zod"), 1);
+var baseFileSchema = import_zod2.default.object({
+  /**
+   * The ID of the file
+   *
+   * The ID is part of the files name.
+   */
+  id: uuidSchema.readonly(),
+  /**
+   * The timestamp of the file being created is set by the service of "objectType" while creating it
+   */
+  created: import_zod2.default.number().readonly(),
+  /**
+   * The timestamp of the file being updated is set by the service of "objectType" while updating it
+   */
+  updated: import_zod2.default.number().nullable()
+});
+var baseFileWithLanguageSchema = baseFileSchema.extend({
+  /**
+   * The language of the file
+   *
+   * The language is part of the files name and together with it's ID the only unique identifier.
+   * That's why the language cannot be changed after creating the file.
+   *
+   * @todo Maybe remove the above restriction by implementing logic to handle changing the files language inside all services
+   */
+  language: supportedLanguageSchema.readonly()
+});
+var fileReferenceSchema = import_zod2.default.object({
+  id: uuidSchema,
+  language: supportedLanguageSchema.optional(),
+  extension: supportedAssetExtensionSchema.optional()
+});
+
+// src/schema/assetSchema.ts
+var assetFileSchema = baseFileWithLanguageSchema.extend({
+  objectType: import_zod3.default.literal(objectTypeSchema.Enum.asset).readonly(),
+  name: import_zod3.default.string(),
+  description: import_zod3.default.string(),
+  extension: supportedAssetExtensionSchema.readonly(),
+  mimeType: supportedAssetMimeTypeSchema.readonly(),
+  /**
+   * Total size in bytes
+   */
+  size: import_zod3.default.number().readonly()
+});
+var assetSchema = assetFileSchema.extend({
+  /**
+   * Absolute path on this filesystem
+   */
+  absolutePath: import_zod3.default.string().readonly()
+});
+var assetExportSchema = assetSchema.extend({});
+var createAssetSchema = assetFileSchema.pick({
+  name: true,
+  description: true,
+  language: true
+}).extend({
+  projectId: uuidSchema.readonly(),
+  /**
+   * Path of the file to add as a new Asset
+   */
+  filePath: import_zod3.default.string().readonly()
+});
+var readAssetSchema = assetFileSchema.pick({
+  id: true,
+  language: true
+}).extend({
+  projectId: uuidSchema.readonly()
+});
+var updateAssetSchema = assetFileSchema.pick({
+  id: true,
+  name: true,
+  description: true,
+  language: true
+}).extend({
+  projectId: uuidSchema.readonly(),
+  /**
+   * Path of the new file to update the Asset with
+   */
+  newFilePath: import_zod3.default.string().readonly().optional()
+});
+var deleteAssetSchema = assetFileSchema.pick({
+  id: true,
+  language: true,
+  extension: true
+}).extend({
+  projectId: uuidSchema.readonly()
+});
+var countAssetsSchema = import_zod3.default.object({ projectId: uuidSchema.readonly() });
+
+// src/schema/collectionSchema.ts
+var import_zod6 = __toESM(require("zod"), 1);
+
+// src/schema/entrySchema.ts
+var import_zod5 = __toESM(require("zod"), 1);
+
+// src/schema/valueSchema.ts
+var import_zod4 = __toESM(require("zod"), 1);
+var ValueTypeSchema = import_zod4.default.enum([
+  "string",
+  "number",
+  "boolean",
+  "reference"
+]);
+var ValueInputTypeSchema = import_zod4.default.enum([
+  // String
+  "text",
+  "textarea",
+  "email",
+  // 'password', @todo maybe if there is a usecase
+  "url",
+  "ip",
+  "date",
+  "time",
+  "datetime",
+  "telephone",
+  // Number
+  "number",
+  "range",
+  // Boolean
+  "toggle",
+  // Reference
+  "asset",
+  "entry"
+  // 'sharedValue', // @todo
+]);
+var ValueInputWidthSchema = import_zod4.default.enum(["12", "6", "4", "3"]);
+var ValueDefinitionBaseSchema = import_zod4.default.object({
+  id: uuidSchema.readonly(),
+  label: translatableStringSchema,
+  description: translatableStringSchema,
+  isRequired: import_zod4.default.boolean(),
+  isDisabled: import_zod4.default.boolean(),
+  isUnique: import_zod4.default.boolean(),
+  inputWidth: ValueInputWidthSchema
+});
+var StringValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend(
+  {
+    valueType: import_zod4.default.literal(ValueTypeSchema.Enum.string),
+    defaultValue: import_zod4.default.string().nullable()
+  }
+);
+var textValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
+  {
+    inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.text),
+    min: import_zod4.default.number().nullable(),
+    max: import_zod4.default.number().nullable()
+  }
+);
+var textareaValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.textarea),
+  min: import_zod4.default.number().nullable(),
+  max: import_zod4.default.number().nullable()
+});
+var emailValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.email),
+  defaultValue: import_zod4.default.string().email().nullable()
+});
+var urlValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.url),
+  defaultValue: import_zod4.default.string().url().nullable()
+});
+var ipValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.ip),
+  defaultValue: import_zod4.default.string().ip().nullable()
+});
+var dateValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
+  {
+    inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.date),
+    defaultValue: import_zod4.default.string().date().nullable()
+  }
+);
+var timeValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
+  {
+    inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.time),
+    defaultValue: import_zod4.default.string().time().nullable()
+  }
+);
+var datetimeValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.datetime),
+  defaultValue: import_zod4.default.string().datetime().nullable()
+});
+var telephoneValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.telephone)
+  // defaultValue: z.string().e164(), @todo when zod v4 releases @see https://github.com/colinhacks/zod/pull/3476
+});
+var stringValueDefinitionSchema = import_zod4.default.union([
+  textValueDefinitionSchema,
+  textareaValueDefinitionSchema,
+  emailValueDefinitionSchema,
+  urlValueDefinitionSchema,
+  ipValueDefinitionSchema,
+  dateValueDefinitionSchema,
+  timeValueDefinitionSchema,
+  datetimeValueDefinitionSchema,
+  telephoneValueDefinitionSchema
+]);
+var NumberValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend(
+  {
+    valueType: import_zod4.default.literal(ValueTypeSchema.Enum.number),
+    min: import_zod4.default.number().nullable(),
+    max: import_zod4.default.number().nullable(),
+    isUnique: import_zod4.default.literal(false),
+    defaultValue: import_zod4.default.number().nullable()
+  }
+);
+var numberValueDefinitionSchema = NumberValueDefinitionBaseSchema.extend({
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.number)
+});
+var rangeValueDefinitionSchema = NumberValueDefinitionBaseSchema.extend({
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.range),
+  // Overwrite from nullable to required because a range needs min, max and default to work and is required, since it always returns a number
+  isRequired: import_zod4.default.literal(true),
+  min: import_zod4.default.number(),
+  max: import_zod4.default.number(),
+  defaultValue: import_zod4.default.number()
+});
+var BooleanValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend({
+  valueType: import_zod4.default.literal(ValueTypeSchema.Enum.boolean),
+  // Overwrite from nullable to required because a boolean needs a default to work and is required, since it always is either true or false
+  isRequired: import_zod4.default.literal(true),
+  defaultValue: import_zod4.default.boolean(),
+  isUnique: import_zod4.default.literal(false)
+});
+var toggleValueDefinitionSchema = BooleanValueDefinitionBaseSchema.extend({
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.toggle)
+});
+var ReferenceValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend({
+  valueType: import_zod4.default.literal(ValueTypeSchema.Enum.reference)
+});
+var assetValueDefinitionSchema = ReferenceValueDefinitionBaseSchema.extend({
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.asset),
+  allowedMimeTypes: import_zod4.default.array(supportedAssetMimeTypeSchema).min(1),
+  min: import_zod4.default.number().nullable(),
+  max: import_zod4.default.number().nullable()
+});
+var entryValueDefinitionSchema = ReferenceValueDefinitionBaseSchema.extend({
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.entry),
+  ofCollections: import_zod4.default.array(uuidSchema),
+  min: import_zod4.default.number().nullable(),
+  max: import_zod4.default.number().nullable()
+});
+var valueDefinitionSchema = import_zod4.default.union([
+  stringValueDefinitionSchema,
+  numberValueDefinitionSchema,
+  rangeValueDefinitionSchema,
+  toggleValueDefinitionSchema,
+  assetValueDefinitionSchema,
+  entryValueDefinitionSchema
+  // sharedValueDefinitionSchema,
+]);
+var valueContentReferenceBase = import_zod4.default.object({
+  id: uuidSchema
+});
+var valueContentReferenceWithLanguageBase = valueContentReferenceBase.extend({
+  language: supportedLanguageSchema
+});
+var valueContentReferenceToAssetSchema = valueContentReferenceWithLanguageBase.extend({
+  objectType: import_zod4.default.literal(objectTypeSchema.Enum.asset)
+});
+var valueContentReferenceToCollectionSchema = valueContentReferenceBase.extend({
+  objectType: import_zod4.default.literal(objectTypeSchema.Enum.collection)
+});
+var valueContentReferenceToEntrySchema = valueContentReferenceBase.extend({
+  objectType: import_zod4.default.literal(objectTypeSchema.Enum.entry)
+});
+var valueContentReferenceSchema = import_zod4.default.union([
+  valueContentReferenceToAssetSchema,
+  valueContentReferenceToCollectionSchema,
+  valueContentReferenceToEntrySchema
+  // valueContentReferenceToSharedValueSchema,
+]);
+var resolvedValueContentReferenceSchema = import_zod4.default.union([
+  assetSchema,
+  import_zod4.default.lazy(() => entrySchema)
+  // Circular dependency / recursive type @see https://github.com/colinhacks/zod?tab=readme-ov-file#recursive-types
+  // resolvedValueContentReferenceToSharedValueSchema,
+]);
+var directValueBaseSchema = import_zod4.default.object({
+  objectType: import_zod4.default.literal(objectTypeSchema.Enum.value).readonly(),
+  definitionId: uuidSchema.readonly()
+});
+var directStringValueSchema = directValueBaseSchema.extend({
+  valueType: import_zod4.default.literal(ValueTypeSchema.Enum.string).readonly(),
+  content: translatableStringSchema
+});
+var directNumberValueSchema = directValueBaseSchema.extend({
+  valueType: import_zod4.default.literal(ValueTypeSchema.Enum.number).readonly(),
+  content: translatableNumberSchema
+});
+var directBooleanValueSchema = directValueBaseSchema.extend({
+  valueType: import_zod4.default.literal(ValueTypeSchema.Enum.boolean).readonly(),
+  content: translatableBooleanSchema
+});
+var directValueSchema = import_zod4.default.union([
+  directStringValueSchema,
+  directNumberValueSchema,
+  directBooleanValueSchema
+]);
+var referencedValueSchema = import_zod4.default.object({
+  objectType: import_zod4.default.literal(objectTypeSchema.Enum.value).readonly(),
+  definitionId: uuidSchema.readonly(),
+  valueType: import_zod4.default.literal(ValueTypeSchema.Enum.reference).readonly(),
+  content: translatableArrayOf(valueContentReferenceSchema)
+});
+var valueSchema = import_zod4.default.union([directValueSchema, referencedValueSchema]);
+var resolvedReferencedValueSchema = referencedValueSchema.extend({
+  content: translatableArrayOf(resolvedValueContentReferenceSchema)
+});
+var resolvedValueSchema = import_zod4.default.union([
+  directValueSchema,
+  resolvedReferencedValueSchema
+]);
+function getValueContentSchemaFromDefinition(definition) {
+  switch (definition.valueType) {
+    case ValueTypeSchema.Enum.boolean:
+      return getBooleanValueContentSchema(definition);
+    case ValueTypeSchema.Enum.number:
+      return getNumberValueContentSchema(definition);
+    case ValueTypeSchema.Enum.string:
+      return getStringValueContentSchema(definition);
+    case ValueTypeSchema.Enum.reference:
+      return getReferenceValueContentSchema(definition);
+    default:
+      throw new Error(
+        // @ts-expect-error
+        `Error generating schema for unsupported ValueType "${definition.valueType}"`
+      );
+  }
+}
+function getBooleanValueContentSchema(definition) {
+  return import_zod4.default.boolean();
+}
+function getNumberValueContentSchema(definition) {
+  let schema = import_zod4.default.number();
+  if (definition.min) {
+    schema = schema.min(definition.min);
+  }
+  if (definition.max) {
+    schema = schema.max(definition.max);
+  }
+  if (definition.isRequired === false) {
+    return schema.nullable();
+  }
+  return schema;
+}
+function getStringValueContentSchema(definition) {
+  let schema = import_zod4.default.string().trim();
+  if ("min" in definition && definition.min) {
+    schema = schema.min(definition.min);
+  }
+  if ("max" in definition && definition.max) {
+    schema = schema.max(definition.max);
+  }
+  switch (definition.inputType) {
+    case ValueInputTypeSchema.Enum.email:
+      schema = schema.email();
+      break;
+    case ValueInputTypeSchema.Enum.url:
+      schema = schema.url();
+      break;
+    case ValueInputTypeSchema.Enum.ip:
+      schema = schema.ip();
+      break;
+    case ValueInputTypeSchema.Enum.date:
+      schema = schema.date();
+      break;
+    case ValueInputTypeSchema.Enum.time:
+      schema = schema.time();
+      break;
+    case ValueInputTypeSchema.Enum.datetime:
+      schema = schema.datetime();
+      break;
+    case ValueInputTypeSchema.Enum.telephone:
+      break;
+  }
+  if (definition.isRequired === false) {
+    return schema.nullable();
+  }
+  return schema.min(1, "shared.stringValueRequired");
+}
+function getReferenceValueContentSchema(definition) {
+  let schema;
+  switch (definition.inputType) {
+    case ValueInputTypeSchema.Enum.asset:
+      {
+        schema = import_zod4.default.array(valueContentReferenceToAssetSchema);
+      }
+      break;
+    case ValueInputTypeSchema.Enum.entry:
+      {
+        schema = import_zod4.default.array(valueContentReferenceToEntrySchema);
+      }
+      break;
+  }
+  if (definition.isRequired) {
+    schema = schema.min(1, "shared.referenceRequired");
+  }
+  if (definition.min) {
+    schema = schema.min(definition.min);
+  }
+  if (definition.max) {
+    schema = schema.max(definition.max);
+  }
+  return schema;
+}
+
+// src/schema/entrySchema.ts
+var entryFileSchema = baseFileSchema.extend({
+  objectType: import_zod5.default.literal(objectTypeSchema.Enum.entry).readonly(),
+  values: import_zod5.default.array(valueSchema)
+});
+var entrySchema = entryFileSchema.extend({
+  values: import_zod5.default.array(import_zod5.default.lazy(() => resolvedValueSchema))
+});
+var entryExportSchema = entrySchema.extend({});
+var createEntrySchema = entryFileSchema.omit({
+  id: true,
+  objectType: true,
+  created: true,
+  updated: true
+}).extend({
+  projectId: uuidSchema.readonly(),
+  collectionId: uuidSchema.readonly(),
+  values: import_zod5.default.array(valueSchema)
+});
+var readEntrySchema = import_zod5.default.object({
+  id: uuidSchema.readonly(),
+  projectId: uuidSchema.readonly(),
+  collectionId: uuidSchema.readonly()
+});
+var updateEntrySchema = entrySchema.omit({
+  objectType: true,
+  created: true,
+  updated: true
+}).extend({
+  projectId: uuidSchema.readonly(),
+  collectionId: uuidSchema.readonly()
+});
+var deleteEntrySchema = readEntrySchema.extend({});
+var countEntriesSchema = import_zod5.default.object({
+  projectId: uuidSchema.readonly(),
+  collectionId: uuidSchema.readonly()
+});
+
+// src/schema/collectionSchema.ts
+var collectionFileSchema = baseFileSchema.extend({
+  objectType: import_zod6.default.literal(objectTypeSchema.Enum.collection).readonly(),
+  name: import_zod6.default.object({
+    singular: translatableStringSchema,
+    plural: translatableStringSchema
+  }),
+  slug: import_zod6.default.object({
+    singular: import_zod6.default.string(),
+    plural: import_zod6.default.string()
+  }),
+  description: translatableStringSchema,
+  icon: supportedIconSchema,
+  valueDefinitions: import_zod6.default.array(valueDefinitionSchema)
+});
+var collectionSchema = collectionFileSchema.extend({});
+var collectionExportSchema = collectionSchema.extend({
+  entries: import_zod6.default.array(entryExportSchema)
+});
+var createCollectionSchema = collectionSchema.omit({
+  id: true,
+  objectType: true,
+  created: true,
+  updated: true
+}).extend({
+  projectId: uuidSchema.readonly()
+});
+var readCollectionSchema = import_zod6.default.object({
+  id: uuidSchema.readonly(),
+  projectId: uuidSchema.readonly()
+});
+var updateCollectionSchema = collectionFileSchema.pick({
+  id: true,
+  name: true,
+  slug: true,
+  description: true,
+  icon: true,
+  valueDefinitions: true
+}).extend({
+  projectId: uuidSchema.readonly()
+});
+var deleteCollectionSchema = readCollectionSchema.extend({});
+var countCollectionsSchema = import_zod6.default.object({
+  projectId: uuidSchema.readonly()
+});
+
+// src/schema/coreSchema.ts
+var import_zod7 = require("zod");
+var elekIoCoreOptionsSchema = import_zod7.z.object({
+  /**
+   * The environment elek.io Core is currently running in
+   */
+  environment: environmentSchema,
+  /**
+   * The current version of elek.io Core
+   */
+  version: versionSchema,
+  file: import_zod7.z.object({
+    json: import_zod7.z.object({
+      /**
+       * If set, adds indentation with spaces (number) or escape character (string)
+       * and line break characters to saved JSON files on disk, to make them easier to read.
+       * Defaults to 2 spaces of indentation.
+       */
+      indentation: import_zod7.z.union([import_zod7.z.number(), import_zod7.z.string()])
+    })
+  })
+});
+var constructorElekIoCoreSchema = elekIoCoreOptionsSchema.omit({
+  version: true
+}).partial({
+  environment: true,
+  file: true
+}).optional();
+
+// src/schema/gitSchema.ts
+var import_zod8 = require("zod");
+var gitRepositoryPathSchema = import_zod8.z.string();
+var gitSignatureSchema = import_zod8.z.object({
+  name: import_zod8.z.string(),
+  email: import_zod8.z.string()
+});
+var gitCommitSchema = import_zod8.z.object({
+  /**
+   * SHA-1 hash of the commit
+   */
+  hash: import_zod8.z.string(),
+  message: import_zod8.z.string(),
+  author: gitSignatureSchema,
+  timestamp: import_zod8.z.number(),
+  tag: import_zod8.z.string().nullable()
+});
+var GitCommitIconNative = /* @__PURE__ */ ((GitCommitIconNative2) => {
+  GitCommitIconNative2["INIT"] = ":tada:";
+  GitCommitIconNative2["CREATE"] = ":heavy_plus_sign:";
+  GitCommitIconNative2["UPDATE"] = ":wrench:";
+  GitCommitIconNative2["DELETE"] = ":fire:";
+  return GitCommitIconNative2;
+})(GitCommitIconNative || {});
+var gitCommitIconSchema = import_zod8.z.nativeEnum(GitCommitIconNative);
+var gitInitOptionsSchema = import_zod8.z.object({
+  /**
+   * Use the specified name for the initial branch in the newly created repository. If not specified, fall back to the default name (currently master, but this is subject to change in the future; the name can be customized via the init.defaultBranch configuration variable).
+   */
+  initialBranch: import_zod8.z.string()
+});
+var gitCloneOptionsSchema = import_zod8.z.object({
+  /**
+   * Create a shallow clone with a history truncated to the specified number of commits. Implies --single-branch unless --no-single-branch is given to fetch the histories near the tips of all branches. If you want to clone submodules shallowly, also pass --shallow-submodules.
+   */
+  depth: import_zod8.z.number(),
+  /**
+   * Clone only the history leading to the tip of a single branch, either specified by the --branch option or the primary branch remote’s HEAD points at. Further fetches into the resulting repository will only update the remote-tracking branch for the branch this option was used for the initial cloning. If the HEAD at the remote did not point at any branch when --single-branch clone was made, no remote-tracking branch is created.
+   */
+  singleBranch: import_zod8.z.boolean(),
+  /**
+   * Instead of pointing the newly created HEAD to the branch pointed to by the cloned repository’s HEAD, point to <name> branch instead. In a non-bare repository, this is the branch that will be checked out. --branch can also take tags and detaches the HEAD at that commit in the resulting repository.
+   */
+  branch: import_zod8.z.string()
+});
+var gitSwitchOptionsSchema = import_zod8.z.object({
+  /**
+   * If true, creates a new local branch and then switches to it
+   *
+   * @see https://git-scm.com/docs/git-switch#Documentation/git-switch.txt---createltnew-branchgt
+   */
+  isNew: import_zod8.z.boolean().optional()
+});
+var gitLogOptionsSchema = import_zod8.z.object({
+  /**
+   * Limit the result to given number of commits
+   */
+  limit: import_zod8.z.number().optional(),
+  /**
+   * Only list commits that are between given SHAs or tag names
+   *
+   * Note that the commits of from and to are not included in the result
+   */
+  between: import_zod8.z.object({
+    /**
+     * From the oldest commit
+     */
+    from: import_zod8.z.string(),
+    /**
+     * To the newest commit
+     *
+     * Defaults to the current HEAD
+     */
+    to: import_zod8.z.string().optional()
+  })
+});
+
+// src/schema/gitTagSchema.ts
+var import_zod9 = require("zod");
+var gitTagSchema = import_zod9.z.object({
+  id: uuidSchema,
+  message: import_zod9.z.string(),
+  author: gitSignatureSchema,
+  timestamp: import_zod9.z.number()
+});
+var createGitTagSchema = gitTagSchema.pick({
+  message: true
+}).extend({
+  path: gitRepositoryPathSchema,
+  hash: gitCommitSchema.shape.hash.optional()
+});
+var readGitTagSchema = import_zod9.z.object({
+  path: gitRepositoryPathSchema,
+  id: uuidSchema.readonly()
+});
+var deleteGitTagSchema = readGitTagSchema.extend({});
+var countGitTagsSchema = import_zod9.z.object({
+  path: gitRepositoryPathSchema
+});
+
+// src/schema/projectSchema.ts
+var import_zod10 = require("zod");
+var projectStatusSchema = import_zod10.z.enum(["foo", "bar", "todo"]);
+var projectSettingsSchema = import_zod10.z.object({
+  language: import_zod10.z.object({
+    default: supportedLanguageSchema,
+    supported: import_zod10.z.array(supportedLanguageSchema)
+  })
+});
+var projectFolderSchema = import_zod10.z.enum([
+  "assets",
+  "collections",
+  "shared-values",
+  "lfs"
+  // 'logs',
+  // 'public',
+  // 'theme',
+]);
+var projectFileSchema = baseFileSchema.extend({
+  objectType: import_zod10.z.literal(objectTypeSchema.Enum.project).readonly(),
+  coreVersion: versionSchema,
+  name: import_zod10.z.string().trim().min(1, "shared.projectNameRequired"),
+  description: import_zod10.z.string().trim().min(1, "shared.projectDescriptionRequired"),
+  version: versionSchema,
+  status: projectStatusSchema,
+  settings: projectSettingsSchema
+});
+var projectSchema = projectFileSchema.extend({});
+var projectExportSchema = projectSchema.extend({
+  assets: import_zod10.z.array(assetExportSchema),
+  collections: import_zod10.z.array(collectionExportSchema)
+});
+var createProjectSchema = projectSchema.pick({
+  name: true,
+  description: true,
+  settings: true
+}).partial({
+  description: true,
+  settings: true
+});
+var readProjectSchema = import_zod10.z.object({
+  id: uuidSchema.readonly()
+});
+var updateProjectSchema = projectSchema.pick({
+  id: true,
+  name: true,
+  description: true,
+  settings: true
+}).partial({
+  name: true,
+  description: true,
+  settings: true
+});
+var upgradeProjectSchema = import_zod10.z.object({
+  id: uuidSchema.readonly()
+});
+var deleteProjectSchema = readProjectSchema.extend({});
+var projectUpgradeSchema = import_zod10.z.object({
+  /**
+   * The Core version the Project will be upgraded to
+   */
+  to: versionSchema.readonly(),
+  /**
+   * Function that will be executed in the process of upgrading a Project
+   */
+  run: import_zod10.z.function().args(projectFileSchema).returns(import_zod10.z.promise(import_zod10.z.void()))
+});
+var cloneProjectSchema = import_zod10.z.object({
+  url: import_zod10.z.string()
+});
+var listBranchesProjectSchema = import_zod10.z.object({
+  id: uuidSchema.readonly()
+});
+var currentBranchProjectSchema = import_zod10.z.object({
+  id: uuidSchema.readonly()
+});
+var switchBranchProjectSchema = import_zod10.z.object({
+  id: uuidSchema.readonly(),
+  branch: import_zod10.z.string(),
+  options: gitSwitchOptionsSchema.optional()
+});
+var getRemoteOriginUrlProjectSchema = import_zod10.z.object({
+  id: uuidSchema.readonly()
+});
+var setRemoteOriginUrlProjectSchema = import_zod10.z.object({
+  id: uuidSchema.readonly(),
+  url: import_zod10.z.string()
+});
+var getChangesProjectSchema = import_zod10.z.object({
+  id: uuidSchema.readonly()
+});
+var synchronizeProjectSchema = import_zod10.z.object({
+  id: uuidSchema.readonly()
+});
+var searchProjectSchema = import_zod10.z.object({
+  id: uuidSchema.readonly(),
+  query: import_zod10.z.string(),
+  language: supportedLanguageSchema,
+  type: import_zod10.z.array(objectTypeSchema).optional()
+});
+
+// src/schema/serviceSchema.ts
+var import_zod11 = require("zod");
+var serviceTypeSchema = import_zod11.z.enum([
+  "Git",
+  "GitTag",
+  "User",
+  "Project",
+  "Asset",
+  "JsonFile",
+  "Search",
+  "Collection",
+  "Entry",
+  "Value"
+]);
+var listSchema = import_zod11.z.object({
+  projectId: uuidSchema,
+  limit: import_zod11.z.number().optional(),
+  offset: import_zod11.z.number().optional()
+});
+var listCollectionsSchema = listSchema;
+var listEntriesSchema = listSchema.extend({
+  collectionId: uuidSchema
+});
+var listAssetsSchema = listSchema;
+var listProjectsSchema = listSchema.omit({
+  projectId: true
+});
+var listGitTagsSchema = import_zod11.z.object({
+  path: gitRepositoryPathSchema
+});
+
+// src/schema/userSchema.ts
+var import_zod12 = __toESM(require("zod"), 1);
+var UserTypeSchema = import_zod12.default.enum(["local", "cloud"]);
+var baseUserSchema = gitSignatureSchema.extend({
+  userType: UserTypeSchema,
+  language: supportedLanguageSchema
+});
+var localUserSchema = baseUserSchema.extend({
+  userType: import_zod12.default.literal(UserTypeSchema.Enum.local)
+});
+var cloudUserSchema = baseUserSchema.extend({
+  userType: import_zod12.default.literal(UserTypeSchema.Enum.cloud),
+  id: uuidSchema
+});
+var userFileSchema = import_zod12.default.union([localUserSchema, cloudUserSchema]);
+var userSchema = userFileSchema;
+var setUserSchema = userSchema;
+
+// src/util/shared.ts
+var import_slugify = __toESM(require("slugify"), 1);
+var import_uuid = require("uuid");
+var Slugify = import_slugify.default.default || import_slugify.default;
+function uuid() {
+  return (0, import_uuid.v4)();
+}
+function currentTimestamp() {
+  return Math.floor(Date.now() / 1e3);
+}
+function slug(string) {
+  return Slugify(string, {
+    replacement: "-",
+    // replace spaces with replacement character, defaults to `-`
+    remove: void 0,
+    // remove characters that match regex, defaults to `undefined`
+    lower: true,
+    // convert to lower case, defaults to `false`
+    strict: true
+    // strip special characters except replacement, defaults to `false`
+  });
+}
+//# sourceMappingURL=index.browser.cjs.map