react-semaphor 0.1.398 → 0.1.399

package/dist/chunks/analyze-result-contract-CUO5QmqV.js

@@ -0,0 +1,1797 @@
+import { z as e } from "zod";
+const M = {
+  answerSummary: "string",
+  responseDetail: "responseDetail",
+  mode: "string",
+  comparisonType: "string",
+  executionResult: "executionResult",
+  compiledQuery: "unknown",
+  data: "unknown",
+  resultSets: "record",
+  analysisWarnings: "unknownArray",
+  columns: "unknownArray",
+  records: "recordArray",
+  rowCount: "number",
+  rowLimitExceeded: "boolean",
+  output: "string",
+  querySpec: "unknown",
+  metadata: "record",
+  validation: "validationResult",
+  coverage: "coverage",
+  diagnosticFeedback: "diagnosticFeedback",
+  missingFields: "stringArray",
+  warnings: "unknownArray",
+  comparison: "unknown",
+  population: "population",
+  comparisons: "recordArray",
+  fieldsUsed: "compactExecutionFieldArray",
+  primary: "recordArray",
+  contributors: "recordArray",
+  segments: "recordArray",
+  periodChanges: "recordArray",
+  changes: "recordArray",
+  largestNegativeChanges: "recordArray",
+  largestPositiveChanges: "recordArray",
+  drivers: "recordArray",
+  absoluteDeltaDrivers: "recordArray",
+  largestNegativeDrivers: "recordArray",
+  largestPositiveDrivers: "recordArray",
+  periodRows: "recordArray",
+  sql: "unknown",
+  omitted: "stringArray"
+}, N = "semaphor-data-app-codegen-summary/v1", Ho = "semaphor-data-app-codegen-summary-validator/v2", ge = /* @__PURE__ */ new Set([
+  "metric",
+  "records",
+  "matrix",
+  "analysis",
+  "sql_fallback"
+]), he = /* @__PURE__ */ new Set([
+  "semaphor.metric",
+  "semaphor.records",
+  "semaphor.matrix",
+  "semaphor.analysis",
+  "semaphor.sql"
+]), fe = /* @__PURE__ */ new Set([
+  "absolute_delta",
+  "largest_negative",
+  "largest_positive",
+  "positive_and_negative",
+  "all"
+]), Y = /* @__PURE__ */ new Set([
+  "source",
+  "id",
+  "label",
+  "measures",
+  "primaryMeasure",
+  "dateField",
+  "timeGrain",
+  "dimensions",
+  "comparison",
+  "orderBy",
+  "filters",
+  "relationshipHint",
+  "limit",
+  "derivedFields"
+]), be = /* @__PURE__ */ new Set([
+  ...Y,
+  "analysis",
+  "timeWindow",
+  "filters",
+  "driverMode",
+  "includePopulation",
+  "calendarContext",
+  "chartTitle",
+  "chartType"
+]), ye = /* @__PURE__ */ new Set([
+  "source",
+  "id",
+  "label",
+  "fields",
+  "dateField",
+  "timeGrain",
+  "timeWindow",
+  "filters",
+  "orderBy",
+  "relationshipHint",
+  "limit",
+  "pagination",
+  "totals",
+  "derivedFields"
+]), ve = /* @__PURE__ */ new Set([
+  "source",
+  "id",
+  "label",
+  "filters",
+  "relationshipHint",
+  "rows",
+  "columns",
+  "values",
+  "totals",
+  "sort",
+  "expansion",
+  "layout",
+  "displayLimits"
+]), $e = /* @__PURE__ */ new Set([
+  "source",
+  "id",
+  "label",
+  "sql",
+  "defaultParameters",
+  "pythonCode",
+  "fields",
+  "limit",
+  "pagination",
+  "rationale"
+]), Se = /* @__PURE__ */ new Set([
+  "kpi",
+  "line_chart",
+  "bar_chart",
+  "stacked_bar_chart",
+  "pie_chart",
+  "donut_chart",
+  "area_chart",
+  "table",
+  "matrix",
+  "narrative",
+  "text_block",
+  "custom"
+]), we = /* @__PURE__ */ new Set([
+  "missing_measure",
+  "missing_dimension",
+  "missing_date",
+  "missing_relationship",
+  "missing_semantic_role",
+  "missing_current_app_state",
+  "unsupported_change_intent",
+  "ambiguous_field_grounding",
+  "invalid_ranker_output",
+  "latest_snapshot_selector_not_modeled",
+  "unsupported_grain",
+  "requires_sql_escape_hatch",
+  "unsupported_sdk_capability"
+]);
+function Qo(i) {
+  return W(i).ok;
+}
+function W(i) {
+  const t = [];
+  if (!i || typeof i != "object")
+    return { ok: !1, issues: ["Summary must be an object."] };
+  const o = i;
+  return o.schemaVersion !== N && t.push(
+    `schemaVersion must be ${N}.`
+  ), (typeof o.title != "string" || !o.title.trim()) && t.push("title is required."), Array.isArray(o.sources) || t.push("sources must be an array."), Array.isArray(o.inputs) || t.push("inputs must be an array."), Array.isArray(o.views) || t.push("views must be an array."), Array.isArray(o.filterContracts) || t.push("filterContracts must be an array."), (!o.implementationChecklist || typeof o.implementationChecklist != "object") && t.push("implementationChecklist must be an object."), o.implementationChecklist && typeof o.implementationChecklist == "object" && t.push(
+    ...Ae(o.implementationChecklist)
+  ), Array.isArray(o.sources) && o.sources.forEach((s, r) => {
+    t.push(...w(s, `sources.${r}`));
+  }), Array.isArray(o.inputs) && o.inputs.forEach((s, r) => {
+    t.push(...Ie(s, `inputs.${r}`));
+  }), Array.isArray(o.views) && o.views.forEach((s, r) => {
+    t.push(..._e(s, `views.${r}`));
+  }), Array.isArray(o.filterContracts) && o.filterContracts.forEach((s, r) => {
+    t.push(
+      ...xe(s, `filterContracts.${r}`)
+    );
+  }), o.unsupportedInsights !== void 0 && (Array.isArray(o.unsupportedInsights) ? o.unsupportedInsights.forEach((s, r) => {
+    t.push(
+      ...We(
+        s,
+        `unsupportedInsights.${r}`
+      )
+    );
+  }) : t.push("unsupportedInsights must be an array.")), t.push(...ke(o)), { ok: t.length === 0, issues: t };
+}
+function ke(i) {
+  const t = Array.isArray(i.unsupportedInsights) && i.unsupportedInsights.some(
+    (l) => {
+      var u;
+      return ((u = a(l)) == null ? void 0 : u.reason) === "missing_relationship";
+    }
+  ), o = Array.isArray(i.views) && i.views.some((l) => {
+    var p;
+    const u = a((p = a(l)) == null ? void 0 : p.computation);
+    return (u == null ? void 0 : u.kind) === "unsupported" && u.reason === "missing_relationship";
+  });
+  if (!t && !o)
+    return [];
+  const s = [], r = a(i.validation);
+  (r == null ? void 0 : r.status) !== "blocked" && s.push(
+    "validation.status must be blocked when missing_relationship gaps are present."
+  );
+  const n = a(i.nextRequiredTool);
+  return (n == null ? void 0 : n.name) !== "semaphor_propose_semantic_model_change" && s.push(
+    "nextRequiredTool.name must be semaphor_propose_semantic_model_change when missing_relationship gaps are present."
+  ), s;
+}
+function w(i, t) {
+  const o = a(i);
+  return o ? o.kind === "semantic" ? typeof o.domainId == "string" && o.domainId.trim() && typeof o.datasetName == "string" && o.datasetName.trim() ? [] : [`${t} must include sourceKey or a supported source identity.`] : typeof o.sourceKey == "string" && o.sourceKey.trim() ? [] : o.kind === "physical" && typeof o.tableName == "string" && o.tableName.trim() && typeof o.connectionId == "string" && o.connectionId.trim() ? [] : o.kind === "sql" && typeof o.connectionId == "string" && o.connectionId.trim() ? [] : [`${t} must include sourceKey or a supported source identity.`] : [`${t} must be an object.`];
+}
+function Ae(i) {
+  const t = a(i);
+  if (!t)
+    return ["implementationChecklist must be an object."];
+  const o = [], s = [
+    "requiredDevtools",
+    "requiredInputOptions",
+    "filterScopeByInput",
+    "bindingsByView",
+    "validationCommands",
+    "browserSmokeChecks"
+  ];
+  for (const n of s)
+    n in t || o.push(`implementationChecklist.${n} is required.`);
+  const r = a(t.requiredDevtools);
+  return r ? typeof r.mountRootDevtools != "boolean" && o.push(
+    "implementationChecklist.requiredDevtools.mountRootDevtools must be a boolean."
+  ) : o.push("implementationChecklist.requiredDevtools must be an object."), Array.isArray(t.requiredInputOptions) || o.push(
+    "implementationChecklist.requiredInputOptions must be an array."
+  ), Array.isArray(t.filterScopeByInput) || o.push("implementationChecklist.filterScopeByInput must be an array."), a(t.bindingsByView) || o.push("implementationChecklist.bindingsByView must be an object."), g(t.validationCommands) || o.push(
+    "implementationChecklist.validationCommands must be an array of strings."
+  ), g(t.browserSmokeChecks) || o.push(
+    "implementationChecklist.browserSmokeChecks must be an array of strings."
+  ), o;
+}
+function Ie(i, t) {
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [];
+  return (typeof o.id != "string" || !o.id.trim()) && s.push(`${t}.id is required.`), o.fieldRef && s.push(...d(o.fieldRef, `${t}.fieldRef`)), s.push(...Z(o.optionQuery, `${t}.optionQuery`)), g(o.appliesToViewIds) || s.push(`${t}.appliesToViewIds must be an array of strings.`), o.bindings !== void 0 && !Array.isArray(o.bindings) && s.push(`${t}.bindings must be an array.`), Array.isArray(o.bindings) && o.bindings.forEach((r, n) => {
+    const l = a(r);
+    if (!l) {
+      s.push(`${t}.bindings.${n} must be an object.`);
+      return;
+    }
+    g(l.appliesToViewIds) || s.push(
+      `${t}.bindings.${n}.appliesToViewIds must be an array of strings.`
+    ), s.push(
+      ...d(
+        l.fieldRef,
+        `${t}.bindings.${n}.fieldRef`
+      )
+    );
+  }), s;
+}
+function _e(i, t) {
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [];
+  if ((typeof o.id != "string" || !o.id.trim()) && s.push(`${t}.id is required.`), o.visualSpec !== void 0 && s.push(...Le(o.visualSpec, `${t}.visualSpec`)), o.computation !== void 0 && s.push(...Ye(o.computation, `${t}.computation`)), Ve(o))
+    return o.fields !== void 0 && (Array.isArray(o.fields) ? o.fields.forEach((n, l) => {
+      s.push(...d(n, `${t}.fields.${l}`));
+    }) : s.push(`${t}.fields must be an array.`)), o.queryKind !== void 0 && s.push(`${t}.queryKind is not allowed for non-executable views.`), o.sdkBuilder !== void 0 && s.push(`${t}.sdkBuilder is not allowed for non-executable views.`), o.sdkSpec !== void 0 && s.push(`${t}.sdkSpec is not allowed for non-executable views.`), s;
+  if (!Array.isArray(o.fields))
+    return s.push(`${t}.fields must be an array.`), (o.sdkSpec !== void 0 || o.sdkBuilder !== void 0) && s.push(`${t}.fields must be an array for executable views.`), s;
+  o.fields.forEach((n, l) => {
+    s.push(...d(n, `${t}.fields.${l}`));
+  }), $(o.queryKind) || s.push(`${t}.queryKind must be a supported codegen query kind.`), o.sdkBuilder !== void 0 && !J(o.sdkBuilder) && s.push(`${t}.sdkBuilder must be a supported SDK builder.`);
+  const r = a(o.computation);
+  return (r == null ? void 0 : r.kind) === "server_query" && $(o.queryKind) && $(r.queryKind) && r.queryKind !== o.queryKind && s.push(`${t}.computation.queryKind must match queryKind.`), s.push(
+    ...Ee({
+      value: o.sdkSpec,
+      path: `${t}.sdkSpec`,
+      queryKind: typeof o.queryKind == "string" ? o.queryKind : void 0,
+      sdkBuilder: typeof o.sdkBuilder == "string" ? o.sdkBuilder : void 0
+    }),
+    ...je(o, `${t}`)
+  ), s;
+}
+function je(i, t) {
+  var L, G;
+  const o = a((L = a(i.visualSpec)) == null ? void 0 : L.tableBehavior);
+  if (!o)
+    return [];
+  const s = a(o.totals);
+  if (!s)
+    return [];
+  const r = a(i.sdkSpec), n = a(r == null ? void 0 : r.spec), l = a(n == null ? void 0 : n.totals), u = [], p = typeof (r == null ? void 0 : r.builder) == "string" ? r.builder : void 0, me = (G = a(o.pagination)) == null ? void 0 : G.mode;
+  return s.mode === "server" && (p !== "semaphor.records" && u.push(
+    `${t}.visualSpec.tableBehavior.totals.mode server is only supported for semaphor.records views.`
+  ), !l || l.mode !== "server" ? u.push(
+    `${t}.sdkSpec.spec.totals.mode must be server when tableBehavior.totals.mode is server.`
+  ) : u.push(
+    ...Re({
+      left: s.measures,
+      right: l.measures,
+      leftPath: `${t}.visualSpec.tableBehavior.totals.measures`,
+      rightPath: `${t}.sdkSpec.spec.totals.measures`
+    })
+  )), s.mode !== "server" && l && u.push(
+    `${t}.sdkSpec.spec.totals is only allowed when tableBehavior.totals.mode is server.`
+  ), s.mode === "local" && me === "server" && u.push(
+    `${t}.visualSpec.tableBehavior.totals.mode must not be local for server-paginated tables.`
+  ), p === "semaphor.sql" && s.mode !== "none" && u.push(
+    `${t}.visualSpec.tableBehavior.totals.mode must be none for semaphor.sql views.`
+  ), p === "semaphor.sql" && l && u.push(`${t}.sdkSpec.spec.totals is not supported for semaphor.sql.`), u;
+}
+function Re({
+  left: i,
+  right: t,
+  leftPath: o,
+  rightPath: s
+}) {
+  if (!Array.isArray(i) || !Array.isArray(t))
+    return [`${s} must match ${o}.`];
+  const r = [];
+  return i.length !== t.length ? (r.push(`${s} must match ${o}.`), r) : (i.forEach((n, l) => {
+    Ce(
+      a(n),
+      a(t[l])
+    ) || r.push(`${s}.${l} must match ${o}.${l}.`);
+  }), r);
+}
+function Ce(i, t) {
+  return !i || !t ? !1 : i.name === t.name && (i.role || "measure") === (t.role || "measure") && U(i) === U(t) && qe(i, t);
+}
+function U(i) {
+  return typeof i.aggregate == "string" ? i.aggregate.toUpperCase() : "SUM";
+}
+function qe(i, t) {
+  const o = typeof i.sourceKey == "string" ? i.sourceKey : void 0, s = typeof t.sourceKey == "string" ? t.sourceKey : void 0;
+  if (o || s)
+    return o === s;
+  const r = a(i.source), n = a(t.source);
+  return !r || !n || r.kind !== n.kind ? !1 : r.kind === "semantic" ? r.domainId === n.domainId && r.datasetName === n.datasetName && (r.datasetId === void 0 || n.datasetId === void 0 || r.datasetId === n.datasetId) : r.kind === "physical" ? r.connectionId === n.connectionId && r.tableName === n.tableName : r.kind === "sql" ? r.connectionId === n.connectionId : !1;
+}
+function xe(i, t) {
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [];
+  if (o.fieldRef && s.push(
+    ...d(o.fieldRef, `${t}.fieldRef`)
+  ), (typeof o.inputId != "string" || !o.inputId.trim()) && s.push(`${t}.inputId is required.`), s.push(
+    ...Z(o.optionQuery, `${t}.optionQuery`)
+  ), g(o.appliesToViewIds) || s.push(`${t}.appliesToViewIds must be an array of strings.`), g(o.notAppliedToViewIds) || s.push(`${t}.notAppliedToViewIds must be an array of strings.`), !Array.isArray(o.bindings))
+    s.push(`${t}.bindings must be an array.`);
+  else {
+    const r = g(o.appliesToViewIds) ? new Set(o.appliesToViewIds) : void 0, n = g(
+      o.notAppliedToViewIds
+    ) ? new Set(o.notAppliedToViewIds) : void 0;
+    o.bindings.forEach((l, u) => {
+      const p = a(l);
+      if (!p) {
+        s.push(`${t}.bindings.${u} must be an object.`);
+        return;
+      }
+      typeof p.viewId != "string" || !p.viewId ? s.push(`${t}.bindings.${u}.viewId is required.`) : (r && !r.has(p.viewId) && s.push(
+        `${t}.bindings.${u}.viewId must be included in appliesToViewIds.`
+      ), n != null && n.has(p.viewId) && s.push(
+        `${t}.bindings.${u}.viewId must not be listed in notAppliedToViewIds.`
+      )), s.push(
+        ...d(
+          p.fieldRef,
+          `${t}.bindings.${u}.fieldRef`
+        )
+      );
+    });
+  }
+  return s;
+}
+function Z(i, t) {
+  if (i === void 0)
+    return [];
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [
+    ...h(
+      o.valueFieldRef,
+      `${t}.valueFieldRef`
+    ),
+    ...h(
+      o.labelFieldRef,
+      `${t}.labelFieldRef`
+    ),
+    ...h(
+      o.filterFieldRef,
+      `${t}.filterFieldRef`
+    )
+  ];
+  return o.builder !== "semaphor.inputOptions" && s.push(`${t}.builder must be semaphor.inputOptions.`), typeof o.sourceKey != "string" && o.source === void 0 && s.push(`${t} must include source or sourceKey.`), o.source !== void 0 && s.push(...w(o.source, `${t}.source`)), a(o.valueFieldRef) || s.push(`${t}.valueFieldRef is required.`), a(o.labelFieldRef) || s.push(`${t}.labelFieldRef is required.`), o.limit !== void 0 && (typeof o.limit != "number" || !Number.isInteger(o.limit) || o.limit <= 0) && s.push(`${t}.limit must be a positive integer.`), s;
+}
+function Ee(i) {
+  var r;
+  const t = a(i.value);
+  if (!t)
+    return [`${i.path} is required for executable views.`];
+  const o = [];
+  if (!J(t.builder))
+    return o.push(`${i.path}.builder must be a supported SDK builder.`), o;
+  i.sdkBuilder && t.builder !== i.sdkBuilder && o.push(`${i.path}.builder must match sdkBuilder.`), i.queryKind && $(i.queryKind) && t.builder !== Pe(i.queryKind) && o.push(`${i.path}.builder must match queryKind.`);
+  const s = a(t.spec);
+  if (!s)
+    return o.push(`${i.path}.spec must be an object.`), o;
+  switch (t.builder) {
+    case "semaphor.metric":
+      o.push(
+        ...v(s, Y, `${i.path}.spec`),
+        ...I(s, i.path),
+        ...E(s.measures, `${i.path}.spec.measures`),
+        ...h(
+          s.primaryMeasure,
+          `${i.path}.spec.primaryMeasure`
+        ),
+        ...h(
+          s.dateField,
+          `${i.path}.spec.dateField`
+        ),
+        ...F(
+          s.dimensions,
+          `${i.path}.spec.dimensions`
+        ),
+        ...T(s.orderBy, `${i.path}.spec.orderBy`),
+        ..._(s.filters, `${i.path}.spec.filters`)
+      );
+      break;
+    case "semaphor.analysis":
+      o.push(
+        ...v(s, be, `${i.path}.spec`),
+        ...I(s, i.path),
+        ...E(s.measures, `${i.path}.spec.measures`),
+        ...h(
+          s.primaryMeasure,
+          `${i.path}.spec.primaryMeasure`
+        ),
+        ...h(
+          s.dateField,
+          `${i.path}.spec.dateField`
+        ),
+        ...F(
+          s.dimensions,
+          `${i.path}.spec.dimensions`
+        ),
+        ...T(s.orderBy, `${i.path}.spec.orderBy`),
+        ..._(s.filters, `${i.path}.spec.filters`),
+        ...Fe(s, `${i.path}.spec`)
+      );
+      break;
+    case "semaphor.records":
+      o.push(
+        ...v(s, ye, `${i.path}.spec`),
+        ...I(s, i.path),
+        ...E(s.fields, `${i.path}.spec.fields`),
+        ...h(
+          s.dateField,
+          `${i.path}.spec.dateField`
+        ),
+        ...T(s.orderBy, `${i.path}.spec.orderBy`),
+        ..._(s.filters, `${i.path}.spec.filters`),
+        ...Te(
+          s.totals,
+          `${i.path}.spec.totals`
+        )
+      );
+      break;
+    case "semaphor.matrix":
+      o.push(
+        ...v(s, ve, `${i.path}.spec`),
+        ...De(s, i.path),
+        ...Ne(s.rows, `${i.path}.spec.rows`),
+        ...Oe(
+          s.columns,
+          `${i.path}.spec.columns`
+        ),
+        ...Ke(s.values, `${i.path}.spec.values`),
+        ...Me(s.sort, `${i.path}.spec.sort`),
+        ..._(s.filters, `${i.path}.spec.filters`)
+      );
+      break;
+    case "semaphor.sql":
+      o.push(
+        ...v(s, $e, `${i.path}.spec`),
+        ...I(s, i.path)
+      ), ((r = a(s.source)) == null ? void 0 : r.kind) !== "sql" && o.push(`${i.path}.spec.source.kind must be sql.`), (typeof s.sql != "string" || !s.sql.trim()) && o.push(`${i.path}.spec.sql is required.`), o.push(
+        ...F(
+          s.fields,
+          `${i.path}.spec.fields`
+        )
+      );
+      break;
+  }
+  return o;
+}
+function Fe(i, t) {
+  const o = [];
+  if (i.driverMode !== void 0 && !fe.has(i.driverMode) && o.push(`${t}.driverMode must be a supported analysis driver mode.`), i.includePopulation !== void 0 && typeof i.includePopulation != "boolean" && o.push(`${t}.includePopulation must be a boolean.`), i.calendarContext !== void 0) {
+    const s = a(i.calendarContext);
+    if (!s)
+      o.push(`${t}.calendarContext must be an object.`);
+    else {
+      s.tz !== void 0 && typeof s.tz != "string" && o.push(`${t}.calendarContext.tz must be a string.`), s.weekStart !== void 0 && (typeof s.weekStart != "number" || !Number.isInteger(s.weekStart) || s.weekStart < 0 || s.weekStart > 6) && o.push(
+        `${t}.calendarContext.weekStart must be an integer between 0 and 6.`
+      );
+      const r = s.anchor;
+      if (r !== void 0 && r !== "now") {
+        const n = a(r);
+        (!n || typeof n.iso != "string" || !n.iso.trim()) && o.push(`${t}.calendarContext.anchor must be now or { iso }.`);
+      }
+    }
+  }
+  return o;
+}
+function Te(i, t) {
+  if (i === void 0)
+    return [];
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [];
+  return o.mode !== "server" && s.push(`${t}.mode must be server.`), !Array.isArray(o.measures) || o.measures.length === 0 ? s.push(`${t}.measures must include at least one measure.`) : o.measures.forEach((r, n) => {
+    var l;
+    s.push(
+      ...ee(
+        r,
+        `${t}.measures.${n}`
+      )
+    ), ((l = a(r)) == null ? void 0 : l.role) !== "measure" && s.push(`${t}.measures.${n}.role must be measure.`);
+  }), s;
+}
+function v(i, t, o) {
+  const s = [];
+  return Object.keys(i).forEach((r) => {
+    t.has(r) || s.push(`${o}.${r} is not supported for this SDK builder.`);
+  }), s;
+}
+function I(i, t) {
+  return a(i.source) ? w(i.source, `${t}.spec.source`) : [`${t}.spec.source must be an object.`];
+}
+function De(i, t) {
+  const o = a(i.source);
+  if (!o)
+    return [`${t}.spec.source must be an object.`];
+  const s = w(i.source, `${t}.spec.source`);
+  return o.kind !== "semantic" && o.kind !== "physical" && s.push(`${t}.spec.source.kind must be semantic or physical.`), s;
+}
+function E(i, t) {
+  const o = B(i, t);
+  return Array.isArray(i) && i.forEach((s, r) => {
+    o.push(...d(s, `${t}.${r}`));
+  }), o;
+}
+function F(i, t) {
+  if (i === void 0)
+    return [];
+  if (!Array.isArray(i))
+    return [`${t} must be an array.`];
+  const o = [];
+  return i.forEach((s, r) => {
+    o.push(...d(s, `${t}.${r}`));
+  }), o;
+}
+function T(i, t) {
+  if (i === void 0)
+    return [];
+  const o = a(i);
+  return o ? [
+    ...d(o.field, `${t}.field`),
+    ...X(o.direction, `${t}.direction`)
+  ] : [`${t} must be an object.`];
+}
+function Ne(i, t) {
+  const o = B(i, t);
+  return Array.isArray(i) && i.forEach((s, r) => {
+    const n = a(s);
+    if (!n) {
+      o.push(`${t}.${r} must be an object.`);
+      return;
+    }
+    o.push(
+      ...d(n.field, `${t}.${r}.field`)
+    );
+  }), o;
+}
+function Oe(i, t) {
+  if (i === void 0)
+    return [];
+  const o = [];
+  return Array.isArray(i) ? (i.forEach((s, r) => {
+    const n = a(s);
+    if (!n) {
+      o.push(`${t}.${r} must be an object.`);
+      return;
+    }
+    o.push(
+      ...d(n.field, `${t}.${r}.field`)
+    );
+  }), o) : [`${t} must be an array.`];
+}
+function Ke(i, t) {
+  const o = B(i, t);
+  return Array.isArray(i) && i.forEach((s, r) => {
+    const n = a(s);
+    if (!n) {
+      o.push(`${t}.${r} must be an object.`);
+      return;
+    }
+    o.push(
+      ...d(n.field, `${t}.${r}.field`)
+    );
+  }), o;
+}
+function Me(i, t) {
+  if (i === void 0)
+    return [];
+  if (!Array.isArray(i))
+    return [`${t} must be an array.`];
+  const o = [];
+  return i.forEach((s, r) => {
+    const n = a(s);
+    if (!n) {
+      o.push(`${t}.${r} must be an object.`);
+      return;
+    }
+    n.axis !== "row" && n.axis !== "column" && o.push(`${t}.${r}.axis must be row or column.`), o.push(
+      ...X(n.direction, `${t}.${r}.direction`),
+      ...Be(n.by, `${t}.${r}.by`)
+    );
+  }), o;
+}
+function Be(i, t) {
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  switch (o.kind) {
+    case "label":
+      return [];
+    case "field":
+      return d(o.field, `${t}.field`);
+    case "value":
+      return typeof o.valueId != "string" || !o.valueId.trim() ? [`${t}.valueId is required.`] : [];
+    default:
+      return [`${t}.kind must be label, field, or value.`];
+  }
+}
+function X(i, t) {
+  return i === "asc" || i === "desc" ? [] : [`${t} must be asc or desc.`];
+}
+function _(i, t) {
+  if (i === void 0)
+    return [];
+  if (!Array.isArray(i))
+    return [`${t} must be an array.`];
+  const o = [];
+  return i.forEach((s, r) => {
+    const n = a(s);
+    if (!n) {
+      o.push(`${t}.${r} must be an object.`);
+      return;
+    }
+    o.push(...d(n.field, `${t}.${r}.field`));
+  }), o;
+}
+function B(i, t) {
+  return !Array.isArray(i) || i.length === 0 ? [`${t} must be a non-empty array.`] : [];
+}
+function Pe(i) {
+  switch (i) {
+    case "metric":
+      return "semaphor.metric";
+    case "records":
+      return "semaphor.records";
+    case "matrix":
+      return "semaphor.matrix";
+    case "analysis":
+      return "semaphor.analysis";
+    case "sql_fallback":
+      return "semaphor.sql";
+  }
+}
+function Ve(i) {
+  const t = a(i.computation), o = a(i.visualSpec);
+  return (t == null ? void 0 : t.kind) === "presentation_only" || (t == null ? void 0 : t.kind) === "derived" || (t == null ? void 0 : t.kind) === "unsupported" || i.visual === "text_block" || (o == null ? void 0 : o.visualType) === "text_block";
+}
+function Le(i, t) {
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [];
+  return Se.has(o.visualType) || s.push(`${t}.visualType must be a supported visual type.`), o.limit !== void 0 && (typeof o.limit != "number" || !Number.isInteger(o.limit) || o.limit <= 0) && s.push(`${t}.limit must be a positive integer.`), o.tableBehavior !== void 0 && s.push(
+    ...Ge(
+      o.tableBehavior,
+      `${t}.tableBehavior`
+    )
+  ), s;
+}
+function Ge(i, t) {
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [];
+  return o.tableMode !== "bounded" && o.tableMode !== "server_paginated" && o.tableMode !== "server_windowed" && s.push(`${t}.tableMode must be a supported table mode.`), s.push(
+    ...Ue(o.height, `${t}.height`),
+    ...ze(o.pagination, `${t}.pagination`),
+    ...He(o.sorting, `${t}.sorting`),
+    ...Qe(o.totals, `${t}.totals`)
+  ), typeof o.serverSideRequired != "boolean" && s.push(`${t}.serverSideRequired must be a boolean.`), s;
+}
+function Ue(i, t) {
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [];
+  return (typeof o.maxPx != "number" || !Number.isInteger(o.maxPx) || o.maxPx <= 0) && s.push(`${t}.maxPx must be a positive integer.`), o.scroll !== "vertical" && o.scroll !== "both" && s.push(`${t}.scroll must be vertical or both.`), typeof o.stickyHeader != "boolean" && s.push(`${t}.stickyHeader must be a boolean.`), s;
+}
+function ze(i, t) {
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [];
+  return o.mode !== "none" && o.mode !== "server" && o.mode !== "client_for_bounded_rows" && s.push(`${t}.mode must be a supported pagination mode.`), o.pageSize !== void 0 && (typeof o.pageSize != "number" || !Number.isInteger(o.pageSize) || o.pageSize <= 0) && s.push(`${t}.pageSize must be a positive integer.`), o.readsFrom !== void 0 && o.readsFrom !== "result.pagination" && s.push(`${t}.readsFrom must be result.pagination.`), s;
+}
+function He(i, t) {
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [];
+  return o.mode !== "server" && o.mode !== "client_for_bounded_rows" && s.push(`${t}.mode must be a supported sorting mode.`), o.defaultField !== void 0 && (typeof o.defaultField != "string" || !o.defaultField.trim()) && s.push(`${t}.defaultField must be a non-empty string.`), o.defaultDirection !== void 0 && o.defaultDirection !== "asc" && o.defaultDirection !== "desc" && s.push(`${t}.defaultDirection must be asc or desc.`), o.resetPageOnChange !== void 0 && typeof o.resetPageOnChange != "boolean" && s.push(`${t}.resetPageOnChange must be a boolean.`), s;
+}
+function Qe(i, t) {
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [];
+  return o.mode !== "none" && o.mode !== "server" && o.mode !== "local" ? (s.push(`${t}.mode must be none, server, or local.`), s) : o.mode === "none" ? (o.measures !== void 0 && s.push(`${t}.measures is not allowed when mode is none.`), o.label !== void 0 && s.push(`${t}.label is not allowed when mode is none.`), s) : o.mode === "server" ? (!Array.isArray(o.measures) || o.measures.length === 0 ? s.push(`${t}.measures must include at least one measure when mode is server.`) : o.measures.forEach((r, n) => {
+    var l;
+    s.push(
+      ...ee(
+        r,
+        `${t}.measures.${n}`
+      )
+    ), ((l = a(r)) == null ? void 0 : l.role) !== "measure" && s.push(`${t}.measures.${n}.role must be measure.`);
+  }), o.label !== void 0 && s.push(`${t}.label is not allowed when mode is server.`), s) : (o.mode === "local" && (o.label !== "Displayed rows" && o.label !== "Current page" && s.push(`${t}.label must be Displayed rows or Current page when mode is local.`), o.measures !== void 0 && s.push(`${t}.measures is not allowed when mode is local.`)), s);
+}
+function Ye(i, t) {
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [];
+  switch (o.kind) {
+    case "server_query":
+      $(o.queryKind) || s.push(`${t}.queryKind must be a supported codegen query kind.`), o.queryOwnership !== void 0 && o.queryOwnership !== "view_owned" && o.queryOwnership !== "shared_query" && s.push(
+        `${t}.queryOwnership must be view_owned or shared_query.`
+      ), o.sourceKeys !== void 0 && !g(o.sourceKeys) && s.push(`${t}.sourceKeys must be an array of strings.`), o.fieldNames !== void 0 && !g(o.fieldNames) && s.push(`${t}.fieldNames must be an array of strings.`);
+      break;
+    case "derived":
+      (typeof o.upstreamViewId != "string" || !o.upstreamViewId.trim()) && s.push(`${t}.upstreamViewId is required.`), (typeof o.derivation != "string" || !o.derivation.trim()) && s.push(`${t}.derivation is required.`);
+      break;
+    case "presentation_only":
+      break;
+    case "unsupported":
+      (typeof o.reason != "string" || !o.reason.trim()) && s.push(`${t}.reason is required.`), (typeof o.suggestedModelingFix != "string" || !o.suggestedModelingFix.trim()) && s.push(`${t}.suggestedModelingFix is required.`);
+      break;
+    default:
+      s.push(`${t}.kind must be a supported computation kind.`);
+  }
+  return s;
+}
+function We(i, t) {
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [];
+  for (const n of ["title", "requestedQuestion", "suggestedModelingFix"])
+    (typeof o[n] != "string" || !o[n].trim()) && s.push(`${t}.${n} is required.`);
+  return we.has(o.reason) || s.push(`${t}.reason must be a supported unsupported insight reason.`), (o.relationshipCandidate !== void 0 || o.nextRepairAction !== void 0) && o.reason !== "missing_relationship" && s.push(
+    `${t} relationship repair metadata is only valid for missing_relationship unsupported insights.`
+  ), o.relationshipCandidate !== void 0 && s.push(
+    ...Xe(
+      o.relationshipCandidate,
+      `${t}.relationshipCandidate`
+    )
+  ), o.nextRepairAction !== void 0 && s.push(
+    ...Ze(
+      o.nextRepairAction,
+      `${t}.nextRepairAction`
+    )
+  ), s;
+}
+function Ze(i, t) {
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [], r = /* @__PURE__ */ new Set(["tool", "reason"]);
+  return Object.keys(o).forEach((n) => {
+    r.has(n) || s.push(
+      `${t}.${n} is not supported; repair actions support only tool and reason.`
+    );
+  }), o.tool !== "semaphor_propose_semantic_model_change" && s.push(
+    `${t}.tool must be semaphor_propose_semantic_model_change.`
+  ), o.reason !== "missing_relationship" && s.push(`${t}.reason must be missing_relationship.`), s;
+}
+function Xe(i, t) {
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [], r = /* @__PURE__ */ new Set(["source", "sourceFields", "target", "targetFields"]);
+  Object.keys(o).forEach((n) => {
+    r.has(n) || s.push(
+      `${t}.${n} is not supported; relationship candidates support only source, sourceFields, target, and targetFields.`
+    );
+  }), s.push(
+    ...z(o.source, `${t}.source`)
+  ), s.push(
+    ...z(o.target, `${t}.target`)
+  );
+  for (const n of ["sourceFields", "targetFields"]) {
+    const l = o[n];
+    if (!Array.isArray(l) || l.length === 0) {
+      s.push(`${t}.${n} must be a non-empty endpoint field array.`);
+      continue;
+    }
+    l.forEach((u, p) => {
+      s.push(
+        ...Je(u, `${t}.${n}.${p}`)
+      );
+    });
+  }
+  return s;
+}
+function Je(i, t) {
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [], r = /* @__PURE__ */ new Set(["name", "label", "role", "dataType"]);
+  return Object.keys(o).forEach((n) => {
+    r.has(n) || s.push(
+      `${t}.${n} is not supported; relationship candidate fields are scoped by their endpoint and support only name, label, role, and dataType.`
+    );
+  }), (typeof o.name != "string" || !o.name.trim()) && s.push(`${t}.name must be a non-empty string.`), o.role !== void 0 && (typeof o.role != "string" || !["dimension", "measure", "date", "id", "unknown"].includes(o.role)) && s.push(`${t}.role must be dimension, measure, date, id, or unknown.`), o.dataType !== void 0 && (typeof o.dataType != "string" || !["string", "number", "boolean", "date", "datetime", "unknown"].includes(
+    o.dataType
+  )) && s.push(
+    `${t}.dataType must be string, number, boolean, date, datetime, or unknown.`
+  ), s;
+}
+function z(i, t) {
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [], r = /* @__PURE__ */ new Set([
+    "kind",
+    "domainId",
+    "datasetName",
+    "datasetId",
+    "label",
+    "sourceKey"
+  ]);
+  return Object.keys(o).forEach((n) => {
+    r.has(n) || s.push(
+      `${t}.${n} is not supported; relationship candidate sources support only semantic identity fields.`
+    );
+  }), o.kind !== "semantic" && s.push(`${t} must use semantic source identity.`), (typeof o.domainId != "string" || !o.domainId.trim() || typeof o.datasetName != "string" || !o.datasetName.trim()) && s.push(`${t} must include semantic domainId and datasetName.`), s;
+}
+function $(i) {
+  return ge.has(i);
+}
+function J(i) {
+  return he.has(i);
+}
+function h(i, t) {
+  return i === void 0 ? [] : d(i, t);
+}
+function d(i, t) {
+  const o = a(i);
+  if (!o)
+    return [`${t} must be an object.`];
+  const s = [];
+  return (typeof o.name != "string" || !o.name.trim()) && s.push(`${t}.name is required.`), !o.source && typeof o.sourceKey != "string" && s.push(`${t} must include source or sourceKey.`), s;
+}
+function ee(i, t) {
+  const o = a(i), s = d(i, t);
+  if (!o || typeof o.sourceKey == "string" && o.sourceKey.trim())
+    return s;
+  if (o.source !== void 0) {
+    const n = w(o.source, `${t}.source`);
+    return n.length === 0 || s.push(...n), s;
+  }
+  return s.includes(`${t} must include source or sourceKey.`) || s.push(`${t} must include source or sourceKey.`), s;
+}
+function a(i) {
+  return i && typeof i == "object" && !Array.isArray(i) ? i : void 0;
+}
+function g(i) {
+  return Array.isArray(i) && i.every((t) => typeof t == "string");
+}
+const m = e.record(e.string(), e.unknown()), R = e.array(m), c = e.enum([
+  "SUM",
+  "COUNT",
+  "AVG",
+  "MIN",
+  "MAX",
+  "MEDIAN",
+  "DISTINCT"
+]), C = e.enum([
+  "postgres",
+  "mysql",
+  "mssql",
+  "snowflake",
+  "clickhouse",
+  "bigquery",
+  "redshift",
+  "duckdb",
+  "sqlite",
+  "unknown"
+]), oe = e.enum([
+  "hour",
+  "day",
+  "week",
+  "month",
+  "quarter",
+  "year"
+]), q = e.enum([
+  "dimension",
+  "measure",
+  "date",
+  "id",
+  "unknown"
+]), x = e.enum([
+  "string",
+  "number",
+  "boolean",
+  "date",
+  "datetime",
+  "unknown"
+]), te = e.enum([
+  "semantic_model",
+  "caller_override",
+  "default_sum"
+]), j = e.union([e.number(), e.string(), e.null()]), D = e.enum([
+  "millisecond",
+  "second",
+  "minute",
+  "hour",
+  "day"
+]), se = e.union([
+  e.object({
+    type: e.enum(["number", "currency", "percent", "percentage", "scientific"]),
+    locale: e.string().optional(),
+    minimumFractionDigits: e.number().optional(),
+    maximumFractionDigits: e.number().optional(),
+    useGrouping: e.boolean().optional(),
+    prefix: e.string().optional(),
+    suffix: e.string().optional(),
+    negativeStyle: e.enum(["minus", "parentheses"]).optional(),
+    compact: e.boolean().optional(),
+    scale: e.number().optional(),
+    currency: e.string().optional(),
+    percentValueMode: e.enum(["fraction", "whole"]).optional()
+  }).passthrough(),
+  e.object({
+    type: e.enum(["date", "datetime"]),
+    locale: e.string().optional(),
+    pattern: e.string().optional(),
+    relative: e.boolean().optional(),
+    timezone: e.string().optional(),
+    sourceTimezone: e.string().optional(),
+    prefix: e.string().optional(),
+    suffix: e.string().optional()
+  }).passthrough(),
+  e.object({
+    type: e.literal("duration"),
+    inputUnit: D.optional(),
+    outputStyle: e.enum(["compact", "digital", "long"]).optional(),
+    largestUnit: D.optional(),
+    smallestUnit: D.optional(),
+    maxUnits: e.number().optional(),
+    prefix: e.string().optional(),
+    suffix: e.string().optional(),
+    negativeStyle: e.enum(["minus", "parentheses"]).optional()
+  }).passthrough(),
+  e.object({
+    type: e.literal("string"),
+    prefix: e.string().optional(),
+    suffix: e.string().optional()
+  }).passthrough()
+]), eo = e.union([
+  e.object({ kind: e.literal("defaultAggregate") }).passthrough(),
+  e.object({ kind: e.literal("blank") }).passthrough(),
+  e.object({
+    kind: e.literal("labelOnly"),
+    label: e.string().optional()
+  }).passthrough(),
+  e.object({
+    kind: e.literal("customAggregate"),
+    aggregate: c
+  }).passthrough(),
+  e.object({ kind: e.literal("percentOfParent") }).passthrough(),
+  e.object({ kind: e.literal("percentOfGrandTotal") }).passthrough(),
+  e.object({
+    kind: e.literal("customExpression"),
+    expressionId: e.string()
+  }).passthrough()
+]);
+function k(i, t) {
+  return e.object(i).passthrough().superRefine((o, s) => {
+    for (const r of t)
+      Object.prototype.hasOwnProperty.call(o, r) || s.addIssue({
+        code: "custom",
+        path: [r],
+        message: `Required field "${r}" is missing.`
+      });
+  });
+}
+const ie = e.object({
+  kind: e.literal("semantic"),
+  domainId: e.string(),
+  datasetName: e.string(),
+  datasetId: e.string().optional(),
+  label: e.string().optional(),
+  connectionId: e.string().optional()
+}).passthrough(), oo = e.object({
+  kind: e.literal("physical"),
+  connectionId: e.string(),
+  connectionType: e.string().optional(),
+  tableName: e.string(),
+  databaseName: e.string().optional(),
+  schemaName: e.string().optional(),
+  label: e.string().optional(),
+  dialect: C.optional()
+}).passthrough(), to = e.object({
+  kind: e.literal("sql"),
+  connectionId: e.string(),
+  dialect: C.optional(),
+  label: e.string().optional()
+}).passthrough(), S = e.union([
+  ie,
+  oo,
+  to
+]), y = e.object({
+  name: e.string(),
+  label: e.string().optional(),
+  role: q.optional(),
+  dataType: x.optional(),
+  source: S.optional(),
+  aggregate: c.optional()
+}).passthrough(), so = e.object({
+  kind: e.literal("field"),
+  field: y,
+  aggregate: c.optional()
+}).passthrough(), re = e.object({
+  kind: e.literal("derived_field"),
+  name: e.string(),
+  label: e.string(),
+  description: e.string().optional(),
+  resultRole: q,
+  dataType: x,
+  computeStage: e.enum(["row", "aggregate"]),
+  expression: e.string(),
+  expressionLanguage: e.literal("semaphor_sql_template").optional(),
+  inputs: e.record(so),
+  defaultAggregate: c.optional(),
+  aggregationBehavior: e.enum([
+    "additive",
+    "non_additive",
+    "ratio_of_sums",
+    "weighted",
+    "pre_aggregated",
+    "snapshot"
+  ]).optional(),
+  aggregationStrategy: e.enum([
+    "default",
+    "symmetric_aggregate",
+    "aggregate_then_join",
+    "weighted"
+  ]).optional(),
+  format: se.optional(),
+  tags: e.array(e.string()).optional()
+}).passthrough(), P = y.and(
+  e.object({
+    semanticAggregate: c.optional(),
+    effectiveAggregate: c.optional(),
+    aggregateSource: te.optional(),
+    derivedField: re.optional()
+  }).passthrough()
+), io = ie, ro = e.object({
+  kind: e.literal("physical"),
+  connectionId: e.string().optional(),
+  connectionType: e.string().optional(),
+  tableName: e.string(),
+  databaseName: e.string().optional(),
+  schemaName: e.string().optional(),
+  label: e.string().optional(),
+  dialect: C.optional()
+}).passthrough(), no = e.object({
+  kind: e.literal("sql"),
+  connectionId: e.string().optional(),
+  dialect: C.optional(),
+  label: e.string().optional()
+}).passthrough(), ao = e.union([
+  io,
+  ro,
+  no
+]), lo = e.object({
+  key: e.string().optional(),
+  name: e.string(),
+  label: e.string().optional(),
+  role: q.optional(),
+  dataType: x.optional(),
+  source: ao.optional(),
+  aggregate: c.optional(),
+  semanticAggregate: c.optional(),
+  effectiveAggregate: c.optional(),
+  aggregateSource: te.optional(),
+  derivedField: e.never().optional()
+}).passthrough(), O = e.object({
+  key: e.string(),
+  name: e.string(),
+  label: e.string(),
+  role: q.optional(),
+  dataType: x.optional(),
+  aggregate: c.optional(),
+  source: S.optional(),
+  derivedField: re.optional()
+}).passthrough(), ne = e.object({
+  code: e.string(),
+  message: e.string().optional(),
+  invalidField: e.string().optional(),
+  fieldRole: e.enum(["measure", "date", "dimension", "input", "source", "sql"]).optional(),
+  validMeasureCandidates: e.array(e.string()).optional(),
+  validDateCandidates: e.array(e.string()).optional(),
+  validDimensionCandidates: e.array(e.string()).optional(),
+  recommendedNextStep: e.string()
+}).passthrough(), K = e.object({
+  code: e.string(),
+  message: e.string(),
+  path: e.string().optional(),
+  fieldRole: e.enum(["measure", "date", "dimension", "input", "source", "sql"]).optional(),
+  repairHint: ne.optional()
+}).passthrough(), ae = e.object({
+  ok: e.boolean(),
+  errors: e.array(K),
+  warnings: e.array(K),
+  repairHints: e.array(ne)
+}).passthrough(), uo = e.object({
+  page: e.number(),
+  pageSize: e.number(),
+  pageCount: e.number(),
+  totalCount: e.number(),
+  hasNextPage: e.boolean(),
+  hasPrevPage: e.boolean()
+}).passthrough(), A = {
+  intentId: e.string().optional(),
+  queryPath: e.enum(["query_spec", "sql", "sql_python"]),
+  warnings: e.array(e.string()).optional(),
+  rowCount: e.number().optional(),
+  rowLimitExceeded: e.boolean().optional(),
+  limit: e.number().optional(),
+  pagination: uo.optional()
+}, co = e.object({
+  ...A,
+  kind: e.literal("metric"),
+  value: j,
+  measures: e.record(j).optional(),
+  comparison: e.object({
+    kind: e.enum(["previous_period", "previous_year", "target"]),
+    value: j.optional(),
+    delta: e.union([e.number(), e.null()]).optional(),
+    deltaPercent: e.union([e.number(), e.null()]).optional()
+  }).passthrough().optional(),
+  records: R.optional()
+}).passthrough(), po = e.object({
+  ...A,
+  kind: e.literal("records"),
+  columns: e.array(O),
+  records: R,
+  totals: e.object({
+    mode: e.literal("server"),
+    scope: e.literal("filtered_result"),
+    row: e.record(e.string(), e.unknown()),
+    columns: e.array(O).optional()
+  }).passthrough().optional()
+}).passthrough(), mo = e.object({
+  ...A,
+  kind: e.literal("inputOptions"),
+  options: e.array(
+    k(
+      {
+        label: e.string(),
+        value: e.unknown(),
+        count: e.number().optional(),
+        disambiguation: e.array(e.string()).optional()
+      },
+      ["value"]
+    )
+  )
+}).passthrough(), go = e.object({
+  ...A,
+  kind: e.literal("sql"),
+  columns: e.array(O),
+  records: R,
+  sqlShape: e.object({
+    statementType: e.string().optional(),
+    explicitLimit: e.number().optional(),
+    hasPythonCode: e.boolean().optional()
+  }).passthrough().optional()
+}).passthrough(), ho = e.object({
+  enabled: e.boolean().optional(),
+  position: e.enum(["before", "after"]).optional(),
+  label: e.string().optional()
+}).passthrough(), H = e.object({
+  id: e.enum(["rows", "columns"]),
+  levels: e.array(
+    e.object({
+      instanceId: e.string(),
+      fieldKey: e.string(),
+      label: e.string(),
+      field: y,
+      grain: oe.optional(),
+      subtotal: ho.optional()
+    }).passthrough()
+  ),
+  nodeIds: e.array(e.string())
+}).passthrough(), b = k(
+  {
+    instanceId: e.string(),
+    fieldKey: e.string(),
+    value: e.unknown(),
+    label: e.string()
+  },
+  ["value"]
+), fo = e.union([
+  e.object({ kind: e.literal("label") }).passthrough(),
+  e.object({
+    kind: e.literal("field"),
+    field: y,
+    aggregate: c.optional()
+  }).passthrough(),
+  e.object({
+    kind: e.literal("value"),
+    valueId: e.string(),
+    rowPath: e.array(b).optional(),
+    columnPath: e.array(b).optional()
+  }).passthrough()
+]), bo = e.enum([
+  "present",
+  "presentNull",
+  "missing",
+  "densified"
+]), yo = e.enum([
+  "value",
+  "rowSubtotal",
+  "columnSubtotal",
+  "subtotalIntersection",
+  "rowGrandTotal",
+  "columnGrandTotal",
+  "matrixGrandTotal"
+]), vo = e.object({
+  instanceId: e.string(),
+  fieldKey: e.string(),
+  field: y,
+  role: e.enum(["row", "column", "measure", "sort", "filter"]),
+  label: e.string().optional()
+}).passthrough(), $o = e.union([
+  e.object({
+    kind: e.literal("additive"),
+    aggregate: c.optional()
+  }).passthrough(),
+  e.object({
+    kind: e.literal("semiAdditive"),
+    aggregate: c.optional(),
+    grain: oe.optional()
+  }).passthrough(),
+  e.object({
+    kind: e.literal("nonAdditive"),
+    aggregate: c.optional()
+  }).passthrough(),
+  e.object({
+    kind: e.literal("ratio"),
+    numeratorMeasureInstanceId: e.string().optional(),
+    denominatorMeasureInstanceId: e.string().optional()
+  }).passthrough(),
+  e.object({
+    kind: e.literal("custom"),
+    expressionId: e.string().optional()
+  }).passthrough()
+]), So = e.object({
+  instanceId: e.string(),
+  fieldKey: e.string(),
+  label: e.string(),
+  field: y,
+  aggregate: c.optional(),
+  format: se.optional(),
+  totalBehavior: eo.optional(),
+  semantics: $o
+}).passthrough(), wo = e.object({
+  id: e.string(),
+  measureId: e.string(),
+  aggregate: c.optional(),
+  label: e.string().optional(),
+  source: e.enum([
+    "measureDefault",
+    "rowSubtotal",
+    "columnSubtotal",
+    "subtotalIntersection",
+    "rowGrandTotal",
+    "columnGrandTotal",
+    "matrixGrandTotal",
+    "custom"
+  ]),
+  scope: e.object({
+    rowLevelId: e.string().optional(),
+    columnLevelId: e.string().optional(),
+    rowNodeId: e.string().optional(),
+    columnNodeId: e.string().optional()
+  }).passthrough().optional()
+}).passthrough(), ko = e.object({
+  kind: e.string(),
+  label: e.string().optional(),
+  payload: e.record(e.string(), e.unknown()).optional()
+}).passthrough(), Ao = k(
+  {
+    id: e.string(),
+    axis: e.enum(["row", "column"]),
+    path: e.array(b),
+    level: e.number(),
+    label: e.string(),
+    value: e.unknown(),
+    parentId: e.string().optional(),
+    hasChildren: e.boolean(),
+    isExpanded: e.boolean().optional(),
+    isSubtotal: e.boolean().optional(),
+    isGrandTotal: e.boolean().optional(),
+    subtotalFunction: c.optional(),
+    childCount: e.number().optional(),
+    actions: e.array(ko).optional()
+  },
+  ["value"]
+), Io = e.object({
+  rowHeaderLevels: e.array(
+    e.object({
+      id: e.string(),
+      label: e.string(),
+      fieldInstanceId: e.string()
+    }).passthrough()
+  ),
+  columnHeaderRows: e.array(
+    e.object({
+      id: e.string(),
+      cells: e.array(
+        e.object({
+          id: e.string(),
+          label: e.string(),
+          role: e.enum([
+            "rowHeader",
+            "columnHeader",
+            "measureHeader",
+            "subtotal",
+            "grandTotal"
+          ]),
+          colSpan: e.number(),
+          rowSpan: e.number(),
+          columnPath: e.array(b),
+          measureInstanceId: e.string().optional()
+        }).passthrough()
+      )
+    }).passthrough()
+  ),
+  columns: e.array(
+    e.object({
+      id: e.string(),
+      label: e.string(),
+      columnNodeId: e.string().optional(),
+      columnPath: e.array(b),
+      measureInstanceId: e.string(),
+      role: e.enum(["value", "columnSubtotal", "columnGrandTotal"])
+    }).passthrough()
+  )
+}).passthrough(), _o = k(
+  {
+    rowId: e.string(),
+    columnId: e.string().optional(),
+    measureId: e.string(),
+    value: e.unknown(),
+    formattedValue: e.string().optional(),
+    presence: bo,
+    role: yo,
+    calculationId: e.string().optional()
+  },
+  ["value"]
+), jo = e.object({
+  rows: e.boolean().optional(),
+  columns: e.boolean().optional(),
+  grandTotal: e.union([
+    e.boolean(),
+    e.object({
+      rows: e.boolean().optional(),
+      columns: e.boolean().optional()
+    }).passthrough()
+  ]).optional()
+}).passthrough(), Ro = k(
+  {
+    id: e.string(),
+    axis: e.enum(["row", "column"]),
+    targetInstanceId: e.string().optional(),
+    direction: e.enum(["asc", "desc"]),
+    nulls: e.enum(["warehouseDefault", "first", "last"]).optional(),
+    scope: e.enum(["global", "withinParent"]).optional(),
+    by: fo
+  },
+  ["by"]
+), Co = e.object({
+  rowOffset: e.number().optional(),
+  rowLimit: e.number().optional(),
+  columnOffset: e.number().optional(),
+  columnLimit: e.number().optional(),
+  hasMoreRows: e.boolean().optional(),
+  hasMoreColumns: e.boolean().optional()
+}).passthrough(), qo = e.object({
+  axis: e.enum(["row", "column"]),
+  path: e.array(b),
+  depth: e.number().optional()
+}).passthrough(), xo = e.object({
+  rowLazyLoading: e.boolean().optional(),
+  columnLazyLoading: e.boolean().optional(),
+  expandableRowNodeIds: e.array(e.string()).optional(),
+  expandableColumnNodeIds: e.array(e.string()).optional(),
+  nextRequests: e.array(qo).optional()
+}).passthrough(), Eo = e.object({
+  domains: e.record(
+    e.object({
+      min: e.number().optional(),
+      max: e.number().optional()
+    }).passthrough()
+  ).optional(),
+  rules: e.array(e.record(e.string(), e.unknown())).optional()
+}).passthrough(), Fo = e.object({
+  ...A,
+  kind: e.literal("matrix"),
+  schemaVersion: e.literal(1),
+  shape: e.enum(["hierarchical", "pivot"]),
+  capabilities: e.array(e.string()),
+  executionMetadata: e.record(e.string(), e.unknown()),
+  fieldsById: e.record(e.string(), vo),
+  measuresById: e.record(e.string(), So),
+  calculationsById: e.record(e.string(), wo).optional(),
+  axes: e.object({
+    rows: H,
+    columns: H
+  }).passthrough(),
+  nodesById: e.record(e.string(), Ao),
+  layout: Io,
+  cells: e.array(_o),
+  totals: jo,
+  sort: e.array(Ro),
+  formattingContext: Eo,
+  pageInfo: Co.optional(),
+  expansion: xo.optional()
+}).passthrough(), To = e.union([
+  co,
+  po,
+  mo,
+  go,
+  Fo
+]), Do = e.object({
+  status: e.enum([
+    "not_required",
+    "resolved",
+    "missing",
+    "ambiguous",
+    "fanout_risk",
+    "unknown"
+  ]),
+  requiredSources: e.array(S).optional(),
+  relationshipsUsed: e.array(e.string()).optional(),
+  missingSources: e.array(e.string()).optional(),
+  warnings: e.array(e.string()).optional(),
+  message: e.string().optional(),
+  recommendedNextStep: e.string().optional(),
+  joinPlanSummary: e.object({
+    baseSource: S.optional(),
+    joinedSources: e.array(S).optional(),
+    joinCount: e.number().optional()
+  }).passthrough().optional(),
+  fanoutRisk: e.object({
+    status: e.enum(["none", "warning", "error", "unknown"]),
+    message: e.string().optional()
+  }).passthrough().optional()
+}).passthrough(), Q = e.enum([
+  "ambiguous_fields",
+  "empty_result",
+  "missing_grounded_fields",
+  "missing_relationship",
+  "no_grounded_query",
+  "partial_result",
+  "presentation_incomplete",
+  "query_validation_failed",
+  "unsafe_join"
+]), le = e.object({
+  version: e.literal(1),
+  status: e.enum(["answered", "partial", "blocked"]),
+  summary: e.string(),
+  answered: e.array(
+    e.object({
+      slotId: e.string().optional(),
+      queryId: e.string().optional(),
+      summary: e.string(),
+      evidenceIds: e.array(e.string()).optional(),
+      fieldsUsed: e.array(P).optional()
+    }).passthrough()
+  ),
+  blocked: e.array(
+    e.object({
+      slotId: e.string().optional(),
+      queryId: e.string().optional(),
+      reasonCode: Q,
+      message: e.string(),
+      missingFields: e.array(e.string()).optional(),
+      availableFields: e.array(e.string()).optional(),
+      ambiguousFields: e.array(e.string()).optional(),
+      missingRelationships: e.array(e.string()).optional(),
+      evidenceIds: e.array(e.string()).optional(),
+      neededFromUser: e.array(e.string()).optional(),
+      recommendedNextStep: e.string().optional()
+    }).passthrough()
+  ),
+  semanticModelRecommendations: e.array(
+    e.object({
+      reasonCode: Q,
+      message: e.string(),
+      recommendedNextStep: e.string().optional()
+    }).passthrough()
+  ).optional()
+}).passthrough(), ue = e.object({
+  scope: e.literal("filtered_query"),
+  measures: e.record(j)
+}).passthrough(), ce = e.object({
+  answeredObligations: e.array(e.string()),
+  missingObligations: e.array(e.string()),
+  warnings: e.array(K).optional()
+}).passthrough(), No = e.object({
+  intentId: e.string().optional(),
+  queryId: e.string().optional(),
+  status: e.enum(["answered", "partial", "failed"]),
+  resultShape: e.enum([
+    "metric",
+    "records",
+    "inputOptions",
+    "sql",
+    "matrix",
+    "period_change",
+    "analysis"
+  ]).optional(),
+  intent: e.unknown().optional(),
+  compiledQuery: e.unknown().optional(),
+  fieldsUsed: e.array(P).optional(),
+  result: To.optional(),
+  validation: ae,
+  coverage: ce.optional(),
+  missingFields: e.array(e.string()).optional(),
+  warnings: e.array(e.string()).optional(),
+  relationshipDiagnostics: Do.optional(),
+  diagnosticFeedback: le.optional(),
+  population: ue.optional(),
+  metadata: e.record(e.string(), e.unknown()).optional()
+}).passthrough();
+function Oo(i) {
+  switch (i) {
+    case "boolean":
+      return e.boolean().optional();
+    case "compactExecutionFieldArray":
+      return e.array(lo).optional();
+    case "coverage":
+      return ce.optional();
+    case "diagnosticFeedback":
+      return le.optional();
+    case "executionFieldArray":
+      return e.array(P).optional();
+    case "executionResult":
+      return No.optional();
+    case "number":
+      return e.number().finite().optional();
+    case "population":
+      return ue.optional();
+    case "record":
+      return m.optional();
+    case "recordArray":
+      return R.optional();
+    case "responseDetail":
+      return e.enum(["compact", "standard", "debug"]).optional();
+    case "string":
+      return e.string().optional();
+    case "stringArray":
+      return e.array(e.string()).optional();
+    case "unknown":
+      return e.unknown().optional();
+    case "unknownArray":
+      return e.array(e.unknown()).optional();
+    case "validationResult":
+      return ae.optional();
+  }
+}
+const Ko = Object.fromEntries(
+  Object.entries(M).map(
+    ([i, t]) => [i, Oo(t)]
+  )
+), Mo = e.object(Ko).strict(), V = e.object({
+  sourceKey: e.string().optional(),
+  kind: e.enum(["semantic", "physical", "sql"]).optional(),
+  domainId: e.string().optional(),
+  datasetName: e.string().optional(),
+  datasetId: e.string().optional(),
+  connectionId: e.string().optional(),
+  tableName: e.string().optional(),
+  label: e.string().optional()
+}).passthrough(), f = e.object({
+  name: e.string(),
+  label: e.string().optional(),
+  role: e.enum(["dimension", "measure", "date", "id", "unknown"]).optional(),
+  dataType: e.enum(["string", "number", "boolean", "date", "datetime", "unknown"]).optional(),
+  aggregate: c.optional(),
+  sourceKey: e.string().optional(),
+  source: V.optional()
+}).passthrough(), de = e.object({
+  id: e.string().optional(),
+  builder: e.literal("semaphor.inputOptions"),
+  source: V.optional(),
+  sourceKey: e.string().optional(),
+  valueFieldRef: f,
+  labelFieldRef: f,
+  filterFieldRef: f.optional(),
+  population: e.unknown().optional(),
+  dependencies: e.unknown().optional(),
+  limit: e.number().int().positive().optional(),
+  spec: m.optional()
+}).passthrough(), pe = e.object({
+  appliesToViewIds: e.array(e.string()).optional(),
+  viewId: e.string().optional(),
+  fieldRef: f,
+  relationshipHint: e.unknown().optional(),
+  relationshipsUsed: e.array(m).optional()
+}).passthrough(), Bo = e.object({
+  id: e.string(),
+  label: e.string().optional(),
+  type: e.string().optional(),
+  serverSide: e.boolean().optional(),
+  fieldRef: f.optional(),
+  optionQuery: de.optional(),
+  bindings: e.array(pe).optional(),
+  appliesToViewIds: e.array(e.string()),
+  relationshipHint: e.unknown().optional(),
+  relationshipsUsed: e.array(m).optional()
+}).passthrough(), Po = e.object({
+  builder: e.enum([
+    "semaphor.metric",
+    "semaphor.records",
+    "semaphor.matrix",
+    "semaphor.analysis",
+    "semaphor.sql"
+  ]),
+  spec: m,
+  fallbackReason: m.optional()
+}).passthrough(), Vo = e.object({
+  id: e.string(),
+  title: e.string().optional(),
+  purpose: e.string().optional(),
+  sourcePresentation: e.object({
+    sourceKeys: e.array(e.string()).optional(),
+    sourceLabels: e.array(e.string()).optional()
+  }).passthrough().optional(),
+  visual: e.string().optional(),
+  visualSpec: m.optional(),
+  queryKind: e.enum(["metric", "records", "matrix", "analysis", "sql_fallback"]).optional(),
+  sdkBuilder: e.enum([
+    "semaphor.metric",
+    "semaphor.records",
+    "semaphor.matrix",
+    "semaphor.analysis",
+    "semaphor.sql"
+  ]).optional(),
+  sdkSpec: Po.optional(),
+  fields: e.array(f).optional(),
+  computation: m.optional(),
+  uxExpectations: e.array(e.string()).optional(),
+  validation: m.optional()
+}).passthrough(), Lo = e.object({
+  inputId: e.string(),
+  label: e.string().optional(),
+  type: e.string().optional(),
+  serverSide: e.boolean().optional(),
+  fieldRef: f.optional(),
+  optionQuery: de.optional(),
+  bindings: e.array(pe),
+  appliesToViewIds: e.array(e.string()),
+  notAppliedToViewIds: e.array(e.string())
+}).passthrough(), Yo = e.object({
+  schemaVersion: e.literal(N),
+  title: e.string(),
+  purpose: e.string().optional(),
+  userGoal: e.string().optional(),
+  nextStep: e.string().optional(),
+  sources: e.array(V),
+  inputs: e.array(Bo),
+  views: e.array(Vo),
+  filterContracts: e.array(Lo),
+  implementationChecklist: e.object({
+    schemaVersion: e.string().optional(),
+    requiredDevtools: e.object({
+      mountRootDevtools: e.boolean(),
+      providerDebugBridge: e.string().optional(),
+      panelPosition: e.string().optional(),
+      forbidden: e.array(e.string()).optional()
+    }).passthrough(),
+    requiredInputOptions: e.array(m),
+    filterScopeByInput: e.array(m),
+    bindingsByView: e.record(e.string(), e.array(m)),
+    validationCommands: e.array(e.string()),
+    browserSmokeChecks: e.array(e.string())
+  }).passthrough(),
+  nextRequiredTool: e.object({
+    name: e.string(),
+    reason: e.string().optional()
+  }).optional(),
+  unsupportedInsights: e.array(
+    e.object({
+      title: e.string(),
+      requestedQuestion: e.string(),
+      reason: e.string(),
+      suggestedModelingFix: e.string()
+    }).passthrough()
+  ).optional(),
+  assumptions: e.array(e.string()).optional(),
+  validation: m.optional()
+}).passthrough().superRefine((i, t) => {
+  const o = W(i);
+  for (const s of o.issues)
+    t.addIssue({
+      code: e.ZodIssueCode.custom,
+      message: s
+    });
+}), Go = new Set(
+  Object.keys(M)
+);
+function Wo() {
+  return Object.keys(
+    M
+  );
+}
+function Uo(i) {
+  return Go.has(i);
+}
+function Zo(i) {
+  if (!i || typeof i != "object" || Array.isArray(i))
+    throw new Error("Semaphor analyze result must be an object.");
+  const o = Object.keys(i).filter(
+    (s) => !Uo(s)
+  );
+  if (o.length)
+    throw new Error(
+      `Semaphor analyze result contains unsupported top-level field(s): ${o.join(", ")}.`
+    );
+  return Mo.parse(i);
+}
+export {
+  ce as A,
+  No as B,
+  Ko as C,
+  Mo as D,
+  Yo as E,
+  M as S,
+  N as a,
+  Ho as b,
+  Qo as c,
+  oo as d,
+  to as e,
+  S as f,
+  Wo as g,
+  y as h,
+  Uo as i,
+  re as j,
+  P as k,
+  O as l,
+  K as m,
+  ae as n,
+  co as o,
+  Zo as p,
+  po as q,
+  mo as r,
+  ie as s,
+  go as t,
+  Fo as u,
+  W as v,
+  To as w,
+  Do as x,
+  le as y,
+  ue as z
+};