@proteos/sdk 0.18.1

package/dist/chunk-7RGN4E22.cjs

@@ -0,0 +1,1185 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/iterator.ts
+var DONE = /* @__PURE__ */ Symbol("DONE");
+var DEFAULT_PAGE_SIZE = 100;
+var PageIterator = class {
+  listFn;
+  options;
+  // Pages are 0-indexed across all Proteos services. First fetch is page 0,
+  // last is pagesTotal - 1.
+  page = 0;
+  buffer = [];
+  bufferIndex = 0;
+  pagesTotal;
+  /**
+   * Creates a new PageIterator.
+   *
+   * @param listFn - Function to fetch a page of results
+   * @param options - Options for list requests (including pagination)
+   */
+  constructor(listFn, options) {
+    this.listFn = listFn;
+    this.options = { ...options };
+    if (!this.options.page_size) {
+      this.options.page_size = DEFAULT_PAGE_SIZE;
+    }
+  }
+  /**
+   * Returns the next item in the iterator.
+   * Returns DONE symbol when iteration is complete.
+   *
+   * @returns The next item or DONE
+   *
+   * @example
+   * ```ts
+   * const item = await iterator.next();
+   * if (item !== DONE) {
+   *   console.log(item);
+   * }
+   * ```
+   */
+  async next() {
+    if (this.bufferIndex < this.buffer.length) {
+      const item = this.buffer[this.bufferIndex];
+      this.bufferIndex++;
+      return item;
+    }
+    if (this.pagesTotal !== void 0 && this.page >= this.pagesTotal) {
+      return DONE;
+    }
+    const result = await this.listFn({
+      ...this.options,
+      page: this.page
+    });
+    this.pagesTotal = result.meta.pages_total;
+    if (result.data.length === 0) {
+      return DONE;
+    }
+    this.buffer = result.data;
+    this.bufferIndex = 1;
+    this.page++;
+    return this.buffer[0];
+  }
+  /**
+   * Collects all remaining items into an array.
+   * Useful when you need all items at once.
+   *
+   * @returns Array of all remaining items
+   *
+   * @example
+   * ```ts
+   * const allEntities = await iterator.all();
+   * console.log(`Found ${allEntities.length} entities`);
+   * ```
+   */
+  async all() {
+    const items = [];
+    while (true) {
+      const item = await this.next();
+      if (item === DONE) {
+        break;
+      }
+      items.push(item);
+    }
+    return items;
+  }
+  /**
+   * Implements AsyncIterable for use with for-await-of loops.
+   *
+   * @example
+   * ```ts
+   * for await (const entity of iterator) {
+   *   console.log(entity.name);
+   * }
+   * ```
+   */
+  async *[Symbol.asyncIterator]() {
+    while (true) {
+      const item = await this.next();
+      if (item === DONE) {
+        return;
+      }
+      yield item;
+    }
+  }
+};
+function createIterator(listFn, options) {
+  return new PageIterator(listFn, options);
+}
+
+// src/meta/apps.ts
+var APPS_BASE_PATH = "/meta/v1/apps";
+var AppServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", APPS_BASE_PATH, options);
+  }
+  async get(slug) {
+    return this.client.request("GET", `${APPS_BASE_PATH}/${slug}`);
+  }
+  async create(request) {
+    return this.client.request("POST", APPS_BASE_PATH, request);
+  }
+  async upsert(slug, request) {
+    return this.client.request("PUT", `${APPS_BASE_PATH}/${slug}`, { ...request, slug });
+  }
+  async update(slug, request) {
+    return this.client.request("PATCH", `${APPS_BASE_PATH}/${slug}`, request);
+  }
+  async delete(slug) {
+    await this.client.request("DELETE", `${APPS_BASE_PATH}/${slug}`);
+  }
+};
+
+// src/meta/components.ts
+var COMPONENTS_BASE_PATH = "/meta/v1/components";
+var ComponentServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", COMPONENTS_BASE_PATH, options);
+  }
+  async get(id) {
+    return this.client.request("GET", `${COMPONENTS_BASE_PATH}/${id}`);
+  }
+  async create(request) {
+    return this.client.request("POST", COMPONENTS_BASE_PATH, request);
+  }
+  async upsert(request) {
+    return this.client.request("POST", `${COMPONENTS_BASE_PATH}/upsert`, request);
+  }
+  async update(id, request) {
+    return this.client.request("PATCH", `${COMPONENTS_BASE_PATH}/${id}`, request);
+  }
+  async delete(id) {
+    await this.client.request("DELETE", `${COMPONENTS_BASE_PATH}/${id}`);
+  }
+  bundleUrl(slug) {
+    return `${COMPONENTS_BASE_PATH}/${slug}/bundle`;
+  }
+};
+
+// src/meta/entities.ts
+var ENTITIES_BASE_PATH = "/meta/v1/entities";
+var EntityServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", ENTITIES_BASE_PATH, options);
+  }
+  listWithSchema(options = {}) {
+    return new PageIterator((opts) => this.listPageWithSchema(opts), options);
+  }
+  async listPageWithSchema(options = {}) {
+    return this.client.requestWithQuery("GET", ENTITIES_BASE_PATH, {
+      ...options,
+      with_schema: true
+    });
+  }
+  async get(slug) {
+    return this.client.request("GET", `${ENTITIES_BASE_PATH}/${slug}`);
+  }
+  async getWithSchema(slug) {
+    return this.client.requestWithQuery("GET", `${ENTITIES_BASE_PATH}/${slug}`, {
+      with_schema: true
+    });
+  }
+  async create(request) {
+    return this.client.request("POST", ENTITIES_BASE_PATH, request);
+  }
+  async upsert(slug, request) {
+    return this.client.request("PUT", `${ENTITIES_BASE_PATH}/${slug}`, { ...request, slug });
+  }
+  async update(slug, request) {
+    return this.client.request("PATCH", `${ENTITIES_BASE_PATH}/${slug}`, request);
+  }
+  async delete(slug) {
+    await this.client.request("DELETE", `${ENTITIES_BASE_PATH}/${slug}`);
+  }
+};
+
+// src/meta/list-views.ts
+var LIST_VIEWS_BASE_PATH = "/meta/v1/list-views";
+var ListViewServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", LIST_VIEWS_BASE_PATH, options);
+  }
+  async get(slug) {
+    return this.client.request("GET", `${LIST_VIEWS_BASE_PATH}/${slug}`);
+  }
+  async create(request) {
+    return this.client.request("POST", LIST_VIEWS_BASE_PATH, request);
+  }
+  async upsert(request) {
+    return this.client.request("POST", `${LIST_VIEWS_BASE_PATH}/upsert`, request);
+  }
+  async update(slug, request) {
+    return this.client.request("PATCH", `${LIST_VIEWS_BASE_PATH}/${slug}`, request);
+  }
+  async delete(slug) {
+    await this.client.request("DELETE", `${LIST_VIEWS_BASE_PATH}/${slug}`);
+  }
+};
+
+// src/meta/lists.ts
+var LISTS_BASE_PATH = "/meta/v1/lists";
+var ListServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", LISTS_BASE_PATH, options);
+  }
+  async get(slug) {
+    return this.client.request("GET", `${LISTS_BASE_PATH}/${slug}`);
+  }
+  async create(request) {
+    return this.client.request("POST", LISTS_BASE_PATH, request);
+  }
+  async upsert(request) {
+    return this.client.request("POST", `${LISTS_BASE_PATH}/upsert`, request);
+  }
+  async update(slug, request) {
+    return this.client.request("PATCH", `${LISTS_BASE_PATH}/${slug}`, request);
+  }
+  async delete(slug) {
+    await this.client.request("DELETE", `${LISTS_BASE_PATH}/${slug}`);
+  }
+};
+
+// src/meta/menu-configurations.ts
+var MENU_CONFIGURATIONS_BASE_PATH = "/meta/v1/menu-configurations";
+var MenuConfigurationServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery(
+      "GET",
+      MENU_CONFIGURATIONS_BASE_PATH,
+      options
+    );
+  }
+  async get(slug) {
+    return this.client.request("GET", `${MENU_CONFIGURATIONS_BASE_PATH}/${slug}`);
+  }
+  async create(request) {
+    return this.client.request("POST", MENU_CONFIGURATIONS_BASE_PATH, request);
+  }
+  async upsert(slug, request) {
+    return this.client.request(
+      "PUT",
+      `${MENU_CONFIGURATIONS_BASE_PATH}/${slug}`,
+      { ...request, slug }
+    );
+  }
+  async update(slug, request) {
+    return this.client.request(
+      "PATCH",
+      `${MENU_CONFIGURATIONS_BASE_PATH}/${slug}`,
+      request
+    );
+  }
+  async delete(slug) {
+    await this.client.request("DELETE", `${MENU_CONFIGURATIONS_BASE_PATH}/${slug}`);
+  }
+};
+
+// src/meta/modules.ts
+var MODULES_BASE_PATH = "/meta/v1/modules";
+var ModuleServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", MODULES_BASE_PATH, options);
+  }
+  async get(slug) {
+    return this.client.request("GET", `${MODULES_BASE_PATH}/${slug}`);
+  }
+  async deploy(request, file) {
+    const formData = new FormData();
+    formData.append("metadata", JSON.stringify(request));
+    let blob;
+    if (file instanceof ArrayBuffer) {
+      blob = new Blob([file], { type: "application/wasm" });
+    } else {
+      blob = file;
+    }
+    formData.append("file", blob, "module.wasm");
+    return this.client.requestMultipart("POST", `${MODULES_BASE_PATH}/deploy`, formData);
+  }
+  async delete(slug) {
+    await this.client.request("DELETE", `${MODULES_BASE_PATH}/${slug}`);
+  }
+  async activate(slug) {
+    await this.client.request("PATCH", `${MODULES_BASE_PATH}/${slug}/activate`);
+  }
+  async deactivate(slug) {
+    await this.client.request("PATCH", `${MODULES_BASE_PATH}/${slug}/deactivate`);
+  }
+  async download(slug) {
+    const [{ body }, module] = await Promise.all([
+      this.client.requestRaw("GET", `${MODULES_BASE_PATH}/${slug}/download`),
+      this.get(slug)
+    ]);
+    return { body, module };
+  }
+};
+
+// src/meta/pages.ts
+var PAGES_BASE_PATH = "/meta/v1/pages";
+var PageServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", PAGES_BASE_PATH, options);
+  }
+  async get(slug) {
+    return this.client.request("GET", `${PAGES_BASE_PATH}/${slug}`);
+  }
+  async create(request) {
+    return this.client.request("POST", PAGES_BASE_PATH, request);
+  }
+  async upsert(slug, request) {
+    return this.client.request("PUT", `${PAGES_BASE_PATH}/${slug}`, { ...request, slug });
+  }
+  async update(slug, request) {
+    return this.client.request("PATCH", `${PAGES_BASE_PATH}/${slug}`, request);
+  }
+  async delete(slug) {
+    await this.client.request("DELETE", `${PAGES_BASE_PATH}/${slug}`);
+  }
+};
+
+// src/meta/variables.ts
+var VARIABLES_BASE_PATH = "/meta/v1/variables";
+var VariableServiceImpl = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(options = {}) {
+    return new PageIterator((opts) => this.listPage(opts), options);
+  }
+  async listPage(options = {}) {
+    return this.client.requestWithQuery("GET", VARIABLES_BASE_PATH, options);
+  }
+  async get(id) {
+    return this.client.request("GET", `${VARIABLES_BASE_PATH}/${id}`);
+  }
+  async create(request) {
+    return this.client.request("POST", VARIABLES_BASE_PATH, request);
+  }
+  async update(id, request) {
+    return this.client.request("PATCH", `${VARIABLES_BASE_PATH}/${id}`, request);
+  }
+  async delete(id) {
+    await this.client.request("DELETE", `${VARIABLES_BASE_PATH}/${id}`);
+  }
+};
+
+// src/meta/currency/index.ts
+var cachedCodes = null;
+function allCurrencyCodes() {
+  if (cachedCodes) return cachedCodes;
+  const supported = typeof Intl !== "undefined" && "supportedValuesOf" in Intl ? Intl.supportedValuesOf(
+    "currency"
+  ) : [];
+  cachedCodes = [...supported].sort();
+  return cachedCodes;
+}
+function currencyLabel(code, locale) {
+  try {
+    const names = new Intl.DisplayNames(locale ? [locale] : void 0, { type: "currency" });
+    return names.of(code) ?? code;
+  } catch {
+    return code;
+  }
+}
+function currencySymbol(code, locale) {
+  try {
+    const parts = new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: code,
+      currencyDisplay: "narrowSymbol"
+    }).formatToParts(0);
+    return parts.find((part) => part.type === "currency")?.value ?? code;
+  } catch {
+    return code;
+  }
+}
+var SUFFIX_SYMBOL_CURRENCIES = /* @__PURE__ */ new Set([
+  "EUR",
+  "PLN",
+  "CZK",
+  "HUF",
+  "RON",
+  "BGN",
+  "HRK",
+  "SEK",
+  "NOK",
+  "DKK",
+  "ISK",
+  "RSD",
+  "RUB",
+  "UAH",
+  "GEL",
+  "MKD",
+  "ALL",
+  "AMD",
+  "AZN",
+  "VND"
+]);
+function currencySymbolSide(code) {
+  return SUFFIX_SYMBOL_CURRENCIES.has(code) ? "suffix" : "prefix";
+}
+var separatorCache = /* @__PURE__ */ new Map();
+function localeNumberSeparators(locale) {
+  const key = locale ?? "__default__";
+  const cached = separatorCache.get(key);
+  if (cached) return cached;
+  let group = ",";
+  let decimal = ".";
+  try {
+    const parts = new Intl.NumberFormat(locale).formatToParts(11111.1);
+    group = parts.find((part) => part.type === "group")?.value ?? group;
+    decimal = parts.find((part) => part.type === "decimal")?.value ?? decimal;
+  } catch {
+  }
+  const result = { group, decimal };
+  separatorCache.set(key, result);
+  return result;
+}
+var DECIMAL_RE = /^-?\d+(\.\d+)?$/;
+function groupDigits(intDigits, groupSeparator) {
+  return intDigits.replace(/\B(?=(\d{3})+(?!\d))/g, groupSeparator);
+}
+function formatAmount(canonical, locale, options) {
+  if (canonical === "") return "";
+  if (!DECIMAL_RE.test(canonical)) return canonical;
+  const grouped = options?.grouped !== false;
+  const { group, decimal } = localeNumberSeparators(locale);
+  const negative = canonical.startsWith("-");
+  const body = negative ? canonical.slice(1) : canonical;
+  const dotIndex = body.indexOf(".");
+  const intPart = dotIndex === -1 ? body : body.slice(0, dotIndex);
+  const fracPart = dotIndex === -1 ? void 0 : body.slice(dotIndex + 1);
+  const intOut = grouped ? groupDigits(intPart, group) : intPart;
+  const out = fracPart !== void 0 ? `${intOut}${decimal}${fracPart}` : intOut;
+  return negative ? `-${out}` : out;
+}
+function parseAmount(input, locale) {
+  const trimmed = input.trim();
+  if (trimmed === "") return "";
+  const { group, decimal } = localeNumberSeparators(locale);
+  const negative = trimmed.startsWith("-");
+  let normalized = trimmed.split(group).join("");
+  normalized = normalized.split(decimal).join(".");
+  normalized = normalized.replace(/[^\d.]/g, "");
+  const firstDot = normalized.indexOf(".");
+  if (firstDot !== -1) {
+    normalized = normalized.slice(0, firstDot + 1) + normalized.slice(firstDot + 1).replace(/\./g, "");
+  }
+  if (normalized === "" || normalized === ".") return "";
+  return negative ? `-${normalized}` : normalized;
+}
+function formatMoney(value, locale) {
+  const { amount, currency_code: code } = value;
+  if (!amount || !code) return [amount, code].filter(Boolean).join(" ");
+  if (!DECIMAL_RE.test(amount)) return `${amount} ${code}`;
+  const number = formatAmount(amount, locale, { grouped: true });
+  const symbol = currencySymbol(code, locale);
+  return currencySymbolSide(code) === "suffix" ? `${number} ${symbol}` : `${symbol}${number}`;
+}
+
+// src/meta/layout/control-registry.json
+var control_registry_default = {
+  builtInControls: [
+    "text",
+    "textarea",
+    "email",
+    "url",
+    "password",
+    "number",
+    "switch",
+    "checkbox",
+    "select",
+    "radio-group",
+    "chip-group",
+    "multi-select",
+    "date-picker",
+    "datetime-picker",
+    "time-picker",
+    "tag-input",
+    "entity-picker",
+    "user-picker",
+    "currency",
+    "knowledge-text",
+    "file"
+  ],
+  controls: {
+    string: {
+      primary: "text",
+      compatible: ["text", "textarea", "password"],
+      byFormat: {
+        email: { primary: "email", compatible: ["email", "text"] },
+        uri: { primary: "url", compatible: ["url", "text"] },
+        uuid: { primary: "text", compatible: ["text"] },
+        hostname: { primary: "text", compatible: ["text"] },
+        ipv4: { primary: "text", compatible: ["text"] },
+        ipv6: { primary: "text", compatible: ["text"] }
+      }
+    },
+    number: { primary: "number", compatible: ["number"] },
+    integer: { primary: "number", compatible: ["number"] },
+    boolean: { primary: "switch", compatible: ["switch", "checkbox"] },
+    enum: { primary: "select", compatible: ["select", "radio-group", "chip-group"] },
+    array: {
+      primary: "tag-input",
+      compatible: ["tag-input"],
+      byItemsType: {
+        string: { primary: "tag-input", compatible: ["tag-input"] },
+        enum: { primary: "multi-select", compatible: ["multi-select"] }
+      }
+    },
+    datetime: {
+      primary: null,
+      compatible: [],
+      byFormat: {
+        date: { primary: "date-picker", compatible: ["date-picker"] },
+        "date-time": { primary: "datetime-picker", compatible: ["datetime-picker"] },
+        time: { primary: "time-picker", compatible: ["time-picker"] },
+        duration: { primary: null, compatible: [] }
+      }
+    },
+    object: { primary: null, compatible: [] },
+    relation: { primary: "entity-picker", compatible: ["entity-picker"] },
+    user: { primary: "user-picker", compatible: ["user-picker"] },
+    currency: { primary: "currency", compatible: ["currency"] },
+    "knowledge-text": { primary: "knowledge-text", compatible: ["knowledge-text"] },
+    file: { primary: "file", compatible: ["file"] }
+  }
+};
+
+// src/meta/layout/control-registry.ts
+var BUILT_IN_CONTROLS = control_registry_default.builtInControls;
+var CONTROLS = control_registry_default.controls;
+function isBuiltInControl(slug) {
+  return BUILT_IN_CONTROLS.includes(slug);
+}
+function lookupControls(attr) {
+  const typeBucket = CONTROLS[attr.type];
+  if (!typeBucket) return EMPTY;
+  const meta = attr.meta ?? void 0;
+  const format = meta?.format;
+  if (format && typeBucket.byFormat?.[format]) {
+    return typeBucket.byFormat[format];
+  }
+  const itemsType = meta?.items?.type;
+  if (itemsType && typeBucket.byItemsType?.[itemsType]) {
+    return typeBucket.byItemsType[itemsType];
+  }
+  return typeBucket;
+}
+function lookupPrimaryControl(attr) {
+  return lookupControls(attr).primary;
+}
+function lookupCompatibleControls(attr) {
+  return lookupControls(attr).compatible;
+}
+var EMPTY = { primary: null, compatible: [] };
+var FilterElementSchema = zod.z.object({
+  field: zod.z.string(),
+  value: zod.z.string(),
+  operator: zod.z.enum([
+    "eq",
+    "gt",
+    "lt",
+    "gte",
+    "lte",
+    "ne",
+    "in",
+    "not_in",
+    "contains",
+    "starts_with",
+    "ends_with",
+    "empty",
+    "not_empty"
+  ])
+});
+var FilterGroupSchema = zod.z.lazy(
+  () => zod.z.object({
+    logical_operator: zod.z.enum(["and", "or"]),
+    elements: zod.z.array(FilterElementSchema).optional(),
+    groups: zod.z.array(FilterGroupSchema).optional()
+  })
+);
+var SIZE_VALUE_STRING_RE = /^(\d+\/\d+|\d+px|\d+%|auto|fill)$/;
+var SizeValueSchema = zod.z.union([
+  zod.z.number().min(0).max(1).describe("Fraction in [0, 1]"),
+  zod.z.string().regex(SIZE_VALUE_STRING_RE, 'must match n/m, Npx, N%, "auto", or "fill"')
+]);
+
+// src/meta/layout/common-props.ts
+var AlignSchema = zod.z.enum(["start", "center", "end", "stretch"]);
+var JustifySchema = zod.z.enum(["start", "center", "end", "between", "around"]);
+var GapSchema = zod.z.enum(["xs", "sm", "md", "lg"]);
+var SizingPropsSchema = zod.z.object({
+  width: SizeValueSchema.optional(),
+  height: SizeValueSchema.optional(),
+  grow: zod.z.number().optional(),
+  shrink: zod.z.number().optional(),
+  align: AlignSchema.optional()
+});
+var ResponsiveSizingSchema = zod.z.object({
+  sm: SizingPropsSchema.optional(),
+  md: SizingPropsSchema.optional(),
+  lg: SizingPropsSchema.optional()
+});
+var commonPropsShape = {
+  id: zod.z.string().optional(),
+  visible_when: FilterGroupSchema.optional(),
+  read_only_when: FilterGroupSchema.optional(),
+  width: SizeValueSchema.optional(),
+  height: SizeValueSchema.optional(),
+  grow: zod.z.number().optional(),
+  shrink: zod.z.number().optional(),
+  align: AlignSchema.optional(),
+  responsive: ResponsiveSizingSchema.optional()
+};
+var layoutAlignShape = AlignSchema;
+var layoutJustifyShape = JustifySchema;
+var layoutGapShape = GapSchema;
+
+// src/meta/layout/elements.ts
+var LayoutElementType = {
+  Row: "row",
+  Column: "column",
+  Section: "section",
+  Tabs: "tabs",
+  Field: "field",
+  RelatedList: "related_list",
+  Component: "component",
+  Divider: "divider",
+  Text: "text"
+};
+var LayoutElementSchema = zod.z.lazy(
+  () => zod.z.discriminatedUnion("type", [
+    zod.z.object({
+      type: zod.z.literal("row"),
+      ...commonPropsShape,
+      gap: layoutGapShape.optional(),
+      allows_wrap: zod.z.boolean().optional(),
+      align: layoutAlignShape.optional(),
+      justify: layoutJustifyShape.optional(),
+      children: zod.z.array(LayoutElementSchema)
+    }),
+    zod.z.object({
+      type: zod.z.literal("column"),
+      ...commonPropsShape,
+      gap: layoutGapShape.optional(),
+      align: layoutAlignShape.optional(),
+      justify: layoutJustifyShape.optional(),
+      children: zod.z.array(LayoutElementSchema)
+    }),
+    zod.z.object({
+      type: zod.z.literal("section"),
+      ...commonPropsShape,
+      title: zod.z.string().optional(),
+      description: zod.z.string().optional(),
+      is_collapsible: zod.z.boolean().optional(),
+      default_collapsed: zod.z.boolean().optional(),
+      content: LayoutElementSchema
+    }),
+    zod.z.object({
+      type: zod.z.literal("tabs"),
+      ...commonPropsShape,
+      tabs: zod.z.array(
+        zod.z.object({
+          id: zod.z.string().min(1),
+          label: zod.z.string().min(1),
+          icon: zod.z.string().optional(),
+          visible_when: FilterGroupSchema.optional(),
+          content: LayoutElementSchema
+        })
+      ),
+      default_tab_id: zod.z.string().optional()
+    }),
+    zod.z.object({
+      type: zod.z.literal("field"),
+      ...commonPropsShape,
+      attribute: zod.z.string().min(1),
+      label: zod.z.string().nullable().optional(),
+      description: zod.z.string().optional(),
+      placeholder: zod.z.string().optional(),
+      is_read_only: zod.z.boolean().optional(),
+      is_required: zod.z.boolean().optional(),
+      empty_display: zod.z.string().optional(),
+      control: zod.z.string().optional(),
+      control_props: zod.z.record(zod.z.unknown()).optional()
+    }),
+    zod.z.object({
+      type: zod.z.literal("related_list"),
+      ...commonPropsShape,
+      related_entity_slug: zod.z.string().min(1),
+      via_attribute: zod.z.string().min(1),
+      list_slug: zod.z.string().min(1).optional()
+    }),
+    zod.z.object({
+      type: zod.z.literal("component"),
+      ...commonPropsShape,
+      component_slug: zod.z.string().min(1),
+      props: zod.z.record(zod.z.unknown()).optional()
+    }),
+    zod.z.object({
+      type: zod.z.literal("divider"),
+      ...commonPropsShape
+    }),
+    zod.z.object({
+      type: zod.z.literal("text"),
+      ...commonPropsShape,
+      variant: zod.z.enum(["heading", "subheading", "body", "caption", "callout"]),
+      content: zod.z.string().min(1)
+    })
+  ])
+);
+var PageLayoutSidePanelSchema = zod.z.object({
+  width: SizeValueSchema.optional(),
+  is_sticky: zod.z.boolean().optional(),
+  content: LayoutElementSchema
+});
+var PageLayoutSchema = zod.z.object({
+  version: zod.z.literal(1),
+  main: LayoutElementSchema,
+  side_panel: PageLayoutSidePanelSchema.optional()
+});
+var ResponseMetaSchema = zod.z.object({
+  page: zod.z.number(),
+  page_size: zod.z.number(),
+  items_total: zod.z.number(),
+  pages_total: zod.z.number()
+});
+function createListResultSchema(itemSchema) {
+  return zod.z.object({
+    meta: ResponseMetaSchema,
+    data: zod.z.array(itemSchema)
+  });
+}
+var UserRefSchema = zod.z.object({
+  type: zod.z.enum(["person", "agent", "api"]),
+  id: zod.z.string()
+});
+var PLATFORM_USER_ID = "platform";
+var FileRefSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string()
+});
+var AuditFieldsSchema = zod.z.object({
+  created_at: zod.z.string(),
+  updated_at: zod.z.string(),
+  created_by: UserRefSchema,
+  updated_by: UserRefSchema
+});
+
+// src/meta/types.ts
+var OnDeleteActionSchema = zod.z.enum(["cascade", "restrict", "set-null"]);
+var RelationAttributeMetaSchema = zod.z.object({
+  related_entity_slug: zod.z.string(),
+  related_attribute: zod.z.string(),
+  predicate: zod.z.string(),
+  description: zod.z.string().optional(),
+  on_delete: OnDeleteActionSchema
+});
+var UserAttributeMetaSchema = zod.z.object({
+  description: zod.z.string().optional()
+});
+var CurrencyAttributeMetaSchema = zod.z.object({
+  default_currency_code: zod.z.string().optional(),
+  allowed_currency_codes: zod.z.array(zod.z.string()).optional()
+});
+zod.z.object({
+  description: zod.z.string().optional()
+});
+var FileAttributeMetaSchema = zod.z.object({
+  description: zod.z.string().optional()
+});
+var PLATFORM_ATTRIBUTE_NAMES = [
+  "id",
+  "created_at",
+  "updated_at",
+  "created_by",
+  "updated_by"
+];
+function isPlatformAttributeName(name) {
+  return PLATFORM_ATTRIBUTE_NAMES.includes(name);
+}
+function platformAttributes() {
+  return [
+    {
+      name: "id",
+      type: "string",
+      label: "Id",
+      description: "Unique identifier of the record.",
+      is_required: false,
+      is_unique: true,
+      is_read_only: true,
+      is_platform_managed: true
+    },
+    {
+      name: "created_at",
+      type: "datetime",
+      label: "Created At",
+      description: "Timestamp when the record was created.",
+      is_required: false,
+      is_unique: false,
+      is_read_only: true,
+      is_platform_managed: true,
+      meta: { format: "date-time" }
+    },
+    {
+      name: "updated_at",
+      type: "datetime",
+      label: "Updated At",
+      description: "Timestamp when the record was last updated.",
+      is_required: false,
+      is_unique: false,
+      is_read_only: true,
+      is_platform_managed: true,
+      meta: { format: "date-time" }
+    },
+    {
+      name: "created_by",
+      type: "user",
+      label: "Created By",
+      description: 'User who created the record ("platform" for system writes).',
+      is_required: false,
+      is_unique: false,
+      is_read_only: true,
+      is_platform_managed: true
+    },
+    {
+      name: "updated_by",
+      type: "user",
+      label: "Updated By",
+      description: 'User who last updated the record ("platform" for system writes).',
+      is_required: false,
+      is_unique: false,
+      is_read_only: true,
+      is_platform_managed: true
+    }
+  ];
+}
+var AttributeSchema = zod.z.object({
+  name: zod.z.string(),
+  type: zod.z.string(),
+  label: zod.z.string(),
+  description: zod.z.string().optional(),
+  is_required: zod.z.boolean(),
+  is_nullable: zod.z.boolean().optional(),
+  is_unique: zod.z.boolean(),
+  is_read_only: zod.z.boolean().optional(),
+  default_value: zod.z.unknown().optional(),
+  meta: zod.z.unknown().optional(),
+  options: zod.z.record(zod.z.unknown()).optional()
+});
+function parseRelationMeta(attr) {
+  if (attr.type !== "relation") return null;
+  const parsed = RelationAttributeMetaSchema.safeParse(attr.meta);
+  return parsed.success ? parsed.data : null;
+}
+function parseCurrencyMeta(attr) {
+  if (attr.type !== "currency") return null;
+  const parsed = CurrencyAttributeMetaSchema.safeParse(attr.meta ?? {});
+  return parsed.success ? parsed.data : null;
+}
+function parseUserMeta(attr) {
+  if (attr.type !== "user") return null;
+  if (attr.meta == null) return {};
+  const parsed = UserAttributeMetaSchema.safeParse(attr.meta);
+  return parsed.success ? parsed.data : {};
+}
+function parseFileMeta(attr) {
+  if (attr.type !== "file") return null;
+  if (attr.meta == null) return {};
+  const parsed = FileAttributeMetaSchema.safeParse(attr.meta);
+  return parsed.success ? parsed.data : {};
+}
+var EntitySchema = AuditFieldsSchema.extend({
+  slug: zod.z.string(),
+  name: zod.z.string(),
+  description: zod.z.string(),
+  is_remote: zod.z.boolean(),
+  module_slug: zod.z.string(),
+  // Default keeps older API responses (pre-`title_template` rollout) parsing
+  // cleanly — the field is non-optional in the TS surface but tolerant on
+  // the wire.
+  title_template: zod.z.string().default(""),
+  attributes: zod.z.array(AttributeSchema)
+});
+var EntityWithSchemaSchema = EntitySchema.extend({
+  schema: zod.z.record(zod.z.unknown())
+});
+var ModuleSchema = AuditFieldsSchema.extend({
+  slug: zod.z.string(),
+  name: zod.z.string(),
+  description: zod.z.string(),
+  version: zod.z.string(),
+  file_id: zod.z.string(),
+  status: zod.z.enum(["pending", "deploying", "active", "failed", "deactivating", "inactive"]),
+  status_details: zod.z.string(),
+  is_deactivated: zod.z.boolean()
+});
+var VariableSchema = AuditFieldsSchema.extend({
+  id: zod.z.string(),
+  key: zod.z.string(),
+  value: zod.z.string(),
+  is_secret: zod.z.boolean(),
+  module: zod.z.string()
+});
+var ComponentSchema = AuditFieldsSchema.extend({
+  slug: zod.z.string(),
+  name: zod.z.string(),
+  description: zod.z.string(),
+  module_slug: zod.z.string(),
+  bundle_file_id: zod.z.string(),
+  source_file_id: zod.z.string(),
+  props_schema: zod.z.record(zod.z.unknown()).nullable()
+});
+var ColumnSchema = zod.z.object({
+  attribute: zod.z.string(),
+  label: zod.z.string(),
+  width: zod.z.number()
+});
+var SortConfigSchema = zod.z.object({
+  attribute: zod.z.string(),
+  direction: zod.z.enum(["asc", "desc"])
+});
+var ListSchema = AuditFieldsSchema.extend({
+  slug: zod.z.string(),
+  module_slug: zod.z.string(),
+  name: zod.z.string(),
+  entity_slug: zod.z.string(),
+  columns: zod.z.array(ColumnSchema),
+  sorting: zod.z.array(SortConfigSchema),
+  filters: zod.z.array(FilterGroupSchema)
+});
+var ListViewSchema = AuditFieldsSchema.extend({
+  slug: zod.z.string(),
+  module_slug: zod.z.string(),
+  list_slug: zod.z.string(),
+  name: zod.z.string(),
+  columns: zod.z.array(ColumnSchema),
+  sorting: zod.z.array(SortConfigSchema),
+  filters: zod.z.array(FilterGroupSchema)
+});
+var PageActionSchema = zod.z.object({
+  label: zod.z.string(),
+  icon: zod.z.string(),
+  action: zod.z.string()
+});
+var PageTypeSchema = zod.z.enum(["record", "platform"]);
+var PageSchema = AuditFieldsSchema.extend({
+  slug: zod.z.string(),
+  name: zod.z.string(),
+  module_slug: zod.z.string(),
+  type: PageTypeSchema,
+  entity_slug: zod.z.string().optional(),
+  actions: zod.z.array(PageActionSchema),
+  layout: PageLayoutSchema
+});
+var MenuItemType = {
+  Link: "link",
+  Group: "group",
+  Entity: "entity",
+  Page: "page",
+  List: "list"
+};
+var MenuItemSchema = zod.z.lazy(
+  () => zod.z.object({
+    id: zod.z.string(),
+    order: zod.z.number(),
+    label: zod.z.string(),
+    type: zod.z.enum(["link", "group", "entity", "page", "list"]),
+    icon: zod.z.string(),
+    reference: zod.z.string().optional(),
+    children: zod.z.array(MenuItemSchema).nullable()
+  })
+);
+var MenuConfigurationSchema = AuditFieldsSchema.extend({
+  slug: zod.z.string(),
+  name: zod.z.string(),
+  module_slug: zod.z.string(),
+  app_slug: zod.z.string(),
+  items: zod.z.array(MenuItemSchema),
+  is_default: zod.z.boolean()
+});
+var AppSchema = AuditFieldsSchema.extend({
+  slug: zod.z.string(),
+  org_id: zod.z.string(),
+  module_slug: zod.z.string(),
+  name: zod.z.string(),
+  description: zod.z.string(),
+  icon_slug: zod.z.string()
+});
+
+// src/meta/index.ts
+var MetaClient = class {
+  /**
+   * Service for managing entity definitions.
+   */
+  entities;
+  /**
+   * Service for managing WebAssembly modules.
+   */
+  modules;
+  /**
+   * Service for managing configuration and secret variables.
+   */
+  variables;
+  /**
+   * Service for managing UI component definitions.
+   */
+  components;
+  /**
+   * Service for managing list configurations.
+   */
+  lists;
+  /**
+   * Service for managing list view configurations.
+   */
+  listViews;
+  /**
+   * Service for managing page configurations.
+   */
+  pages;
+  /**
+   * Service for managing menu configurations.
+   */
+  menuConfigurations;
+  /**
+   * Service for managing apps.
+   */
+  apps;
+  /**
+   * Creates a new MetaClient instance.
+   *
+   * @param client - The base ProteosClient to use for API requests
+   */
+  constructor(client) {
+    this.entities = new EntityServiceImpl(client);
+    this.modules = new ModuleServiceImpl(client);
+    this.variables = new VariableServiceImpl(client);
+    this.components = new ComponentServiceImpl(client);
+    this.lists = new ListServiceImpl(client);
+    this.listViews = new ListViewServiceImpl(client);
+    this.pages = new PageServiceImpl(client);
+    this.menuConfigurations = new MenuConfigurationServiceImpl(client);
+    this.apps = new AppServiceImpl(client);
+  }
+};
+
+exports.AppSchema = AppSchema;
+exports.AttributeSchema = AttributeSchema;
+exports.AuditFieldsSchema = AuditFieldsSchema;
+exports.BUILT_IN_CONTROLS = BUILT_IN_CONTROLS;
+exports.ColumnSchema = ColumnSchema;
+exports.ComponentSchema = ComponentSchema;
+exports.CurrencyAttributeMetaSchema = CurrencyAttributeMetaSchema;
+exports.DEFAULT_PAGE_SIZE = DEFAULT_PAGE_SIZE;
+exports.DONE = DONE;
+exports.EntitySchema = EntitySchema;
+exports.EntityWithSchemaSchema = EntityWithSchemaSchema;
+exports.FileAttributeMetaSchema = FileAttributeMetaSchema;
+exports.FileRefSchema = FileRefSchema;
+exports.FilterElementSchema = FilterElementSchema;
+exports.FilterGroupSchema = FilterGroupSchema;
+exports.LayoutElementSchema = LayoutElementSchema;
+exports.LayoutElementType = LayoutElementType;
+exports.ListSchema = ListSchema;
+exports.ListViewSchema = ListViewSchema;
+exports.MenuConfigurationSchema = MenuConfigurationSchema;
+exports.MenuItemSchema = MenuItemSchema;
+exports.MenuItemType = MenuItemType;
+exports.MetaClient = MetaClient;
+exports.ModuleSchema = ModuleSchema;
+exports.OnDeleteActionSchema = OnDeleteActionSchema;
+exports.PLATFORM_ATTRIBUTE_NAMES = PLATFORM_ATTRIBUTE_NAMES;
+exports.PLATFORM_USER_ID = PLATFORM_USER_ID;
+exports.PageActionSchema = PageActionSchema;
+exports.PageIterator = PageIterator;
+exports.PageLayoutSchema = PageLayoutSchema;
+exports.PageLayoutSidePanelSchema = PageLayoutSidePanelSchema;
+exports.PageSchema = PageSchema;
+exports.RelationAttributeMetaSchema = RelationAttributeMetaSchema;
+exports.ResponseMetaSchema = ResponseMetaSchema;
+exports.SizeValueSchema = SizeValueSchema;
+exports.SortConfigSchema = SortConfigSchema;
+exports.UserAttributeMetaSchema = UserAttributeMetaSchema;
+exports.UserRefSchema = UserRefSchema;
+exports.VariableSchema = VariableSchema;
+exports.allCurrencyCodes = allCurrencyCodes;
+exports.createIterator = createIterator;
+exports.createListResultSchema = createListResultSchema;
+exports.currencyLabel = currencyLabel;
+exports.currencySymbol = currencySymbol;
+exports.currencySymbolSide = currencySymbolSide;
+exports.formatAmount = formatAmount;
+exports.formatMoney = formatMoney;
+exports.isBuiltInControl = isBuiltInControl;
+exports.isPlatformAttributeName = isPlatformAttributeName;
+exports.localeNumberSeparators = localeNumberSeparators;
+exports.lookupCompatibleControls = lookupCompatibleControls;
+exports.lookupControls = lookupControls;
+exports.lookupPrimaryControl = lookupPrimaryControl;
+exports.parseAmount = parseAmount;
+exports.parseCurrencyMeta = parseCurrencyMeta;
+exports.parseFileMeta = parseFileMeta;
+exports.parseRelationMeta = parseRelationMeta;
+exports.parseUserMeta = parseUserMeta;
+exports.platformAttributes = platformAttributes;
+//# sourceMappingURL=chunk-7RGN4E22.cjs.map
+//# sourceMappingURL=chunk-7RGN4E22.cjs.map