@relyio/sdk 0.2.0

package/dist/chunk-2QUK2ZGD.js

@@ -0,0 +1,738 @@
+import { __name, __export } from './chunk-XQ4QHWZE.js';
+
+/* RelyIO SDK - Built with ❤️ by the RelyIO Team */
+
+// src/schema/define-workflow.ts
+function defineWorkflowStage(id, config) {
+  if (!id || id.length === 0) {
+    throw new Error("Workflow stage ID is required");
+  }
+  const stageIdPattern = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$|^[a-z][a-zA-Z0-9]*$/;
+  if (!stageIdPattern.test(id)) {
+    throw new Error(
+      `Workflow stage ID '${id}' must be kebab-case (e.g., editorial-review) or camelCase (e.g., editorialReview)`
+    );
+  }
+  if (id.length > 64) {
+    throw new Error(`Workflow stage ID '${id}' must be 64 characters or less`);
+  }
+  if (!config.displayName || config.displayName.length === 0) {
+    throw new Error("Workflow stage displayName is required");
+  }
+  if (config.displayName.length > 128) {
+    throw new Error(`Workflow stage displayName must be 128 characters or less`);
+  }
+  if (config.description != null && config.description.length > 512) {
+    throw new Error(`Workflow stage description must be 512 characters or less`);
+  }
+  const requiredApprovals = config.requiredApprovals ?? 1;
+  if (requiredApprovals < 1 || requiredApprovals > 10) {
+    throw new Error(`requiredApprovals must be between 1 and 10`);
+  }
+  if (config.timeoutDays !== void 0) {
+    if (config.timeoutDays < 1 || config.timeoutDays > 365) {
+      throw new Error(`timeoutDays must be between 1 and 365`);
+    }
+  }
+  if (config.autoAssign) {
+    if (!Array.isArray(config.autoAssign.roles) || config.autoAssign.roles.length === 0) {
+      throw new Error(`autoAssign.roles must be a non-empty array`);
+    }
+  }
+  return {
+    _tag: "workflowStage",
+    id,
+    displayName: config.displayName,
+    ...config.description !== void 0 && config.description !== "" && { description: config.description },
+    requiredApprovals,
+    ...config.allowedRoles !== void 0 && config.allowedRoles.length > 0 && { allowedRoles: config.allowedRoles },
+    ...config.autoAssign !== void 0 && { autoAssign: config.autoAssign },
+    ...config.timeoutDays !== void 0 && { timeoutDays: config.timeoutDays },
+    ...config.escalation !== void 0 && { escalation: config.escalation }
+  };
+}
+__name(defineWorkflowStage, "defineWorkflowStage");
+function defineWorkflow(config) {
+  const enabled = config.enabled ?? false;
+  const stages = config.stages ?? [];
+  if (stages.length > 0) {
+    const stageIds = /* @__PURE__ */ new Set();
+    for (const stage of stages) {
+      if (stageIds.has(stage.id)) {
+        throw new Error(`Duplicate workflow stage ID '${stage.id}'`);
+      }
+      stageIds.add(stage.id);
+    }
+  }
+  return {
+    _tag: "workflow",
+    enabled,
+    stages
+  };
+}
+__name(defineWorkflow, "defineWorkflow");
+function defineContentTypeWorkflow(config) {
+  return {
+    ...config.enabled !== void 0 && { enabled: config.enabled },
+    ...config.stages !== void 0 && config.stages.length > 0 && { stages: config.stages },
+    ...config.autoPublish !== void 0 && { autoPublish: config.autoPublish },
+    ...config.requireAllLocales !== void 0 && { requireAllLocales: config.requireAllLocales }
+  };
+}
+__name(defineContentTypeWorkflow, "defineContentTypeWorkflow");
+function isWorkflowStageDefinition(value) {
+  return typeof value === "object" && value !== null && "_tag" in value && value._tag === "workflowStage";
+}
+__name(isWorkflowStageDefinition, "isWorkflowStageDefinition");
+function isWorkflowDefinition(value) {
+  return typeof value === "object" && value !== null && "_tag" in value && value._tag === "workflow";
+}
+__name(isWorkflowDefinition, "isWorkflowDefinition");
+function getWorkflowStageIds(workflow) {
+  return workflow.stages.map((s) => s.id);
+}
+__name(getWorkflowStageIds, "getWorkflowStageIds");
+function findWorkflowStage(workflow, stageId) {
+  return workflow.stages.find((s) => s.id === stageId);
+}
+__name(findWorkflowStage, "findWorkflowStage");
+function getNextWorkflowStage(workflow, currentStageId) {
+  const currentIndex = workflow.stages.findIndex((s) => s.id === currentStageId);
+  if (currentIndex === -1 || currentIndex === workflow.stages.length - 1) {
+    return null;
+  }
+  const nextStage = workflow.stages[currentIndex + 1];
+  return nextStage ?? null;
+}
+__name(getNextWorkflowStage, "getNextWorkflowStage");
+function getFirstWorkflowStage(workflow) {
+  if (workflow.stages.length === 0) return null;
+  const firstStage = workflow.stages[0];
+  return firstStage ?? null;
+}
+__name(getFirstWorkflowStage, "getFirstWorkflowStage");
+function isFinalWorkflowStage(workflow, stageId) {
+  if (workflow.stages.length === 0) return false;
+  const lastStage = workflow.stages[workflow.stages.length - 1];
+  return lastStage?.id === stageId;
+}
+__name(isFinalWorkflowStage, "isFinalWorkflowStage");
+function workflowToJSON(workflow) {
+  return {
+    enabled: workflow.enabled,
+    ...workflow.stages.length > 0 && {
+      stages: workflow.stages.map((stage) => {
+        const { _tag: _, ...rest } = stage;
+        return rest;
+      })
+    }
+  };
+}
+__name(workflowToJSON, "workflowToJSON");
+
+// src/schema/define-view.ts
+function generateSlugFromId(id) {
+  return id.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
+}
+__name(generateSlugFromId, "generateSlugFromId");
+function defineView(id, config) {
+  if (!id.match(/^[a-zA-Z][a-zA-Z0-9_-]*$/)) {
+    throw new Error(
+      `View ID '${id}' must start with a letter and contain only letters, numbers, underscores, and hyphens`
+    );
+  }
+  if (!config.name || config.name.length === 0) {
+    throw new Error(`View '${id}' must have a name`);
+  }
+  if (config.metadataFields && config.metadataFields.length > 3) {
+    throw new Error(`View '${id}' can have at most 3 metadata fields`);
+  }
+  if (!config.scope?.type) {
+    throw new Error(`View '${id}' must have a valid scope`);
+  }
+  const slug2 = config.slug ?? generateSlugFromId(id);
+  if (!slug2.match(/^[a-z][a-z0-9-]*$/)) {
+    throw new Error(
+      `View '${id}' slug '${slug2}' must be lowercase, start with a letter, and contain only letters, numbers, and hyphens`
+    );
+  }
+  return {
+    _tag: "view",
+    id,
+    slug: slug2,
+    ...config
+  };
+}
+__name(defineView, "defineView");
+function viewToJSON(view) {
+  const { _tag, ...rest } = view;
+  return rest;
+}
+__name(viewToJSON, "viewToJSON");
+
+// src/schema/define-schema.ts
+function defineSchema(config) {
+  if (config.contentTypes == null || Object.keys(config.contentTypes).length === 0) {
+    throw new Error("Schema must have at least one content type");
+  }
+  if (config.locales && config.locales.length > 0) {
+    const defaultLocales = config.locales.filter((l) => l.default === true);
+    if (defaultLocales.length === 0) {
+      throw new Error("Schema with locales must have exactly one default locale");
+    }
+    if (defaultLocales.length > 1) {
+      throw new Error(
+        `Schema has ${defaultLocales.length} default locales. Only one locale can be the default.`
+      );
+    }
+    const codes = config.locales.map((l) => l.code);
+    const uniqueCodes = new Set(codes);
+    if (codes.length !== uniqueCodes.size) {
+      throw new Error("Schema has duplicate locale codes");
+    }
+    for (const locale of config.locales) {
+      if (locale.fallback) {
+        for (const fallbackCode of locale.fallback) {
+          if (!uniqueCodes.has(fallbackCode)) {
+            throw new Error(
+              `Locale '${locale.code}' has fallback to non-existent locale '${fallbackCode}'`
+            );
+          }
+        }
+      }
+    }
+  }
+  if (config.roles && config.roles.length > 0) {
+    const roleIds = /* @__PURE__ */ new Set();
+    for (const role of config.roles) {
+      if (roleIds.has(role.id)) {
+        throw new Error(`Duplicate role ID '${role.id}'`);
+      }
+      roleIds.add(role.id);
+    }
+  }
+  if (config.workflow) {
+    const builtInRoles = /* @__PURE__ */ new Set(["admin", "editor", "viewer"]);
+    const customRoleIds = new Set(config.roles?.map((r) => r.id) ?? []);
+    const allRoleIds = /* @__PURE__ */ new Set([...builtInRoles, ...customRoleIds]);
+    for (const stage of config.workflow.stages) {
+      if (stage.allowedRoles) {
+        for (const roleId of stage.allowedRoles) {
+          if (!allRoleIds.has(roleId)) {
+            throw new Error(`Workflow stage '${stage.id}' references non-existent role '${roleId}'`);
+          }
+        }
+      }
+      if (stage.autoAssign?.roles) {
+        for (const roleId of stage.autoAssign.roles) {
+          if (!allRoleIds.has(roleId)) {
+            throw new Error(
+              `Workflow stage '${stage.id}' autoAssign references non-existent role '${roleId}'`
+            );
+          }
+        }
+      }
+      if (stage.escalation) {
+        for (const roleId of stage.escalation.notifyRoles ?? []) {
+          if (!allRoleIds.has(roleId)) {
+            throw new Error(
+              `Workflow stage '${stage.id}' escalation.notifyRoles references non-existent role '${roleId}'`
+            );
+          }
+        }
+        for (const roleId of stage.escalation.escalateToRoles ?? []) {
+          if (!allRoleIds.has(roleId)) {
+            throw new Error(
+              `Workflow stage '${stage.id}' escalation.escalateToRoles references non-existent role '${roleId}'`
+            );
+          }
+        }
+      }
+    }
+  }
+  if (config.views && config.views.length > 0) {
+    const viewIds = /* @__PURE__ */ new Set();
+    for (const view of config.views) {
+      if (viewIds.has(view.id)) {
+        throw new Error(`Duplicate view ID '${view.id}'`);
+      }
+      viewIds.add(view.id);
+    }
+  }
+  return {
+    _tag: "schema",
+    ...config.locales && config.locales.length > 0 && { locales: config.locales },
+    contentTypes: config.contentTypes,
+    components: config.components ?? {},
+    singletonContentTypes: config.singletonContentTypes ?? {},
+    queries: config.queries ?? {},
+    settingsGroups: config.settingsGroups,
+    ...config.assetTypes && { assetTypes: config.assetTypes },
+    ...config.roles && config.roles.length > 0 && { roles: config.roles },
+    ...config.workflow && { workflow: config.workflow },
+    ...config.views && config.views.length > 0 && { views: config.views }
+  };
+}
+__name(defineSchema, "defineSchema");
+function schemaToJSON(schema) {
+  const stripTag = /* @__PURE__ */ __name((obj) => {
+    const { _tag, ...rest } = obj;
+    return rest;
+  }, "stripTag");
+  return {
+    // Include locales if defined (strip _tag from each locale)
+    ...schema.locales && schema.locales.length > 0 && {
+      locales: schema.locales.map((locale) => stripTag(locale))
+    },
+    contentTypes: Object.fromEntries(
+      Object.entries(schema.contentTypes).map(([key, value]) => [key, stripTag(value)])
+    ),
+    components: Object.fromEntries(
+      Object.entries(schema.components).map(([key, value]) => [key, stripTag(value)])
+    ),
+    singletonContentTypes: Object.fromEntries(
+      Object.entries(schema.singletonContentTypes).map(([key, value]) => [key, stripTag(value)])
+    ),
+    queries: Object.fromEntries(
+      Object.entries(schema.queries).map(([key, value]) => [key, stripTag(value)])
+    ),
+    ...schema.settingsGroups && {
+      settingsGroups: Object.fromEntries(
+        Object.entries(schema.settingsGroups).map(([key, value]) => [key, stripTag(value)])
+      )
+    },
+    ...schema.assetTypes && Object.keys(schema.assetTypes).length > 0 && {
+      assetTypes: Object.fromEntries(
+        Object.entries(schema.assetTypes).map(([key, value]) => [key, stripTag(value)])
+      )
+    },
+    // Include roles if defined (strip _tag from each role)
+    ...schema.roles && schema.roles.length > 0 && {
+      roles: schema.roles.map((role) => stripTag(role))
+    },
+    // Include workflow if defined (convert to JSON format)
+    ...schema.workflow && {
+      workflow: workflowToJSON(schema.workflow)
+    },
+    // Include views if defined (convert to JSON format)
+    ...schema.views && schema.views.length > 0 && {
+      views: schema.views.map((view) => viewToJSON(view))
+    }
+  };
+}
+__name(schemaToJSON, "schemaToJSON");
+
+// src/schema/define-locale.ts
+var BCP47_PATTERN = /^[a-z]{2}(-[A-Z]{2})?$/;
+function defineLocale(code, options) {
+  if (!BCP47_PATTERN.test(code)) {
+    throw new Error(
+      `Invalid locale code '${code}'. Expected BCP 47 format: 'xx' or 'xx-XX' (e.g., 'en', 'en-US', 'fr-FR')`
+    );
+  }
+  if (!options.displayName || options.displayName.trim().length === 0) {
+    throw new Error(`Locale '${code}' requires a displayName`);
+  }
+  if (options.fallback) {
+    for (const fallbackCode of options.fallback) {
+      if (typeof fallbackCode !== "string" || !BCP47_PATTERN.test(fallbackCode)) {
+        throw new Error(
+          `Invalid fallback locale code '${fallbackCode}' in locale '${code}'. Expected BCP 47 format.`
+        );
+      }
+      if (fallbackCode === code) {
+        throw new Error(`Locale '${code}' cannot reference itself in fallback chain`);
+      }
+    }
+  }
+  return {
+    _tag: "locale",
+    code,
+    displayName: options.displayName,
+    ...options.default !== void 0 && { default: options.default },
+    ...options.fallback && options.fallback.length > 0 && { fallback: options.fallback },
+    ...options.direction && options.direction !== "ltr" && { direction: options.direction },
+    ...options.active !== void 0 && options.active !== true && { active: options.active }
+  };
+}
+__name(defineLocale, "defineLocale");
+function isLocaleDefinition(value) {
+  return typeof value === "object" && value !== null && "_tag" in value && value._tag === "locale";
+}
+__name(isLocaleDefinition, "isLocaleDefinition");
+function getLocaleCodes(locales) {
+  return locales.map((l) => l.code);
+}
+__name(getLocaleCodes, "getLocaleCodes");
+function findDefaultLocale(locales) {
+  return locales.find((l) => l.default === true);
+}
+__name(findDefaultLocale, "findDefaultLocale");
+function getActiveLocales(locales) {
+  return locales.filter((l) => l.active !== false);
+}
+__name(getActiveLocales, "getActiveLocales");
+function buildFallbackChain(localeCode, locales, maxDepth = 10) {
+  const localeMap = new Map(locales.map((l) => [l.code, l]));
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set();
+  function addFallbacks(code, depth) {
+    if (depth > maxDepth || visited.has(code)) return;
+    const locale = localeMap.get(code);
+    if (!locale?.fallback) return;
+    visited.add(code);
+    for (const fallbackCode of locale.fallback) {
+      if (!chain.includes(fallbackCode) && fallbackCode !== localeCode) {
+        chain.push(fallbackCode);
+        addFallbacks(fallbackCode, depth + 1);
+      }
+    }
+  }
+  __name(addFallbacks, "addFallbacks");
+  addFallbacks(localeCode, 0);
+  return chain;
+}
+__name(buildFallbackChain, "buildFallbackChain");
+
+// src/schema/define-content-type.ts
+function fieldset(id, config) {
+  return {
+    id,
+    displayName: config.displayName,
+    description: config.description,
+    ai: config.ai,
+    fields: config.fields
+  };
+}
+__name(fieldset, "fieldset");
+function defineContentType(name, config) {
+  const base = {
+    _tag: "contentType",
+    name,
+    displayName: config.displayName,
+    displayNamePlural: config.displayNamePlural,
+    description: config.description,
+    ai: config.ai,
+    displayField: config.displayField,
+    hierarchical: config.hierarchical ?? false,
+    ...config.accessTags !== void 0 && config.accessTags.length > 0 && { accessTags: config.accessTags },
+    ...config.workflow !== void 0 && { workflow: config.workflow }
+  };
+  if ("fields" in config && config.fields) {
+    return { ...base, fields: config.fields };
+  }
+  if ("fieldsets" in config && config.fieldsets) {
+    return { ...base, fieldsets: config.fieldsets };
+  }
+  throw new Error("Content type must have either fields or fieldsets");
+}
+__name(defineContentType, "defineContentType");
+
+// src/schema/define-singleton.ts
+function defineSingletonContentType(name, config) {
+  const base = {
+    _tag: "singletonContentType",
+    name,
+    displayName: config.displayName,
+    displayNamePlural: config.displayNamePlural,
+    description: config.description,
+    ai: config.ai,
+    displayField: config.displayField,
+    hierarchical: false,
+    ...config.accessTags !== void 0 && config.accessTags.length > 0 && { accessTags: config.accessTags }
+  };
+  if ("fields" in config && config.fields) {
+    return { ...base, fields: config.fields };
+  }
+  if ("fieldsets" in config && config.fieldsets) {
+    return { ...base, fieldsets: config.fieldsets };
+  }
+  throw new Error("Singleton content type must have either fields or fieldsets");
+}
+__name(defineSingletonContentType, "defineSingletonContentType");
+var defineSingleton = defineSingletonContentType;
+
+// src/schema/define-component.ts
+function defineComponent(name, config) {
+  return {
+    _tag: "component",
+    name,
+    displayName: config.displayName,
+    description: config.description,
+    ai: config.ai,
+    deprecated: config.deprecated ?? false,
+    fields: config.fields,
+    metadata: config.metadata
+  };
+}
+__name(defineComponent, "defineComponent");
+
+// src/schema/define-settings-group.ts
+function defineSettingsGroup(name, config) {
+  return {
+    _tag: "settingsGroup",
+    name,
+    displayName: config.displayName,
+    description: config.description,
+    ai: config.ai,
+    ...config.accessTags !== void 0 && config.accessTags.length > 0 && { accessTags: config.accessTags },
+    fields: config.fields
+  };
+}
+__name(defineSettingsGroup, "defineSettingsGroup");
+
+// src/schema/define-asset-type.ts
+function defineAssetType(name, config) {
+  const kindKeys = ["image", "video", "file"].filter((k) => config[k] !== void 0);
+  if (kindKeys.length === 0) {
+    throw new Error(`Asset type '${name}' must declare exactly one kind key: image, video, or file`);
+  }
+  if (kindKeys.length > 1) {
+    throw new Error(
+      `Asset type '${name}' declares multiple kind keys (${kindKeys.join(", ")}); exactly one is allowed`
+    );
+  }
+  const base = {
+    _tag: "assetType",
+    name,
+    displayName: config.displayName,
+    displayNamePlural: config.displayNamePlural,
+    description: config.description,
+    ai: config.ai,
+    displayField: config.displayField,
+    ...config.accessTags !== void 0 && config.accessTags.length > 0 && { accessTags: config.accessTags },
+    ...config.workflow !== void 0 && { workflow: config.workflow },
+    ...config.image !== void 0 && { image: config.image },
+    ...config.video !== void 0 && { video: config.video },
+    ...config.file !== void 0 && { file: config.file }
+  };
+  if ("fields" in config && config.fields) {
+    return { ...base, fields: config.fields };
+  }
+  if ("fieldsets" in config && config.fieldsets) {
+    return { ...base, fieldsets: config.fieldsets };
+  }
+  throw new Error(`Asset type '${name}' must have either fields or fieldsets`);
+}
+__name(defineAssetType, "defineAssetType");
+
+// src/schema/define-role.ts
+var BUILT_IN_ROLES = ["admin", "editor", "viewer"];
+var ROLE_ACTIONS = [
+  "create",
+  "read",
+  "update",
+  "delete",
+  "publish",
+  "unpublish",
+  "duplicate",
+  "comment",
+  "approveElevated"
+];
+var BUILT_IN_ROLE_ACTIONS = {
+  admin: ["create", "read", "update", "delete", "publish", "unpublish", "duplicate", "comment"],
+  editor: ["create", "read", "update", "delete", "publish", "unpublish", "duplicate", "comment"],
+  viewer: ["read", "comment"]
+};
+function defineRole(id, config) {
+  if (!id || id.length === 0) {
+    throw new Error("Role ID is required");
+  }
+  const roleIdPattern = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$|^[a-z][a-zA-Z0-9]*$/;
+  if (!roleIdPattern.test(id)) {
+    throw new Error(
+      `Role ID '${id}' must be kebab-case (e.g., blog-editor) or camelCase (e.g., blogEditor)`
+    );
+  }
+  if (BUILT_IN_ROLES.includes(id)) {
+    throw new Error(`Role ID '${id}' cannot use a built-in role name (admin, editor, viewer)`);
+  }
+  if (!config.displayName || config.displayName.length === 0) {
+    throw new Error("Role displayName is required");
+  }
+  const hasBaseRole = config.baseRole !== void 0;
+  const hasIncludes = Array.isArray(config.includes) && config.includes.length > 0;
+  const hasPermissions = Array.isArray(config.permissions) && config.permissions.length > 0;
+  const hasHiddenFields = config.fields !== void 0 && Array.isArray(config.fields.hidden) && config.fields.hidden.length > 0;
+  const hasReadonlyFields = config.fields !== void 0 && Array.isArray(config.fields.readonly) && config.fields.readonly.length > 0;
+  const hasFields = hasHiddenFields || hasReadonlyFields;
+  if (!hasBaseRole && !hasIncludes && !hasPermissions && !hasFields) {
+    throw new Error(
+      `Role '${id}' must have at least one of: 'baseRole', 'includes', or permissions (with tags/actions or fields)`
+    );
+  }
+  if (Array.isArray(config.permissions) && config.permissions.length > 0) {
+    for (const perm of config.permissions) {
+      if (perm.tags.length === 0) {
+        throw new Error(`Permission in role '${id}' must have at least one tag`);
+      }
+      if (perm.actions.length === 0) {
+        throw new Error(`Permission in role '${id}' must have at least one action`);
+      }
+      for (const action of perm.actions) {
+        if (!ROLE_ACTIONS.includes(action)) {
+          throw new Error(
+            `Invalid action '${action}' in role '${id}'. Valid actions: ${ROLE_ACTIONS.join(", ")}`
+          );
+        }
+      }
+    }
+  }
+  return {
+    _tag: "role",
+    id,
+    displayName: config.displayName,
+    ...config.description !== void 0 && config.description !== "" && { description: config.description },
+    ...config.baseRole !== void 0 && { baseRole: config.baseRole },
+    ...hasIncludes && { includes: config.includes },
+    ...hasPermissions && { permissions: config.permissions },
+    ...config.fields !== void 0 && { fields: config.fields }
+  };
+}
+__name(defineRole, "defineRole");
+function isRoleDefinition(value) {
+  return typeof value === "object" && value !== null && "_tag" in value && value._tag === "role";
+}
+__name(isRoleDefinition, "isRoleDefinition");
+function isBuiltInRole(roleId) {
+  return BUILT_IN_ROLES.includes(roleId);
+}
+__name(isBuiltInRole, "isBuiltInRole");
+function getBuiltInRoleActions(roleId) {
+  return BUILT_IN_ROLE_ACTIONS[roleId];
+}
+__name(getBuiltInRoleActions, "getBuiltInRoleActions");
+
+// src/schema/define-query.ts
+function defineQuery(name, config) {
+  if (!config.fetch && !config.aggregate && !config.search && !config.similar) {
+    throw new Error("Query must have at least one of: fetch, aggregate, search, or similar");
+  }
+  if (!config.endpoint.startsWith("/api/")) {
+    throw new Error("Query endpoint must start with /api/");
+  }
+  return {
+    _tag: "query",
+    name,
+    endpoint: config.endpoint,
+    description: config.description,
+    fetch: config.fetch,
+    aggregate: config.aggregate,
+    search: config.search,
+    similar: config.similar,
+    include: config.include,
+    filters: config.filters,
+    select: config.select,
+    cache: config.cache
+  };
+}
+__name(defineQuery, "defineQuery");
+
+// src/schema/fields/index.ts
+var fields_exports = {};
+__export(fields_exports, {
+  boolean: () => boolean,
+  component: () => component,
+  date: () => date,
+  dateTime: () => dateTime,
+  decimal: () => decimal,
+  email: () => email,
+  enum: () => enumField,
+  integer: () => integer,
+  list: () => list,
+  longText: () => longText,
+  reference: () => reference,
+  richText: () => richText,
+  shortText: () => shortText,
+  slug: () => slug,
+  tags: () => tags,
+  url: () => url
+});
+
+// src/schema/fields/builders.ts
+function createField(id, type, options = {}) {
+  return {
+    id,
+    type,
+    ...options.config !== void 0 && { config: options.config },
+    ...options.ui !== void 0 && { ui: options.ui },
+    ...options.ai !== void 0 && { ai: options.ai },
+    ...options.rules !== void 0 && options.rules.length > 0 && { rules: options.rules },
+    ...options.localization !== void 0 && { localization: options.localization },
+    ...options.fallback !== void 0 && { fallback: options.fallback },
+    ...options.deprecated !== void 0 && { deprecated: options.deprecated }
+  };
+}
+__name(createField, "createField");
+function shortText(id, options = {}) {
+  return createField(id, "shortText", options);
+}
+__name(shortText, "shortText");
+function longText(id, options = {}) {
+  return createField(id, "longText", options);
+}
+__name(longText, "longText");
+function richText(id, options = {}) {
+  return createField(id, "richText", options);
+}
+__name(richText, "richText");
+function slug(id, options = {}) {
+  return createField(id, "slug", options);
+}
+__name(slug, "slug");
+function url(id, options = {}) {
+  return createField(id, "url", options);
+}
+__name(url, "url");
+function email(id, options = {}) {
+  return createField(id, "email", options);
+}
+__name(email, "email");
+function integer(id, options = {}) {
+  return createField(id, "integer", options);
+}
+__name(integer, "integer");
+function decimal(id, options = {}) {
+  return createField(id, "decimal", options);
+}
+__name(decimal, "decimal");
+function boolean(id, options = {}) {
+  return createField(id, "boolean", options);
+}
+__name(boolean, "boolean");
+function enumField(id, options = {}) {
+  return createField(id, "enum", options);
+}
+__name(enumField, "enumField");
+function date(id, options = {}) {
+  return createField(id, "date", options);
+}
+__name(date, "date");
+function dateTime(id, options = {}) {
+  return createField(id, "dateTime", options);
+}
+__name(dateTime, "dateTime");
+function reference(id, options = {}) {
+  return createField(id, "reference", options);
+}
+__name(reference, "reference");
+function tags(id, options = {}) {
+  return createField(id, "tags", options);
+}
+__name(tags, "tags");
+function list(id, options = {}) {
+  return createField(id, "list", options);
+}
+__name(list, "list");
+function component(id, componentId, options = {}) {
+  const type = `component(${componentId})`;
+  return createField(id, type, options);
+}
+__name(component, "component");
+
+// src/schema/index.ts
+var fields = fields_exports;
+
+export { BUILT_IN_ROLES, BUILT_IN_ROLE_ACTIONS, ROLE_ACTIONS, buildFallbackChain, defineAssetType, defineComponent, defineContentType, defineContentTypeWorkflow, defineLocale, defineQuery, defineRole, defineSchema, defineSettingsGroup, defineSingleton, defineSingletonContentType, defineView, defineWorkflow, defineWorkflowStage, fields, fieldset, findDefaultLocale, findWorkflowStage, getActiveLocales, getBuiltInRoleActions, getFirstWorkflowStage, getLocaleCodes, getNextWorkflowStage, getWorkflowStageIds, isBuiltInRole, isFinalWorkflowStage, isLocaleDefinition, isRoleDefinition, isWorkflowDefinition, isWorkflowStageDefinition, schemaToJSON, viewToJSON, workflowToJSON };
+//# sourceMappingURL=chunk-2QUK2ZGD.js.map
+//# sourceMappingURL=chunk-2QUK2ZGD.js.map