@stndrds/schema 1.0.0-alpha.293 → 1.0.0-alpha.68

package/dist/chunk-OASIPLEB.js

@@ -1,1504 +0,0 @@
-'use strict';
-
-var chunk5N7OSHVX_js = require('./chunk-5N7OSHVX.js');
-var chunkY3UPKP2B_js = require('./chunk-Y3UPKP2B.js');
-var zod = require('zod');
-
-// src/types/system-attributes.ts
-var SYSTEM_ATTRIBUTE_I18N_KEYS = {
-  createdAt: "createdAt",
-  updatedAt: "updatedAt",
-  createdBy: "createdBy",
-  lastUpdatedBy: "lastUpdatedBy",
-  attachments: "attachments"
-};
-function getSystemAttributeI18nKey(name) {
-  return SYSTEM_ATTRIBUTE_I18N_KEYS[name];
-}
-var SYSTEM_ATTRIBUTES = {
-  createdAt: {
-    id: "system:createdAt",
-    name: "createdAt",
-    label: "Created time",
-    type: "date",
-    required: false,
-    system: true,
-    icon: "clock-circle",
-    description: "When this record was created"
-  },
-  updatedAt: {
-    id: "system:updatedAt",
-    name: "updatedAt",
-    label: "Last edited time",
-    type: "date",
-    required: false,
-    system: true,
-    icon: "clock-circle",
-    description: "When this record was last modified"
-  },
-  createdBy: {
-    id: "system:createdBy",
-    name: "createdBy",
-    label: "Created by",
-    type: "user",
-    required: false,
-    system: true,
-    multiple: false,
-    icon: "user",
-    description: "Actor who created this record"
-  },
-  lastUpdatedBy: {
-    id: "system:lastUpdatedBy",
-    name: "lastUpdatedBy",
-    label: "Last edited by",
-    type: "user",
-    required: false,
-    system: true,
-    multiple: false,
-    icon: "user",
-    description: "Actor who last modified this record"
-  },
-  /**
-   * System attribute for free-form document attachments.
-   * Hidden from forms, visible in Documents tab.
-   * Users can attach any document without template constraints.
-   */
-  attachments: {
-    id: "system:attachments",
-    name: "attachments",
-    label: "Attachments",
-    type: "document",
-    required: false,
-    system: true,
-    hidden: true,
-    // Hidden from regular form views
-    icon: "paperclip",
-    description: "Free-form document attachments"
-  }
-};
-function getSystemAttributeList() {
-  return Object.values(SYSTEM_ATTRIBUTES);
-}
-function isManagedSystemAttribute(attribute) {
-  return attribute.id?.startsWith("system:") ?? false;
-}
-
-// src/types/attribute-capabilities.ts
-var TEXT_OPERATORS = [
-  "is",
-  "is_not",
-  "contains",
-  "not_contains",
-  "starts_with",
-  "ends_with",
-  "is_empty",
-  "is_not_empty"
-];
-var NUMBER_OPERATORS = [
-  "is",
-  "is_not",
-  "less_than",
-  "greater_than",
-  "less_or_equal",
-  "greater_or_equal",
-  "is_empty",
-  "is_not_empty"
-];
-var CHECKBOX_OPERATORS = ["is"];
-var DATE_OPERATORS = [
-  "is",
-  "is_not",
-  "less_than",
-  "greater_than",
-  "less_or_equal",
-  "greater_or_equal",
-  "is_within",
-  "on_day_month",
-  "is_empty",
-  "is_not_empty"
-];
-var SELECT_OPERATORS = [
-  "is",
-  "is_not",
-  "any_of",
-  "none_of",
-  "is_empty",
-  "is_not_empty"
-];
-var MULTISELECT_OPERATORS = [
-  "any_of",
-  "none_of",
-  "is_empty",
-  "is_not_empty"
-];
-var REFERENCE_OPERATORS = [
-  "is",
-  "is_not",
-  "any_of",
-  "none_of",
-  "is_empty",
-  "is_not_empty"
-];
-var PRESENCE_OPERATORS = [
-  "is_empty",
-  "is_not_empty"
-];
-var FORMULA_OPERATORS = [
-  "is",
-  "is_not",
-  "less_than",
-  "greater_than",
-  "less_or_equal",
-  "greater_or_equal",
-  "contains",
-  "not_contains",
-  "is_empty",
-  "is_not_empty"
-];
-var LOCATION_FILTER_PROPERTIES = ["city", "postalCode", "country"];
-function isLocationFilterProperty(name) {
-  return LOCATION_FILTER_PROPERTIES.includes(name);
-}
-function isLocationPartOperator(operator) {
-  return TEXT_OPERATORS.includes(operator);
-}
-var ATTRIBUTE_FILTER_OPERATORS = {
-  text: TEXT_OPERATORS,
-  richtext: [],
-  number: NUMBER_OPERATORS,
-  checkbox: CHECKBOX_OPERATORS,
-  date: DATE_OPERATORS,
-  phone: ["is", "is_not", "contains", "not_contains", "starts_with", "is_empty", "is_not_empty"],
-  currency: NUMBER_OPERATORS,
-  status: SELECT_OPERATORS,
-  select: SELECT_OPERATORS,
-  multiselect: MULTISELECT_OPERATORS,
-  location: [],
-  user: REFERENCE_OPERATORS,
-  relation: REFERENCE_OPERATORS,
-  formula: FORMULA_OPERATORS,
-  document: PRESENCE_OPERATORS
-};
-var COMPUTED_TYPES = /* @__PURE__ */ new Set(["formula", "rollup"]);
-var EDGE_BACKED_TYPES = /* @__PURE__ */ new Set(["user", "relation", "document"]);
-var STATIC_DEFAULT_TYPES = /* @__PURE__ */ new Set([
-  "text",
-  "richtext",
-  "number",
-  "select",
-  "multiselect",
-  "status",
-  "date",
-  "phone",
-  "currency",
-  "location",
-  "user",
-  "relation",
-  "document"
-]);
-var PLACEHOLDER_TYPES = /* @__PURE__ */ new Set([
-  "text",
-  "number",
-  "date",
-  "phone",
-  "currency",
-  "select",
-  "multiselect"
-]);
-var SEARCHABLE_TYPES = /* @__PURE__ */ new Set([
-  "text",
-  "phone",
-  "status",
-  "select",
-  "multiselect"
-]);
-var SORTABLE_TYPES = /* @__PURE__ */ new Set([
-  "text",
-  "number",
-  "checkbox",
-  "date",
-  "phone",
-  "currency",
-  "status",
-  "select"
-]);
-function getAttributeCapabilities(attribute) {
-  const suppressed = Boolean(attribute.hidden || attribute.archived);
-  const active = !attribute.archived;
-  const computed = COMPUTED_TYPES.has(attribute.type);
-  const document = attribute.type === "document";
-  const edgeBacked = EDGE_BACKED_TYPES.has(attribute.type);
-  const cardinality = getAttributeCardinality(attribute);
-  const operators = suppressed ? [] : getRawFilterOperators(attribute);
-  const filterable = operators.length > 0 && !suppressed;
-  const searchable = !suppressed && SEARCHABLE_TYPES.has(attribute.type);
-  const sortable = !suppressed && SORTABLE_TYPES.has(attribute.type);
-  const groupable = !suppressed && isGroupableType(attribute.type);
-  const kanbanGroupable = !suppressed && attribute.type === "status";
-  const managed = isManagedSystemAttribute(attribute);
-  const readOnly = computed || document || managed;
-  const editable = !(suppressed || readOnly);
-  const required = isRequiredForbidden(attribute.type) ? "forbidden" : "allowed";
-  const defaultValue = getDefaultValueCapability(attribute.type);
-  const maxItems = supportsMaxItems(attribute);
-  const placeholder = PLACEHOLDER_TYPES.has(attribute.type);
-  const warningWhenDeprecated = Boolean(attribute.deprecated && !suppressed);
-  const editMode = resolveEditMode(attribute);
-  return {
-    lifecycle: {
-      active,
-      deprecated: Boolean(attribute.deprecated),
-      visibleInArchitect: true,
-      visibleInRuntime: !suppressed,
-      warningWhenDeprecated
-    },
-    storage: {
-      mode: computed ? "computed" : edgeBacked ? "edge" : "value",
-      cardinality,
-      edgeBacked,
-      preservesExistingValues: Boolean(attribute.archived),
-      qualifiedProperties: supportsQualifiedProperties(attribute.type),
-      polymorphic: getPolymorphicCapability(attribute),
-      maxItems
-    },
-    authoring: {
-      editable,
-      readOnly,
-      directEdit: editable && editMode === "inline",
-      required,
-      defaultValue,
-      placeholder,
-      maxItems
-    },
-    presentation: {
-      formField: !suppressed && isFormFieldType(attribute.type),
-      tableCell: !suppressed && isTableCellType(attribute.type),
-      defaultColumn: !suppressed && isDefaultColumnType(attribute.type),
-      compactDisplay: !suppressed,
-      popoverEditor: !suppressed && editMode === "popover",
-      placeholder,
-      warningWhenDeprecated
-    },
-    query: {
-      filterable,
-      searchable,
-      sortable,
-      groupable,
-      kanbanGroupable,
-      operators
-    },
-    agent: {
-      readable: !suppressed,
-      writable: editable && !document,
-      compactReadable: !suppressed,
-      contentReadable: !suppressed && isContentReadableType(attribute.type),
-      requiresDedicatedTool: document
-    },
-    exchange: {
-      importable: !suppressed,
-      exportable: !suppressed,
-      schemaExportable: true,
-      metadataExportable: false
-    }
-  };
-}
-function getAttributeFilterOperators(attribute) {
-  return getAttributeCapabilities(attribute).query.operators;
-}
-function isAttributeFilterable(attribute) {
-  return getAttributeCapabilities(attribute).query.filterable;
-}
-function isAttributeSearchable(attribute) {
-  return getAttributeCapabilities(attribute).query.searchable;
-}
-function isAttributeSortable(attribute) {
-  return getAttributeCapabilities(attribute).query.sortable;
-}
-function isAttributeGroupable(attribute) {
-  return getAttributeCapabilities(attribute).query.groupable;
-}
-function isAttributeKanbanGroupable(attribute) {
-  return getAttributeCapabilities(attribute).query.kanbanGroupable;
-}
-function resolveEffectiveFilterType(attribute) {
-  if (attribute.type !== "rollup") return attribute.type;
-  const rollup = attribute;
-  if (rollup.function === "earliest" || rollup.function === "latest") return "date";
-  if (rollup.function === "original") {
-    const targetType = rollup.targetAttributeType;
-    if (targetType && hasFilterOperatorEntry(targetType)) return targetType;
-  }
-  return "number";
-}
-function getRollupFilterOperators(attr) {
-  const effectiveType = resolveEffectiveFilterType(attr);
-  return hasFilterOperatorEntry(effectiveType) ? ATTRIBUTE_FILTER_OPERATORS[effectiveType] : ATTRIBUTE_FILTER_OPERATORS.number;
-}
-function getRawFilterOperators(attribute) {
-  if (attribute.type === "rollup") {
-    return getRollupFilterOperators(attribute);
-  }
-  return ATTRIBUTE_FILTER_OPERATORS[attribute.type] ?? [];
-}
-function getAttributeCardinality(attribute) {
-  if (attribute.type === "multiselect" || attribute.type === "document") return "many";
-  if (attribute.type === "user" && attribute.multiple === true) return "many";
-  if (attribute.type === "relation") return attribute.cardinality === "many" ? "many" : "one";
-  return "one";
-}
-function getPolymorphicCapability(attribute) {
-  if (attribute.type !== "relation") return "none";
-  const relation = attribute;
-  const targets = relation.targets ?? [];
-  if (targets.length === 1 && targets[0]?.object === "*") return "internal";
-  return targets.length > 1 ? "code-only" : "none";
-}
-function supportsMaxItems(attribute) {
-  if (attribute.type === "multiselect") return true;
-  if (attribute.type === "relation") return attribute.cardinality === "many";
-  return false;
-}
-function supportsQualifiedProperties(type) {
-  return type === "relation" || type === "document";
-}
-function isRequiredForbidden(type) {
-  return type === "checkbox" || type === "formula" || type === "rollup";
-}
-function getDefaultValueCapability(type) {
-  if (type === "checkbox") return "automatic";
-  if (type === "formula" || type === "rollup") return "forbidden";
-  if (STATIC_DEFAULT_TYPES.has(type)) return "static";
-  return "forbidden";
-}
-function isDefaultColumnType(type) {
-  return isTableCellType(type);
-}
-function isTableCellType(type) {
-  return type !== "richtext" && type !== "document";
-}
-function isFormFieldType(type) {
-  return type !== "richtext";
-}
-function resolveEditMode(attribute) {
-  switch (attribute.type) {
-    case "checkbox":
-      return "inline";
-    case "number":
-      return attribute.renderAs === "rating" ? "inline" : "default";
-    case "select":
-    case "multiselect":
-      return attribute.renderAs === "badges" ? "inline" : "popover";
-    case "status":
-    case "relation":
-    case "user":
-    case "date":
-      return "popover";
-    default:
-      return "default";
-  }
-}
-function isGroupableType(type) {
-  return type === "status" || type === "currency";
-}
-function isContentReadableType(type) {
-  return type === "richtext" || type === "document";
-}
-function hasFilterOperatorEntry(type) {
-  return Object.prototype.hasOwnProperty.call(ATTRIBUTE_FILTER_OPERATORS, type);
-}
-
-// src/types/filters.ts
-var OPERATORS_BY_TYPE = ATTRIBUTE_FILTER_OPERATORS;
-var NO_VALUE_OPERATORS = ["is_empty", "is_not_empty"];
-function isNoValueOperator(operator) {
-  return NO_VALUE_OPERATORS.includes(operator);
-}
-function getRollupFilterOperators2(attr) {
-  return getRollupFilterOperators(attr);
-}
-
-// src/filters/dynamic-value.ts
-function isDynamicValue(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && "dynamic" in value;
-}
-function currentActor() {
-  return { dynamic: "actor", ref: "current" };
-}
-function today() {
-  return { dynamic: "date", anchor: "today" };
-}
-function now() {
-  return { dynamic: "date", anchor: "now" };
-}
-
-// src/filters/extract-filter-value.ts
-function toAmount(value) {
-  if (typeof value === "number") return Number.isFinite(value) ? value : null;
-  if (typeof value === "string" && value.trim() !== "") {
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : null;
-  }
-  return null;
-}
-function extractCurrencyFilterValue(value) {
-  if (value !== null && typeof value === "object") {
-    return "value" in value ? toAmount(value.value) : null;
-  }
-  return toAmount(value);
-}
-function extractFilterValue(value) {
-  if (value === null || value === void 0) return null;
-  if (typeof value === "object" && "value" in value) {
-    return value.value ?? null;
-  }
-  return value;
-}
-
-// src/filters/polarity.ts
-var NEGATIVE_OPERATORS = /* @__PURE__ */ new Set([
-  "is_not",
-  "not_contains",
-  "none_of",
-  "is_empty"
-]);
-var NEGATIVE_TO_POSITIVE = {
-  is_not: "is",
-  not_contains: "contains",
-  none_of: "any_of",
-  is_empty: "is_not_empty"
-};
-function getOperatorPolarity(op) {
-  return NEGATIVE_OPERATORS.has(op) ? "none" : "any";
-}
-function normalizeForEdgeRpc(op) {
-  return NEGATIVE_TO_POSITIVE[op] ?? op;
-}
-var SINGLE_TO_MULTI = {
-  is: "any_of",
-  is_not: "none_of"
-};
-function toMultiValueOperator(op) {
-  return SINGLE_TO_MULTI[op] ?? op;
-}
-var SET_MEMBERSHIP_OPERATORS = new Set(
-  Object.values(SINGLE_TO_MULTI).filter((op) => op !== void 0)
-);
-function isSetMembershipOperator(op) {
-  return SET_MEMBERSHIP_OPERATORS.has(op);
-}
-
-// src/filters/canonicalize-value.ts
-function canonicalizeFilterValue(rule, effectiveType) {
-  const value = rule.value;
-  if (isNoValueOperator(rule.operator)) return;
-  if (value === null || value === void 0) return;
-  if (isDynamicValue(value)) return;
-  if (isSetMembershipOperator(rule.operator)) {
-    if (!Array.isArray(value)) rule.value = [value];
-    return;
-  }
-  if (effectiveType !== "currency") return;
-  const amount = extractCurrencyFilterValue(value);
-  if (amount !== null) {
-    rule.value = amount;
-    return;
-  }
-  if (!hasCurrencyAmount(value)) return;
-  const message = `Filter on a currency attribute expected a numeric amount, received ${JSON.stringify(
-    value
-  )}`;
-  throw new chunkY3UPKP2B_js.ValidationError(message, [{ path: ["value"], message }]);
-}
-function hasCurrencyAmount(value) {
-  if (typeof value !== "object") return true;
-  if (!("value" in value)) return false;
-  return value.value != null;
-}
-
-// src/filters/normalize-operator.ts
-var SYNONYM_ALIASES = {
-  // equality
-  eq: "is",
-  equals: "is",
-  equal: "is",
-  "==": "is",
-  "=": "is",
-  neq: "is_not",
-  notEqual: "is_not",
-  isNot: "is_not",
-  "!=": "is_not",
-  "<>": "is_not",
-  // ordering
-  lt: "less_than",
-  "<": "less_than",
-  gt: "greater_than",
-  ">": "greater_than",
-  lte: "less_or_equal",
-  "<=": "less_or_equal",
-  gte: "greater_or_equal",
-  ">=": "greater_or_equal",
-  // set
-  in: "any_of",
-  isAnyOf: "any_of",
-  anyOf: "any_of",
-  oneOf: "any_of",
-  notIn: "none_of",
-  not_in: "none_of",
-  isNoneOf: "none_of",
-  noneOf: "none_of",
-  notOneOf: "none_of",
-  // text
-  startsWith: "starts_with",
-  beginsWith: "starts_with",
-  endsWith: "ends_with",
-  doesNotContain: "not_contains",
-  notContain: "not_contains",
-  // nullity
-  isEmpty: "is_empty",
-  isNotEmpty: "is_not_empty"
-};
-function normalizeOperator(rawOp) {
-  return SYNONYM_ALIASES[rawOp] ?? rawOp;
-}
-function normalizeFilterRule(rule) {
-  const normalized = normalizeOperator(rule.operator);
-  return normalized === rule.operator ? rule : { ...rule, operator: normalized };
-}
-
-// src/filters/relative-date.ts
-var MS_PER_DAY = 864e5;
-var RELATIVE_DATE_UNITS = /* @__PURE__ */ new Set(["days", "weeks", "months", "years"]);
-var RELATIVE_DATE_DIRECTIONS = /* @__PURE__ */ new Set(["past", "future"]);
-function isRelativeDateValue(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const rel = value;
-  return typeof rel.amount === "number" && Number.isFinite(rel.amount) && rel.amount > 0 && typeof rel.unit === "string" && RELATIVE_DATE_UNITS.has(rel.unit) && typeof rel.direction === "string" && RELATIVE_DATE_DIRECTIONS.has(rel.direction);
-}
-function utcDayStart(date) {
-  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
-}
-function shiftUtcDay(dayStartMs, amount, unit) {
-  if (unit === "days") return dayStartMs + amount * MS_PER_DAY;
-  if (unit === "weeks") return dayStartMs + amount * 7 * MS_PER_DAY;
-  const from = new Date(dayStartMs);
-  const year = from.getUTCFullYear() + (unit === "years" ? amount : 0);
-  const month = from.getUTCMonth() + (unit === "months" ? amount : 0);
-  const lastDayOfTargetMonth = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
-  return Date.UTC(year, month, Math.min(from.getUTCDate(), lastDayOfTargetMonth));
-}
-function resolveIsWithinBounds(value, now2 = /* @__PURE__ */ new Date()) {
-  if (!isRelativeDateValue(value)) return null;
-  const todayStart = utcDayStart(now2);
-  const amount = Math.trunc(value.amount);
-  const bounds = value.direction === "past" ? {
-    startMs: shiftUtcDay(todayStart, -amount, value.unit),
-    endMs: todayStart + MS_PER_DAY
-  } : {
-    startMs: todayStart,
-    endMs: shiftUtcDay(todayStart, amount, value.unit) + MS_PER_DAY
-  };
-  if (!(Number.isFinite(bounds.startMs) && Number.isFinite(bounds.endMs))) return null;
-  return bounds;
-}
-function resolveUtcDayBounds(ms) {
-  if (!Number.isFinite(ms)) return null;
-  const startMs = utcDayStart(new Date(ms));
-  if (!Number.isFinite(startMs)) return null;
-  return { startMs, endMs: startMs + MS_PER_DAY };
-}
-function toUtcDayString(ms) {
-  return new Date(ms).toISOString().slice(0, 10);
-}
-
-// src/filters/validation.ts
-var REFERENCE_TYPES = /* @__PURE__ */ new Set(["relation", "document", "user"]);
-var ID_LIKE_OPERATORS = [
-  "is",
-  "is_not",
-  "any_of",
-  "none_of",
-  "is_empty",
-  "is_not_empty"
-];
-var SYSTEM_FILTER_OPERATORS = {
-  // Identifier columns (uuid)
-  id: ID_LIKE_OPERATORS,
-  objectId: ID_LIKE_OPERATORS,
-  tenantId: ID_LIKE_OPERATORS,
-  // Free-form text columns share their counterpart's operator set
-  label: OPERATORS_BY_TYPE.text,
-  // Date columns
-  createdAt: OPERATORS_BY_TYPE.date,
-  updatedAt: OPERATORS_BY_TYPE.date,
-  deletedAt: OPERATORS_BY_TYPE.date,
-  // User columns (uuid → actor identity)
-  createdBy: OPERATORS_BY_TYPE.user,
-  lastUpdatedBy: OPERATORS_BY_TYPE.user
-};
-var SYSTEM_FILTER_ATTRIBUTE_TYPES = {
-  id: "text",
-  objectId: "text",
-  objectName: "text",
-  tenantId: "text",
-  label: "text",
-  createdAt: "date",
-  updatedAt: "date",
-  deletedAt: "date",
-  deletedBy: "user",
-  createdBy: "user",
-  lastUpdatedBy: "user",
-  visibility: "select",
-  ownedBy: "user"
-};
-var REMOVED_OPERATOR_REPLACEMENTS = {
-  before: '"less_than"',
-  after: '"greater_than"',
-  on_or_before: '"less_or_equal"',
-  on_or_after: '"greater_or_equal"',
-  is_checked: '"is" with value true',
-  is_not_checked: '"is" with value false',
-  day_month_eq: '"on_day_month"'
-};
-var SET_MEMBERSHIP_TYPES = new Set(
-  Object.entries(ATTRIBUTE_FILTER_OPERATORS).filter(([, ops]) => ops.includes("any_of") && !ops.includes("contains")).map(([type]) => type)
-);
-var SUBSTRING_TO_MEMBERSHIP = {
-  contains: "any_of",
-  not_contains: "none_of"
-};
-function resolveCanonicalOperator(rawOperator, effectiveType) {
-  const replacement = REMOVED_OPERATOR_REPLACEMENTS[rawOperator];
-  if (replacement) {
-    const m = `Unknown filter operator "${rawOperator}" \u2014 use ${replacement}`;
-    throw new chunkY3UPKP2B_js.ValidationError(m, [{ path: ["operator"], message: m }]);
-  }
-  const normalized = normalizeOperator(rawOperator);
-  const membership = SUBSTRING_TO_MEMBERSHIP[normalized];
-  if (membership && SET_MEMBERSHIP_TYPES.has(effectiveType)) {
-    const m = `Operator "${normalized}" is not valid for type "${effectiveType}" \u2014 use "${membership}"`;
-    throw new chunkY3UPKP2B_js.ValidationError(m, [{ path: ["operator"], message: m }]);
-  }
-  return normalized;
-}
-function assertOperatorForType(operator, type, context) {
-  const normalized = resolveCanonicalOperator(operator, type);
-  const ops = OPERATORS_BY_TYPE[type];
-  if (!ops?.includes(normalized)) {
-    const validList = ops?.length ? ops.join(", ") : "(no operators registered for this type)";
-    const summary = `Operator "${operator}" is not valid for ${context} type "${type}". Valid operators: ${validList}.`;
-    throw new chunkY3UPKP2B_js.ValidationError(summary, [
-      {
-        path: ["operator"],
-        message: summary
-      }
-    ]);
-  }
-  return normalized;
-}
-function assertRelativeDateValue(rule) {
-  if (rule.operator !== "is_within") return;
-  if (!isRelativeDateValue(rule.value)) {
-    const m = `Operator "is_within" requires a relative-date value { amount: positive number, unit: days|weeks|months|years, direction: past|future }`;
-    throw new chunkY3UPKP2B_js.ValidationError(m, [{ path: ["value"], message: m }]);
-  }
-}
-function applyCanonicalForm(rule, operator, effectiveType) {
-  rule.operator = operator;
-  canonicalizeFilterValue(rule, effectiveType);
-  assertRelativeDateValue(rule);
-}
-function assertDynamicValueForAttribute(rule, attrType) {
-  if (!isDynamicValue(rule.value)) return;
-  const v = rule.value;
-  if (v.dynamic === "actor" && attrType !== "user") {
-    const m = `actor token (@me) is only valid on user attributes, not "${attrType}"`;
-    throw new chunkY3UPKP2B_js.ValidationError(m, [{ path: ["value"], message: m }]);
-  }
-  if (v.dynamic === "date" && attrType !== "date") {
-    const m = `date token (@today/@now) is only valid on date attributes, not "${attrType}"`;
-    throw new chunkY3UPKP2B_js.ValidationError(m, [{ path: ["value"], message: m }]);
-  }
-}
-var LOCATION_PARTS_LIST = LOCATION_FILTER_PROPERTIES.map((part) => `"${part}"`).join(", ");
-function locationPartsHint(type) {
-  return type === "location" ? ` A location is filtered on one of its parts: set "property" to one of ${LOCATION_PARTS_LIST} and use a text operator (e.g. contains).` : "";
-}
-function collectQualifiedRuleIssues(rule, context) {
-  try {
-    validateQualifiedRule({ ...rule }, context);
-    return [];
-  } catch (error) {
-    if (!(error instanceof chunkY3UPKP2B_js.ValidationError)) throw error;
-    return error.errors.map((issue) => ({ ...issue, path: [...issue.path] }));
-  }
-}
-function validateQualifiedRule(rule, context) {
-  const rootAttr = context.attributes.find((a) => a.name === rule.attribute);
-  const systemOps = SYSTEM_FILTER_OPERATORS[rule.attribute];
-  if (!(rootAttr || systemOps)) {
-    const [head, ...tail] = rule.attribute.split(".");
-    const dottedRoot = tail.length > 0 ? context.attributes.find((a) => a.name === head) : void 0;
-    const dottedHint = dottedRoot?.type === "location" ? ` Dotted paths are not supported \u2014 set "attribute" to "${head}" and "property" to ${isLocationFilterProperty(tail[0] ?? "") ? `"${tail[0]}"` : `one of ${LOCATION_PARTS_LIST}`}.` : rule.attribute.includes(".") ? ' Dotted paths are not supported \u2014 filter on the attribute name alone, or use the full-text "query" parameter to match text inside a value.' : "";
-    const m = `Unknown attribute: ${rule.attribute}${dottedHint}`;
-    throw new chunkY3UPKP2B_js.ValidationError(m, [{ path: ["attribute"], message: m }]);
-  }
-  if (rule.quantifier !== void 0 && !rule.property) {
-    const m = `quantifier is only valid on qualified edge rules (set "property")`;
-    throw new chunkY3UPKP2B_js.ValidationError(m, [{ path: ["quantifier"], message: m }]);
-  }
-  if (!rootAttr) {
-    if (rule.property) {
-      throw new chunkY3UPKP2B_js.ValidationError(`Cannot qualify system attribute "${rule.attribute}"`, [
-        { path: ["property"], message: `"${rule.attribute}" is a system column, not a reference` }
-      ]);
-    }
-    const effectiveType = SYSTEM_FILTER_ATTRIBUTE_TYPES[rule.attribute] ?? "text";
-    const normalizedOperator2 = resolveCanonicalOperator(rule.operator, effectiveType);
-    if (!systemOps.includes(normalizedOperator2)) {
-      const summary = `Operator "${rule.operator}" is not valid for system attribute "${rule.attribute}". Valid operators: ${systemOps.join(", ")}.`;
-      throw new chunkY3UPKP2B_js.ValidationError(summary, [{ path: ["operator"], message: summary }]);
-    }
-    applyCanonicalForm(rule, normalizedOperator2, effectiveType);
-    return;
-  }
-  if (!rule.property) {
-    assertDynamicValueForAttribute(rule, rootAttr.type);
-    const ops = getAttributeFilterOperators(rootAttr);
-    const normalizedOperator2 = resolveCanonicalOperator(rule.operator, rootAttr.type);
-    if (!ops.includes(normalizedOperator2)) {
-      const validList = ops.length ? ops.join(", ") : "(not filterable)";
-      const summary = `Operator "${rule.operator}" is not valid for attribute "${rootAttr.name}". Valid operators: ${validList}.${locationPartsHint(rootAttr.type)}`;
-      throw new chunkY3UPKP2B_js.ValidationError(summary, [{ path: ["operator"], message: summary }]);
-    }
-    applyCanonicalForm(rule, normalizedOperator2, resolveEffectiveFilterType(rootAttr));
-    return;
-  }
-  if (rootAttr.type === "location") {
-    if (rule.quantifier !== void 0) {
-      const m = "quantifier is not valid on a location part \u2014 a location is one value, not a set of edges";
-      throw new chunkY3UPKP2B_js.ValidationError(m, [{ path: ["quantifier"], message: m }]);
-    }
-    if (!isLocationFilterProperty(rule.property)) {
-      const m = `Property "${rule.property}" is not a part of location "${rule.attribute}". Valid parts: ${LOCATION_PARTS_LIST}.`;
-      throw new chunkY3UPKP2B_js.ValidationError(m, [{ path: ["property"], message: m }]);
-    }
-    assertDynamicValueForAttribute(rule, "text");
-    const normalizedOperator2 = assertOperatorForType(rule.operator, "text", "property");
-    applyCanonicalForm(rule, normalizedOperator2, "text");
-    return;
-  }
-  if (!REFERENCE_TYPES.has(rootAttr.type)) {
-    throw new chunkY3UPKP2B_js.ValidationError(`Cannot qualify ${rootAttr.type} attribute "${rule.attribute}"`, [
-      { path: ["property"], message: `Attribute "${rule.attribute}" is not a reference type` }
-    ]);
-  }
-  const propSchema = rootAttr.properties;
-  if (!propSchema) {
-    throw new chunkY3UPKP2B_js.ValidationError(`Attribute "${rule.attribute}" has no qualifyWith schema`, [
-      { path: ["property"], message: `"${rule.attribute}" has no qualifyWith` }
-    ]);
-  }
-  const propDef = propSchema.definitions.find((p) => p.name === rule.property);
-  if (!propDef) {
-    throw new chunkY3UPKP2B_js.ValidationError(
-      `Property "${rule.property}" not defined on "${rule.attribute}".qualifyWith()`,
-      [{ path: ["property"], message: `Unknown property: ${rule.property}` }]
-    );
-  }
-  const normalizedOperator = assertOperatorForType(rule.operator, propDef.type, "property");
-  applyCanonicalForm(rule, normalizedOperator, propDef.type);
-}
-
-// src/types/objects.ts
-var RESOURCE_VISIBILITIES = ["workspace", "private"];
-var LIST_VIEW_TAB_VISIBILITIES = ["all", ...RESOURCE_VISIBILITIES];
-function parseResourceVisibility(value) {
-  if (typeof value === "string" && RESOURCE_VISIBILITIES.includes(value)) {
-    return value;
-  }
-  throw new chunkY3UPKP2B_js.ValidationError(
-    `visibility must be one of: ${RESOURCE_VISIBILITIES.join(", ")} (received: ${String(value)})`,
-    []
-  );
-}
-var SYSTEM_FIELD_NAMES = [
-  "id",
-  "createdAt",
-  "updatedAt",
-  "createdBy",
-  "lastUpdatedBy",
-  "visibility",
-  "ownedBy"
-];
-var RESERVED_ATTRIBUTE_NAMES = [
-  // System fields (auto-managed)
-  ...SYSTEM_FIELD_NAMES,
-  // Other ObjectRecord properties
-  "objectId",
-  "label",
-  "embeddingText",
-  "values",
-  "metadata",
-  "deletedAt",
-  "deletedBy",
-  "schemaVersion",
-  // Physical SQL alias; custom attributes may otherwise use snake_case names.
-  "owned_by"
-];
-var RESERVED_OBJECT_NAMES = ["skill"];
-
-// src/validators/view-config.schema.ts
-var createModeSchema = zod.z.enum(["redirect", "inline", "peek"]);
-var nonEmptyStringArraySchema = zod.z.array(zod.z.string()).min(1);
-var columnsSchema = zod.z.array(zod.z.string()).max(chunk5N7OSHVX_js.SCHEMA_LIMITS.columnsPerTab);
-var displayAttributesSchema = zod.z.array(zod.z.string().min(1)).max(chunk5N7OSHVX_js.SCHEMA_LIMITS.columnsPerTab).refine((names) => new Set(names).size === names.length, {
-  message: "Displayed attribute names must be unique"
-});
-var sortRuleSchema = zod.z.object({
-  attribute: zod.z.string(),
-  direction: zod.z.enum(["asc", "desc"])
-}).strict();
-var sortsSchema = zod.z.array(sortRuleSchema).max(chunk5N7OSHVX_js.SCHEMA_LIMITS.sortsPerTab);
-var relativeDateValueSchema = zod.z.object({
-  amount: zod.z.number(),
-  unit: zod.z.enum(["days", "weeks", "months", "years"]),
-  direction: zod.z.enum(["past", "future"])
-}).strict();
-var currencyFilterValueSchema = zod.z.object({
-  value: zod.z.number().nullable(),
-  code: zod.z.array(zod.z.string()).optional()
-}).strict();
-var phoneFilterValueSchema = zod.z.object({
-  phoneNumber: zod.z.string().nullable(),
-  countryCode: zod.z.string().optional()
-}).strict();
-var dynamicFilterValueSchema = zod.z.discriminatedUnion("dynamic", [
-  zod.z.object({
-    dynamic: zod.z.literal("actor"),
-    ref: zod.z.literal("current")
-  }).strict(),
-  zod.z.object({
-    dynamic: zod.z.literal("date"),
-    anchor: zod.z.enum(["today", "now"])
-  }).strict()
-]);
-var dayMonthValueSchema = zod.z.object({
-  month: zod.z.number(),
-  day: zod.z.number()
-}).strict();
-var filterValueSchema = zod.z.union([
-  zod.z.string(),
-  zod.z.number(),
-  zod.z.boolean(),
-  zod.z.array(zod.z.string()),
-  relativeDateValueSchema,
-  currencyFilterValueSchema,
-  phoneFilterValueSchema,
-  dayMonthValueSchema,
-  dynamicFilterValueSchema,
-  zod.z.null()
-]);
-var filterOperatorSchema = zod.z.enum(
-  [
-    "is",
-    "is_not",
-    "contains",
-    "not_contains",
-    "starts_with",
-    "ends_with",
-    "is_empty",
-    "is_not_empty",
-    "less_than",
-    "greater_than",
-    "less_or_equal",
-    "greater_or_equal",
-    "is_within",
-    "on_day_month",
-    "any_of",
-    "none_of"
-  ],
-  {
-    error: (issue) => {
-      const input = issue.input;
-      const replacement = typeof input === "string" ? REMOVED_OPERATOR_REPLACEMENTS[input] : void 0;
-      return replacement ? `Unknown filter operator "${input}" \u2014 use ${replacement}` : void 0;
-    }
-  }
-);
-var filterRuleSchema = zod.z.object({
-  attribute: zod.z.string(),
-  property: zod.z.string().optional(),
-  quantifier: zod.z.enum(["any", "none"]).optional(),
-  operator: filterOperatorSchema,
-  value: filterValueSchema
-}).strict();
-var filterRulesSchema = zod.z.array(filterRuleSchema).max(chunk5N7OSHVX_js.SCHEMA_LIMITS.filterRulesPerTab);
-var filterStateSchema = zod.z.object({
-  combinator: zod.z.enum(["and", "or"]),
-  rules: filterRulesSchema
-}).strict();
-var filterGroupSchema = zod.z.object({
-  id: zod.z.string(),
-  combinator: zod.z.enum(["and", "or"]),
-  rules: filterRulesSchema
-}).strict();
-function addDuplicateIdIssues(values, ctx, pathPrefix = []) {
-  const seen = /* @__PURE__ */ new Set();
-  values.forEach((value, index) => {
-    if (seen.has(value.id)) {
-      ctx.addIssue({
-        code: "custom",
-        message: `Duplicate id "${value.id}"`,
-        path: [...pathPrefix, index, "id"]
-      });
-    }
-    seen.add(value.id);
-  });
-}
-function addDuplicateNameIssues(values, ctx, pathPrefix = []) {
-  const seen = /* @__PURE__ */ new Set();
-  values.forEach((value, index) => {
-    if (seen.has(value.name)) {
-      ctx.addIssue({
-        code: "custom",
-        message: `Duplicate name "${value.name}"`,
-        path: [...pathPrefix, index, "name"]
-      });
-    }
-    seen.add(value.name);
-  });
-}
-var attributeGroupFieldSchema = zod.z.object({
-  id: zod.z.string(),
-  label: zod.z.string(),
-  description: zod.z.string().optional(),
-  attributes: nonEmptyStringArraySchema,
-  displayTemplate: zod.z.string().optional()
-}).strict();
-var fieldPresentationShape = {
-  span: zod.z.union([
-    zod.z.literal(1),
-    zod.z.literal(2),
-    zod.z.literal(3),
-    zod.z.literal(4),
-    zod.z.literal(5),
-    zod.z.literal(6),
-    zod.z.literal(7),
-    zod.z.literal(8),
-    zod.z.literal(9),
-    zod.z.literal(10),
-    zod.z.literal(11),
-    zod.z.literal(12)
-  ]).optional(),
-  label: zod.z.string().optional(),
-  readOnly: zod.z.boolean().optional()
-};
-var fieldShape = {
-  attribute: zod.z.string().optional(),
-  attributeGroup: attributeGroupFieldSchema.optional(),
-  ...fieldPresentationShape
-};
-function refineField(field, ctx) {
-  if (field.attribute === void 0 === (field.attributeGroup === void 0)) {
-    ctx.addIssue({
-      code: "custom",
-      message: "A field must define exactly one of attribute or attributeGroup"
-    });
-  }
-}
-var fieldSchema = zod.z.object({
-  /** Stable slot identity. Optional: a builder may omit it, `ensureFieldIds` assigns it. */
-  id: zod.z.string().optional(),
-  ...fieldShape
-}).strict().superRefine(refineField);
-var fieldSlotSchema = zod.z.object({ id: zod.z.string().min(1), ...fieldShape }).strict().superRefine(refineField);
-var baseGroupShape = {
-  id: zod.z.string(),
-  label: zod.z.string(),
-  description: zod.z.string().optional(),
-  collapsible: zod.z.boolean().optional(),
-  collapsed: zod.z.boolean().optional(),
-  order: zod.z.number().optional()
-};
-var fieldGroupWriteSchema = zod.z.object({
-  ...baseGroupShape,
-  type: zod.z.literal("fields"),
-  fields: zod.z.array(fieldSchema).max(chunk5N7OSHVX_js.SCHEMA_LIMITS.fieldsPerGroup)
-}).strict();
-var groupWriteSchema = fieldGroupWriteSchema;
-var baseTabShape = {
-  id: zod.z.string(),
-  name: zod.z.string(),
-  label: zod.z.string(),
-  icon: chunk5N7OSHVX_js.iconNameSchema.optional(),
-  order: zod.z.number().optional()
-};
-var formTabGroupsSchema = zod.z.array(groupWriteSchema).max(chunk5N7OSHVX_js.SCHEMA_LIMITS.groupsPerFormTab);
-var formTabShape = {
-  ...baseTabShape,
-  type: zod.z.literal("form"),
-  groups: formTabGroupsSchema,
-  formColumns: zod.z.union([zod.z.literal(1), zod.z.literal(2), zod.z.literal(3)]).optional(),
-  density: zod.z.enum(["compact", "comfortable", "spacious"]).optional()
-};
-var formTabDraftObjectSchema = zod.z.object(formTabShape).strict();
-function refineFormTab(tab, ctx) {
-  addDuplicateIdIssues(tab.groups, ctx, ["groups"]);
-  const totalFields = tab.groups.reduce(
-    (count, group) => count + (group.type === "fields" ? group.fields.length : 0),
-    0
-  );
-  if (totalFields > chunk5N7OSHVX_js.SCHEMA_LIMITS.fieldsPerFormTab) {
-    ctx.addIssue({
-      code: "too_big",
-      origin: "array",
-      maximum: chunk5N7OSHVX_js.SCHEMA_LIMITS.fieldsPerFormTab,
-      inclusive: true,
-      message: `A form tab can contain at most ${chunk5N7OSHVX_js.SCHEMA_LIMITS.fieldsPerFormTab} fields`,
-      path: ["groups"]
-    });
-  }
-  const seenAttributeGroupIds = /* @__PURE__ */ new Set();
-  tab.groups.forEach((group, groupIndex) => {
-    if (group.type !== "fields") return;
-    group.fields.forEach((field, fieldIndex) => {
-      if (field.attributeGroup === void 0) return;
-      const { id } = field.attributeGroup;
-      if (seenAttributeGroupIds.has(id)) {
-        ctx.addIssue({
-          code: "custom",
-          message: `Duplicate attribute group id "${id}"`,
-          path: ["groups", groupIndex, "fields", fieldIndex, "attributeGroup", "id"]
-        });
-      }
-      seenAttributeGroupIds.add(id);
-    });
-  });
-}
-var formTabWriteSchema = zod.z.object({ ...formTabShape, groups: formTabGroupsSchema.min(1) }).strict().superRefine(refineFormTab);
-var formTabDraftSchema = formTabDraftObjectSchema.superRefine(refineFormTab);
-var relationSourceSchema = zod.z.object({
-  type: zod.z.literal("relation"),
-  attribute: zod.z.string()
-}).strict();
-var inverseSourceSchema = zod.z.object({
-  type: zod.z.literal("inverse"),
-  object: zod.z.string(),
-  attribute: zod.z.string()
-}).strict();
-var tableSourceSchema = zod.z.discriminatedUnion("type", [
-  relationSourceSchema,
-  inverseSourceSchema
-]);
-var tableTabSchema = zod.z.object({
-  ...baseTabShape,
-  type: zod.z.literal("table"),
-  source: tableSourceSchema,
-  columns: columnsSchema,
-  allowCreate: zod.z.boolean().optional(),
-  createMode: createModeSchema.optional(),
-  allowEdit: zod.z.boolean().optional(),
-  allowDelete: zod.z.boolean().optional(),
-  filters: filterStateSchema.optional(),
-  sorts: sortsSchema.optional()
-}).strict();
-var JSON_PROPS_MAX_DEPTH = 64;
-var JSON_PROPS_MAX_NODES = 1e4;
-function isPlainJsonObject(value) {
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function addJsonIssue(ctx, message, path = []) {
-  ctx.addIssue({ code: "custom", message, path });
-}
-function pushJsonArrayChildren(current, frame, stack, ctx) {
-  for (const key of Reflect.ownKeys(current)) {
-    if (key === "length") continue;
-    if (key === "__proto__") {
-      addJsonIssue(ctx, "The __proto__ key is not allowed in custom props", [...frame.path, key]);
-      continue;
-    }
-    if (typeof key === "symbol" || !/^(0|[1-9]\d*)$/.test(key)) {
-      addJsonIssue(ctx, "Arrays cannot contain non-index JSON properties", [...frame.path, key]);
-    }
-  }
-  for (let index = current.length - 1; index >= 0; index--) {
-    const descriptor = Object.getOwnPropertyDescriptor(current, String(index));
-    const path = [...frame.path, index];
-    if (!(descriptor && "value" in descriptor)) {
-      addJsonIssue(ctx, "Sparse arrays are not valid JSON values", path);
-      continue;
-    }
-    stack.push({ kind: "enter", value: descriptor.value, path, depth: frame.depth + 1 });
-  }
-}
-function pushJsonObjectChildren(current, frame, stack, ctx) {
-  const keys = Reflect.ownKeys(current);
-  for (let index = keys.length - 1; index >= 0; index--) {
-    const key = keys[index];
-    const path = [...frame.path, key];
-    if (key === "__proto__") {
-      addJsonIssue(ctx, "The __proto__ key is not allowed in custom props", path);
-      continue;
-    }
-    if (typeof key === "symbol") {
-      addJsonIssue(ctx, "Symbol keys are not valid JSON keys", path);
-      continue;
-    }
-    const descriptor = Object.getOwnPropertyDescriptor(current, key);
-    if (!(descriptor?.enumerable && "value" in descriptor)) {
-      addJsonIssue(ctx, "Custom props must contain enumerable data properties only", path);
-      continue;
-    }
-    stack.push({ kind: "enter", value: descriptor.value, path, depth: frame.depth + 1 });
-  }
-}
-function validateJsonProps(value, ctx) {
-  if (value === null || typeof value !== "object") {
-    addJsonIssue(ctx, "Expected a plain JSON object");
-    return;
-  }
-  try {
-    if (Array.isArray(value) || !isPlainJsonObject(value)) {
-      addJsonIssue(ctx, "Expected a plain JSON object");
-      return;
-    }
-  } catch {
-    addJsonIssue(ctx, "Custom props contain an object that cannot be safely inspected");
-    return;
-  }
-  const activeChain = /* @__PURE__ */ new WeakSet();
-  const stack = [{ kind: "enter", value, path: [], depth: 0 }];
-  let visitedNodes = 0;
-  while (stack.length > 0) {
-    const frame = stack.pop();
-    if (!frame) break;
-    if (frame.kind === "exit") {
-      activeChain.delete(frame.value);
-      continue;
-    }
-    visitedNodes++;
-    if (visitedNodes > JSON_PROPS_MAX_NODES) {
-      addJsonIssue(
-        ctx,
-        `Custom props cannot exceed ${JSON_PROPS_MAX_NODES.toLocaleString("en-US")} total JSON nodes`,
-        frame.path
-      );
-      return;
-    }
-    if (frame.depth > JSON_PROPS_MAX_DEPTH) {
-      addJsonIssue(ctx, `Custom props cannot exceed depth ${JSON_PROPS_MAX_DEPTH}`, frame.path);
-      continue;
-    }
-    const current = frame.value;
-    if (current === null || typeof current === "string" || typeof current === "boolean" || typeof current === "number" && Number.isFinite(current)) {
-      continue;
-    }
-    if (typeof current !== "object") {
-      addJsonIssue(ctx, "Expected a JSON value", frame.path);
-      continue;
-    }
-    if (activeChain.has(current)) {
-      addJsonIssue(ctx, "Custom props cannot contain circular references", frame.path);
-      continue;
-    }
-    try {
-      if (Array.isArray(current)) {
-        activeChain.add(current);
-        stack.push({ kind: "exit", value: current });
-        pushJsonArrayChildren(current, frame, stack, ctx);
-        continue;
-      }
-      if (!isPlainJsonObject(current)) {
-        addJsonIssue(ctx, "Expected an array or plain JSON object", frame.path);
-        continue;
-      }
-      activeChain.add(current);
-      stack.push({ kind: "exit", value: current });
-      pushJsonObjectChildren(current, frame, stack, ctx);
-    } catch {
-      addJsonIssue(
-        ctx,
-        "Custom props contain an object that cannot be safely inspected",
-        frame.path
-      );
-    }
-  }
-}
-var jsonPropsSchema = zod.z.unknown().superRefine(validateJsonProps).transform((value) => value);
-var customTabSchema = zod.z.object({
-  ...baseTabShape,
-  type: zod.z.literal("custom"),
-  component: zod.z.string(),
-  props: jsonPropsSchema.optional()
-}).strict();
-var activityTabSchema = zod.z.object({
-  ...baseTabShape,
-  type: zod.z.literal("activity"),
-  limit: zod.z.number().optional()
-}).strict();
-var richtextTabSchema = zod.z.object({
-  ...baseTabShape,
-  type: zod.z.literal("richtext"),
-  attribute: zod.z.string(),
-  titleAttribute: zod.z.string().optional()
-}).strict();
-var documentsTabSchema = zod.z.object({
-  ...baseTabShape,
-  type: zod.z.literal("documents"),
-  allowUpload: zod.z.boolean().optional(),
-  allowRemove: zod.z.boolean().optional(),
-  hideAttachments: zod.z.boolean().optional()
-}).strict();
-var formsTabSchema = zod.z.object({
-  ...baseTabShape,
-  type: zod.z.literal("forms"),
-  objectName: zod.z.string().optional()
-}).strict();
-var emailsTabSchema = zod.z.object({
-  ...baseTabShape,
-  type: zod.z.literal("emails"),
-  emailAttributeIds: zod.z.array(zod.z.string()).max(chunk5N7OSHVX_js.SCHEMA_LIMITS.emailAttributesPerTab)
-}).strict();
-var meetingsTabSchema = zod.z.object({
-  ...baseTabShape,
-  type: zod.z.literal("meetings"),
-  emailAttributeIds: zod.z.array(zod.z.string()).max(chunk5N7OSHVX_js.SCHEMA_LIMITS.emailAttributesPerTab)
-}).strict();
-var nonFormDetailTabSchemas = [
-  tableTabSchema,
-  customTabSchema,
-  activityTabSchema,
-  richtextTabSchema,
-  documentsTabSchema,
-  formsTabSchema,
-  emailsTabSchema,
-  meetingsTabSchema
-];
-var detailTabSchema = zod.z.discriminatedUnion("type", [
-  formTabWriteSchema,
-  ...nonFormDetailTabSchemas
-]);
-var detailTabDraftSchema = zod.z.discriminatedUnion("type", [
-  formTabDraftSchema,
-  ...nonFormDetailTabSchemas
-]);
-var listTabCommonShape = {
-  id: zod.z.string(),
-  label: zod.z.string(),
-  icon: chunk5N7OSHVX_js.iconNameSchema.optional(),
-  default: zod.z.boolean().optional(),
-  // Which records the tab scopes to. `"all"` is the default and means "impose
-  // no scope" — the mandatory viewer predicate alone decides, so the tab shows
-  // workspace records plus the viewer's own private ones. Defaulted rather than
-  // required so configs stored before the field existed still parse.
-  visibility: zod.z.enum(LIST_VIEW_TAB_VISIBILITIES).default("all"),
-  columns: columnsSchema,
-  descriptionAttribute: zod.z.string().min(1).optional(),
-  displayAttributes: displayAttributesSchema.optional(),
-  filters: filterGroupSchema.optional(),
-  sorts: sortsSchema.optional(),
-  readOnly: zod.z.boolean().optional(),
-  createMode: createModeSchema.optional()
-};
-var listTableTabSchema = zod.z.object({
-  ...listTabCommonShape,
-  layout: zod.z.literal("table"),
-  columnSizing: zod.z.record(zod.z.string(), zod.z.number()).optional(),
-  // Opted-in system views expose their immutable code grouping as an inert
-  // hint so Architect can return to Kanban after a saved layout change.
-  groupByAttribute: zod.z.string().min(1).optional()
-}).strict();
-var listKanbanTabSchema = zod.z.object({
-  ...listTabCommonShape,
-  layout: zod.z.literal("kanban"),
-  columns: columnsSchema.default([]),
-  groupByAttribute: zod.z.string(),
-  cardUserAttribute: zod.z.string().optional(),
-  cardDateAttribute: zod.z.string().optional(),
-  kanbanColumnOrder: zod.z.array(zod.z.string()).optional(),
-  kanbanColumnVisibility: zod.z.record(zod.z.string(), zod.z.boolean()).optional(),
-  kanbanPinnedColumns: zod.z.array(zod.z.string()).optional()
-}).strict();
-var listRowsTabSchema = zod.z.object({
-  ...listTabCommonShape,
-  layout: zod.z.literal("list"),
-  columns: columnsSchema.default([]),
-  columnSizing: zod.z.record(zod.z.string(), zod.z.number()).optional(),
-  groupByAttribute: zod.z.string().min(1).optional()
-}).strict();
-var listViewTabSchema = zod.z.discriminatedUnion("layout", [
-  listTableTabSchema,
-  listRowsTabSchema,
-  listKanbanTabSchema
-]);
-var _listViewConfigSchema = zod.z.object({
-  allowPresentationCustomization: zod.z.boolean().optional(),
-  defaultFilters: filterGroupSchema.optional(),
-  tabs: zod.z.array(listViewTabSchema).min(1).max(chunk5N7OSHVX_js.SCHEMA_LIMITS.tabsPerView)
-}).strict().superRefine((config, ctx) => {
-  addDuplicateIdIssues(config.tabs, ctx, ["tabs"]);
-  let hasDefault = false;
-  config.tabs.forEach((tab, index) => {
-    if (tab.layout !== "kanban" && tab.groupByAttribute !== void 0 && config.allowPresentationCustomization !== true) {
-      ctx.addIssue({
-        code: "unrecognized_keys",
-        keys: ["groupByAttribute"],
-        path: ["tabs", index]
-      });
-    }
-    if (!tab.default) return;
-    if (hasDefault) {
-      ctx.addIssue({
-        code: "custom",
-        message: "Only one list tab can be the default",
-        path: ["tabs", index, "default"]
-      });
-    }
-    hasDefault = true;
-  });
-});
-var sidePanelPaneSchema = zod.z.discriminatedUnion("kind", [
-  zod.z.object({
-    kind: zod.z.literal("fields"),
-    id: zod.z.string().optional(),
-    label: zod.z.string().optional(),
-    attributes: zod.z.array(zod.z.string()).max(chunk5N7OSHVX_js.SCHEMA_LIMITS.sidePanelAttributes)
-  }).strict(),
-  zod.z.object({
-    kind: zod.z.literal("activity"),
-    id: zod.z.string().optional(),
-    label: zod.z.string().optional()
-  }).strict(),
-  zod.z.object({
-    kind: zod.z.literal("documents"),
-    // Required here alone: the documents content keys its stored sort mode
-    // on this id, so a pane without one would share the main-column
-    // documents tab's sort.
-    id: zod.z.string(),
-    label: zod.z.string().optional(),
-    allowUpload: zod.z.boolean().optional(),
-    allowRemove: zod.z.boolean().optional()
-  }).strict()
-]);
-var _detailViewConfigSchema = zod.z.object({
-  tabs: zod.z.array(detailTabSchema).min(1).max(chunk5N7OSHVX_js.SCHEMA_LIMITS.tabsPerView),
-  sidePanel: zod.z.object({
-    attributes: zod.z.array(zod.z.string()).max(chunk5N7OSHVX_js.SCHEMA_LIMITS.sidePanelAttributes).optional(),
-    panes: zod.z.array(sidePanelPaneSchema).max(chunk5N7OSHVX_js.SCHEMA_LIMITS.sidePanelPanes).optional(),
-    width: zod.z.number().optional()
-  }).strict().refine((sidePanel) => sidePanel.attributes !== void 0 || sidePanel.panes !== void 0, {
-    message: "sidePanel requires attributes or panes"
-  }).refine((sidePanel) => sidePanel.panes === void 0 || sidePanel.panes.length > 0, {
-    message: "sidePanel panes must not be empty"
-  }).refine((sidePanel) => sidePanel.attributes === void 0 || sidePanel.panes === void 0, {
-    message: "sidePanel takes attributes or panes, not both"
-  }).optional()
-}).strict().superRefine((config, ctx) => {
-  addDuplicateIdIssues(config.tabs, ctx, ["tabs"]);
-  addDuplicateNameIssues(config.tabs, ctx, ["tabs"]);
-});
-var listViewConfigSchema = _listViewConfigSchema;
-var detailViewConfigSchema = _detailViewConfigSchema;
-var viewTypeSchema = zod.z.enum(["list", "detail"]);
-var viewConfigByTypeSchema = zod.z.discriminatedUnion("type", [
-  zod.z.object({
-    type: zod.z.literal("list"),
-    config: listViewConfigSchema
-  }).strict(),
-  zod.z.object({
-    type: zod.z.literal("detail"),
-    config: detailViewConfigSchema
-  }).strict()
-]);
-function parseViewConfig(type, input) {
-  switch (type) {
-    case "list":
-      return listViewConfigSchema.parse(input);
-    case "detail":
-      return detailViewConfigSchema.parse(input);
-    default:
-      return viewConfigByTypeSchema.parse({ type, config: input }).config;
-  }
-}
-var LIST_TAB_TABLE_KEYS = ["columnSizing"];
-var LIST_TAB_KANBAN_KEYS = [
-  "groupByAttribute",
-  "cardUserAttribute",
-  "cardDateAttribute",
-  "kanbanColumnOrder",
-  "kanbanColumnVisibility",
-  "kanbanPinnedColumns"
-];
-
-exports.ATTRIBUTE_FILTER_OPERATORS = ATTRIBUTE_FILTER_OPERATORS;
-exports.LIST_TAB_KANBAN_KEYS = LIST_TAB_KANBAN_KEYS;
-exports.LIST_TAB_TABLE_KEYS = LIST_TAB_TABLE_KEYS;
-exports.LIST_VIEW_TAB_VISIBILITIES = LIST_VIEW_TAB_VISIBILITIES;
-exports.LOCATION_FILTER_PROPERTIES = LOCATION_FILTER_PROPERTIES;
-exports.NO_VALUE_OPERATORS = NO_VALUE_OPERATORS;
-exports.OPERATORS_BY_TYPE = OPERATORS_BY_TYPE;
-exports.REMOVED_OPERATOR_REPLACEMENTS = REMOVED_OPERATOR_REPLACEMENTS;
-exports.RESERVED_ATTRIBUTE_NAMES = RESERVED_ATTRIBUTE_NAMES;
-exports.RESERVED_OBJECT_NAMES = RESERVED_OBJECT_NAMES;
-exports.RESOURCE_VISIBILITIES = RESOURCE_VISIBILITIES;
-exports.SYNONYM_ALIASES = SYNONYM_ALIASES;
-exports.SYSTEM_ATTRIBUTES = SYSTEM_ATTRIBUTES;
-exports.SYSTEM_ATTRIBUTE_I18N_KEYS = SYSTEM_ATTRIBUTE_I18N_KEYS;
-exports.SYSTEM_FIELD_NAMES = SYSTEM_FIELD_NAMES;
-exports.SYSTEM_FILTER_ATTRIBUTE_TYPES = SYSTEM_FILTER_ATTRIBUTE_TYPES;
-exports.canonicalizeFilterValue = canonicalizeFilterValue;
-exports.collectQualifiedRuleIssues = collectQualifiedRuleIssues;
-exports.columnsSchema = columnsSchema;
-exports.currentActor = currentActor;
-exports.detailTabDraftSchema = detailTabDraftSchema;
-exports.detailTabSchema = detailTabSchema;
-exports.detailViewConfigSchema = detailViewConfigSchema;
-exports.displayAttributesSchema = displayAttributesSchema;
-exports.extractCurrencyFilterValue = extractCurrencyFilterValue;
-exports.extractFilterValue = extractFilterValue;
-exports.fieldSchema = fieldSchema;
-exports.fieldShape = fieldShape;
-exports.fieldSlotSchema = fieldSlotSchema;
-exports.filterGroupSchema = filterGroupSchema;
-exports.filterStateSchema = filterStateSchema;
-exports.getAttributeCapabilities = getAttributeCapabilities;
-exports.getAttributeFilterOperators = getAttributeFilterOperators;
-exports.getOperatorPolarity = getOperatorPolarity;
-exports.getRollupFilterOperators = getRollupFilterOperators2;
-exports.getSystemAttributeI18nKey = getSystemAttributeI18nKey;
-exports.getSystemAttributeList = getSystemAttributeList;
-exports.groupWriteSchema = groupWriteSchema;
-exports.inverseSourceSchema = inverseSourceSchema;
-exports.isAttributeFilterable = isAttributeFilterable;
-exports.isAttributeGroupable = isAttributeGroupable;
-exports.isAttributeKanbanGroupable = isAttributeKanbanGroupable;
-exports.isAttributeSearchable = isAttributeSearchable;
-exports.isAttributeSortable = isAttributeSortable;
-exports.isDynamicValue = isDynamicValue;
-exports.isLocationFilterProperty = isLocationFilterProperty;
-exports.isLocationPartOperator = isLocationPartOperator;
-exports.isManagedSystemAttribute = isManagedSystemAttribute;
-exports.isNoValueOperator = isNoValueOperator;
-exports.isRelativeDateValue = isRelativeDateValue;
-exports.isSetMembershipOperator = isSetMembershipOperator;
-exports.listViewConfigSchema = listViewConfigSchema;
-exports.listViewTabSchema = listViewTabSchema;
-exports.normalizeFilterRule = normalizeFilterRule;
-exports.normalizeForEdgeRpc = normalizeForEdgeRpc;
-exports.normalizeOperator = normalizeOperator;
-exports.now = now;
-exports.parseResourceVisibility = parseResourceVisibility;
-exports.parseViewConfig = parseViewConfig;
-exports.relationSourceSchema = relationSourceSchema;
-exports.resolveEffectiveFilterType = resolveEffectiveFilterType;
-exports.resolveIsWithinBounds = resolveIsWithinBounds;
-exports.resolveUtcDayBounds = resolveUtcDayBounds;
-exports.sortsSchema = sortsSchema;
-exports.tableSourceSchema = tableSourceSchema;
-exports.toMultiValueOperator = toMultiValueOperator;
-exports.toUtcDayString = toUtcDayString;
-exports.today = today;
-exports.validateQualifiedRule = validateQualifiedRule;
-exports.viewConfigByTypeSchema = viewConfigByTypeSchema;
-exports.viewTypeSchema = viewTypeSchema;