react-semaphor 0.1.391 → 0.1.392

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

@@ -0,0 +1,1585 @@
+import { z as e } from "zod";
+const P = {
+  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"
+}, O = "semaphor-data-app-codegen-summary/v1", xt = "semaphor-data-app-codegen-summary-validator/v2", le = /* @__PURE__ */ new Set([
+  "metric",
+  "records",
+  "matrix",
+  "analysis",
+  "sql_fallback"
+]), ue = /* @__PURE__ */ new Set([
+  "semaphor.metric",
+  "semaphor.records",
+  "semaphor.matrix",
+  "semaphor.analysis",
+  "semaphor.sql"
+]), ce = /* @__PURE__ */ new Set([
+  "absolute_delta",
+  "largest_negative",
+  "largest_positive",
+  "positive_and_negative",
+  "all"
+]), G = /* @__PURE__ */ new Set([
+  "source",
+  "id",
+  "label",
+  "measures",
+  "primaryMeasure",
+  "dateField",
+  "timeGrain",
+  "dimensions",
+  "comparison",
+  "orderBy",
+  "filters",
+  "relationshipHint",
+  "limit",
+  "derivedFields"
+]), de = /* @__PURE__ */ new Set([
+  ...G,
+  "analysis",
+  "timeWindow",
+  "filters",
+  "driverMode",
+  "includePopulation",
+  "calendarContext",
+  "chartTitle",
+  "chartType"
+]), pe = /* @__PURE__ */ new Set([
+  "source",
+  "id",
+  "label",
+  "fields",
+  "dateField",
+  "timeGrain",
+  "timeWindow",
+  "filters",
+  "orderBy",
+  "relationshipHint",
+  "limit",
+  "pagination",
+  "derivedFields"
+]), me = /* @__PURE__ */ new Set([
+  "source",
+  "id",
+  "label",
+  "filters",
+  "relationshipHint",
+  "rows",
+  "columns",
+  "values",
+  "totals",
+  "sort",
+  "expansion",
+  "layout",
+  "displayLimits"
+]), ge = /* @__PURE__ */ new Set([
+  "source",
+  "id",
+  "label",
+  "sql",
+  "defaultParameters",
+  "pythonCode",
+  "fields",
+  "limit",
+  "pagination",
+  "rationale"
+]), he = /* @__PURE__ */ new Set([
+  "kpi",
+  "line_chart",
+  "bar_chart",
+  "stacked_bar_chart",
+  "pie_chart",
+  "donut_chart",
+  "area_chart",
+  "table",
+  "matrix",
+  "narrative",
+  "text_block",
+  "custom"
+]), be = /* @__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 Et(r) {
+  return U(r).ok;
+}
+function U(r) {
+  const o = [];
+  if (!r || typeof r != "object")
+    return { ok: !1, issues: ["Summary must be an object."] };
+  const t = r;
+  return t.schemaVersion !== O && o.push(
+    `schemaVersion must be ${O}.`
+  ), (typeof t.title != "string" || !t.title.trim()) && o.push("title is required."), Array.isArray(t.sources) || o.push("sources must be an array."), Array.isArray(t.inputs) || o.push("inputs must be an array."), Array.isArray(t.views) || o.push("views must be an array."), Array.isArray(t.filterContracts) || o.push("filterContracts must be an array."), (!t.implementationChecklist || typeof t.implementationChecklist != "object") && o.push("implementationChecklist must be an object."), t.implementationChecklist && typeof t.implementationChecklist == "object" && o.push(
+    ...fe(t.implementationChecklist)
+  ), Array.isArray(t.sources) && t.sources.forEach((i, s) => {
+    o.push(..._(i, `sources.${s}`));
+  }), Array.isArray(t.inputs) && t.inputs.forEach((i, s) => {
+    o.push(...ye(i, `inputs.${s}`));
+  }), Array.isArray(t.views) && t.views.forEach((i, s) => {
+    o.push(...Se(i, `views.${s}`));
+  }), Array.isArray(t.filterContracts) && t.filterContracts.forEach((i, s) => {
+    o.push(
+      ...ve(i, `filterContracts.${s}`)
+    );
+  }), t.unsupportedInsights !== void 0 && (Array.isArray(t.unsupportedInsights) ? t.unsupportedInsights.forEach((i, s) => {
+    o.push(
+      ...Pe(
+        i,
+        `unsupportedInsights.${s}`
+      )
+    );
+  }) : o.push("unsupportedInsights must be an array.")), { ok: o.length === 0, issues: o };
+}
+function _(r, o) {
+  const t = n(r);
+  return t ? t.kind === "semantic" ? typeof t.domainId == "string" && t.domainId.trim() && typeof t.datasetName == "string" && t.datasetName.trim() ? [] : [`${o} must include sourceKey or a supported source identity.`] : typeof t.sourceKey == "string" && t.sourceKey.trim() ? [] : t.kind === "physical" && typeof t.tableName == "string" && t.tableName.trim() && typeof t.connectionId == "string" && t.connectionId.trim() ? [] : t.kind === "sql" && typeof t.connectionId == "string" && t.connectionId.trim() ? [] : [`${o} must include sourceKey or a supported source identity.`] : [`${o} must be an object.`];
+}
+function fe(r) {
+  const o = n(r);
+  if (!o)
+    return ["implementationChecklist must be an object."];
+  const t = [], i = [
+    "requiredDevtools",
+    "requiredInputOptions",
+    "filterScopeByInput",
+    "bindingsByView",
+    "validationCommands",
+    "browserSmokeChecks"
+  ];
+  for (const a of i)
+    a in o || t.push(`implementationChecklist.${a} is required.`);
+  const s = n(o.requiredDevtools);
+  return s ? typeof s.mountRootDevtools != "boolean" && t.push(
+    "implementationChecklist.requiredDevtools.mountRootDevtools must be a boolean."
+  ) : t.push("implementationChecklist.requiredDevtools must be an object."), Array.isArray(o.requiredInputOptions) || t.push(
+    "implementationChecklist.requiredInputOptions must be an array."
+  ), Array.isArray(o.filterScopeByInput) || t.push("implementationChecklist.filterScopeByInput must be an array."), n(o.bindingsByView) || t.push("implementationChecklist.bindingsByView must be an object."), d(o.validationCommands) || t.push(
+    "implementationChecklist.validationCommands must be an array of strings."
+  ), d(o.browserSmokeChecks) || t.push(
+    "implementationChecklist.browserSmokeChecks must be an array of strings."
+  ), t;
+}
+function ye(r, o) {
+  const t = n(r);
+  if (!t)
+    return [`${o} must be an object.`];
+  const i = [];
+  return (typeof t.id != "string" || !t.id.trim()) && i.push(`${o}.id is required.`), t.fieldRef && i.push(...u(t.fieldRef, `${o}.fieldRef`)), i.push(...z(t.optionQuery, `${o}.optionQuery`)), d(t.appliesToViewIds) || i.push(`${o}.appliesToViewIds must be an array of strings.`), t.bindings !== void 0 && !Array.isArray(t.bindings) && i.push(`${o}.bindings must be an array.`), Array.isArray(t.bindings) && t.bindings.forEach((s, a) => {
+    const p = n(s);
+    if (!p) {
+      i.push(`${o}.bindings.${a} must be an object.`);
+      return;
+    }
+    d(p.appliesToViewIds) || i.push(
+      `${o}.bindings.${a}.appliesToViewIds must be an array of strings.`
+    ), i.push(
+      ...u(
+        p.fieldRef,
+        `${o}.bindings.${a}.fieldRef`
+      )
+    );
+  }), i;
+}
+function Se(r, o) {
+  const t = n(r);
+  if (!t)
+    return [`${o} must be an object.`];
+  const i = [];
+  if ((typeof t.id != "string" || !t.id.trim()) && i.push(`${o}.id is required.`), t.visualSpec !== void 0 && i.push(...xe(t.visualSpec, `${o}.visualSpec`)), t.computation !== void 0 && i.push(...Ne(t.computation, `${o}.computation`)), qe(t))
+    return t.fields !== void 0 && (Array.isArray(t.fields) ? t.fields.forEach((a, p) => {
+      i.push(...u(a, `${o}.fields.${p}`));
+    }) : i.push(`${o}.fields must be an array.`)), t.queryKind !== void 0 && i.push(`${o}.queryKind is not allowed for non-executable views.`), t.sdkBuilder !== void 0 && i.push(`${o}.sdkBuilder is not allowed for non-executable views.`), t.sdkSpec !== void 0 && i.push(`${o}.sdkSpec is not allowed for non-executable views.`), i;
+  if (!Array.isArray(t.fields))
+    return i.push(`${o}.fields must be an array.`), (t.sdkSpec !== void 0 || t.sdkBuilder !== void 0) && i.push(`${o}.fields must be an array for executable views.`), i;
+  t.fields.forEach((a, p) => {
+    i.push(...u(a, `${o}.fields.${p}`));
+  }), v(t.queryKind) || i.push(`${o}.queryKind must be a supported codegen query kind.`), t.sdkBuilder !== void 0 && !Q(t.sdkBuilder) && i.push(`${o}.sdkBuilder must be a supported SDK builder.`);
+  const s = n(t.computation);
+  return (s == null ? void 0 : s.kind) === "server_query" && v(t.queryKind) && v(s.queryKind) && s.queryKind !== t.queryKind && i.push(`${o}.computation.queryKind must match queryKind.`), i.push(
+    ...$e({
+      value: t.sdkSpec,
+      path: `${o}.sdkSpec`,
+      queryKind: typeof t.queryKind == "string" ? t.queryKind : void 0,
+      sdkBuilder: typeof t.sdkBuilder == "string" ? t.sdkBuilder : void 0
+    })
+  ), i;
+}
+function ve(r, o) {
+  const t = n(r);
+  if (!t)
+    return [`${o} must be an object.`];
+  const i = [];
+  if (t.fieldRef && i.push(
+    ...u(t.fieldRef, `${o}.fieldRef`)
+  ), (typeof t.inputId != "string" || !t.inputId.trim()) && i.push(`${o}.inputId is required.`), i.push(
+    ...z(t.optionQuery, `${o}.optionQuery`)
+  ), d(t.appliesToViewIds) || i.push(`${o}.appliesToViewIds must be an array of strings.`), d(t.notAppliedToViewIds) || i.push(`${o}.notAppliedToViewIds must be an array of strings.`), !Array.isArray(t.bindings))
+    i.push(`${o}.bindings must be an array.`);
+  else {
+    const s = d(t.appliesToViewIds) ? new Set(t.appliesToViewIds) : void 0, a = d(
+      t.notAppliedToViewIds
+    ) ? new Set(t.notAppliedToViewIds) : void 0;
+    t.bindings.forEach((p, y) => {
+      const h = n(p);
+      if (!h) {
+        i.push(`${o}.bindings.${y} must be an object.`);
+        return;
+      }
+      typeof h.viewId != "string" || !h.viewId ? i.push(`${o}.bindings.${y}.viewId is required.`) : (s && !s.has(h.viewId) && i.push(
+        `${o}.bindings.${y}.viewId must be included in appliesToViewIds.`
+      ), a != null && a.has(h.viewId) && i.push(
+        `${o}.bindings.${y}.viewId must not be listed in notAppliedToViewIds.`
+      )), i.push(
+        ...u(
+          h.fieldRef,
+          `${o}.bindings.${y}.fieldRef`
+        )
+      );
+    });
+  }
+  return i;
+}
+function z(r, o) {
+  if (r === void 0)
+    return [];
+  const t = n(r);
+  if (!t)
+    return [`${o} must be an object.`];
+  const i = [
+    ...m(
+      t.valueFieldRef,
+      `${o}.valueFieldRef`
+    ),
+    ...m(
+      t.labelFieldRef,
+      `${o}.labelFieldRef`
+    ),
+    ...m(
+      t.filterFieldRef,
+      `${o}.filterFieldRef`
+    )
+  ];
+  return t.builder !== "semaphor.inputOptions" && i.push(`${o}.builder must be semaphor.inputOptions.`), typeof t.sourceKey != "string" && t.source === void 0 && i.push(`${o} must include source or sourceKey.`), t.source !== void 0 && i.push(..._(t.source, `${o}.source`)), n(t.valueFieldRef) || i.push(`${o}.valueFieldRef is required.`), n(t.labelFieldRef) || i.push(`${o}.labelFieldRef is required.`), t.limit !== void 0 && (typeof t.limit != "number" || !Number.isInteger(t.limit) || t.limit <= 0) && i.push(`${o}.limit must be a positive integer.`), i;
+}
+function $e(r) {
+  var s;
+  const o = n(r.value);
+  if (!o)
+    return [`${r.path} is required for executable views.`];
+  const t = [];
+  if (!Q(o.builder))
+    return t.push(`${r.path}.builder must be a supported SDK builder.`), t;
+  r.sdkBuilder && o.builder !== r.sdkBuilder && t.push(`${r.path}.builder must match sdkBuilder.`), r.queryKind && v(r.queryKind) && o.builder !== Ce(r.queryKind) && t.push(`${r.path}.builder must match queryKind.`);
+  const i = n(o.spec);
+  if (!i)
+    return t.push(`${r.path}.spec must be an object.`), t;
+  switch (o.builder) {
+    case "semaphor.metric":
+      t.push(
+        ...S(i, G, `${r.path}.spec`),
+        ...A(i, r.path),
+        ...E(i.measures, `${r.path}.spec.measures`),
+        ...m(
+          i.primaryMeasure,
+          `${r.path}.spec.primaryMeasure`
+        ),
+        ...m(
+          i.dateField,
+          `${r.path}.spec.dateField`
+        ),
+        ...F(
+          i.dimensions,
+          `${r.path}.spec.dimensions`
+        ),
+        ...D(i.orderBy, `${r.path}.spec.orderBy`),
+        ...I(i.filters, `${r.path}.spec.filters`)
+      );
+      break;
+    case "semaphor.analysis":
+      t.push(
+        ...S(i, de, `${r.path}.spec`),
+        ...A(i, r.path),
+        ...E(i.measures, `${r.path}.spec.measures`),
+        ...m(
+          i.primaryMeasure,
+          `${r.path}.spec.primaryMeasure`
+        ),
+        ...m(
+          i.dateField,
+          `${r.path}.spec.dateField`
+        ),
+        ...F(
+          i.dimensions,
+          `${r.path}.spec.dimensions`
+        ),
+        ...D(i.orderBy, `${r.path}.spec.orderBy`),
+        ...I(i.filters, `${r.path}.spec.filters`),
+        ...we(i, `${r.path}.spec`)
+      );
+      break;
+    case "semaphor.records":
+      t.push(
+        ...S(i, pe, `${r.path}.spec`),
+        ...A(i, r.path),
+        ...E(i.fields, `${r.path}.spec.fields`),
+        ...m(
+          i.dateField,
+          `${r.path}.spec.dateField`
+        ),
+        ...D(i.orderBy, `${r.path}.spec.orderBy`),
+        ...I(i.filters, `${r.path}.spec.filters`)
+      );
+      break;
+    case "semaphor.matrix":
+      t.push(
+        ...S(i, me, `${r.path}.spec`),
+        ...ke(i, r.path),
+        ...Ae(i.rows, `${r.path}.spec.rows`),
+        ...Ie(
+          i.columns,
+          `${r.path}.spec.columns`
+        ),
+        ...je(i.values, `${r.path}.spec.values`),
+        ..._e(i.sort, `${r.path}.spec.sort`),
+        ...I(i.filters, `${r.path}.spec.filters`)
+      );
+      break;
+    case "semaphor.sql":
+      t.push(
+        ...S(i, ge, `${r.path}.spec`),
+        ...A(i, r.path)
+      ), ((s = n(i.source)) == null ? void 0 : s.kind) !== "sql" && t.push(`${r.path}.spec.source.kind must be sql.`), (typeof i.sql != "string" || !i.sql.trim()) && t.push(`${r.path}.spec.sql is required.`), t.push(
+        ...F(
+          i.fields,
+          `${r.path}.spec.fields`
+        )
+      );
+      break;
+  }
+  return t;
+}
+function we(r, o) {
+  const t = [];
+  if (r.driverMode !== void 0 && !ce.has(r.driverMode) && t.push(`${o}.driverMode must be a supported analysis driver mode.`), r.includePopulation !== void 0 && typeof r.includePopulation != "boolean" && t.push(`${o}.includePopulation must be a boolean.`), r.calendarContext !== void 0) {
+    const i = n(r.calendarContext);
+    if (!i)
+      t.push(`${o}.calendarContext must be an object.`);
+    else {
+      i.tz !== void 0 && typeof i.tz != "string" && t.push(`${o}.calendarContext.tz must be a string.`), i.weekStart !== void 0 && (typeof i.weekStart != "number" || !Number.isInteger(i.weekStart) || i.weekStart < 0 || i.weekStart > 6) && t.push(
+        `${o}.calendarContext.weekStart must be an integer between 0 and 6.`
+      );
+      const s = i.anchor;
+      if (s !== void 0 && s !== "now") {
+        const a = n(s);
+        (!a || typeof a.iso != "string" || !a.iso.trim()) && t.push(`${o}.calendarContext.anchor must be now or { iso }.`);
+      }
+    }
+  }
+  return t;
+}
+function S(r, o, t) {
+  const i = [];
+  return Object.keys(r).forEach((s) => {
+    o.has(s) || i.push(`${t}.${s} is not supported for this SDK builder.`);
+  }), i;
+}
+function A(r, o) {
+  return n(r.source) ? _(r.source, `${o}.spec.source`) : [`${o}.spec.source must be an object.`];
+}
+function ke(r, o) {
+  const t = n(r.source);
+  if (!t)
+    return [`${o}.spec.source must be an object.`];
+  const i = _(r.source, `${o}.spec.source`);
+  return t.kind !== "semantic" && t.kind !== "physical" && i.push(`${o}.spec.source.kind must be semantic or physical.`), i;
+}
+function E(r, o) {
+  const t = M(r, o);
+  return Array.isArray(r) && r.forEach((i, s) => {
+    t.push(...u(i, `${o}.${s}`));
+  }), t;
+}
+function F(r, o) {
+  if (r === void 0)
+    return [];
+  if (!Array.isArray(r))
+    return [`${o} must be an array.`];
+  const t = [];
+  return r.forEach((i, s) => {
+    t.push(...u(i, `${o}.${s}`));
+  }), t;
+}
+function D(r, o) {
+  if (r === void 0)
+    return [];
+  const t = n(r);
+  return t ? [
+    ...u(t.field, `${o}.field`),
+    ...H(t.direction, `${o}.direction`)
+  ] : [`${o} must be an object.`];
+}
+function Ae(r, o) {
+  const t = M(r, o);
+  return Array.isArray(r) && r.forEach((i, s) => {
+    const a = n(i);
+    if (!a) {
+      t.push(`${o}.${s} must be an object.`);
+      return;
+    }
+    t.push(
+      ...u(a.field, `${o}.${s}.field`)
+    );
+  }), t;
+}
+function Ie(r, o) {
+  if (r === void 0)
+    return [];
+  const t = [];
+  return Array.isArray(r) ? (r.forEach((i, s) => {
+    const a = n(i);
+    if (!a) {
+      t.push(`${o}.${s} must be an object.`);
+      return;
+    }
+    t.push(
+      ...u(a.field, `${o}.${s}.field`)
+    );
+  }), t) : [`${o} must be an array.`];
+}
+function je(r, o) {
+  const t = M(r, o);
+  return Array.isArray(r) && r.forEach((i, s) => {
+    const a = n(i);
+    if (!a) {
+      t.push(`${o}.${s} must be an object.`);
+      return;
+    }
+    t.push(
+      ...u(a.field, `${o}.${s}.field`)
+    );
+  }), t;
+}
+function _e(r, o) {
+  if (r === void 0)
+    return [];
+  if (!Array.isArray(r))
+    return [`${o} must be an array.`];
+  const t = [];
+  return r.forEach((i, s) => {
+    const a = n(i);
+    if (!a) {
+      t.push(`${o}.${s} must be an object.`);
+      return;
+    }
+    a.axis !== "row" && a.axis !== "column" && t.push(`${o}.${s}.axis must be row or column.`), t.push(
+      ...H(a.direction, `${o}.${s}.direction`),
+      ...Re(a.by, `${o}.${s}.by`)
+    );
+  }), t;
+}
+function Re(r, o) {
+  const t = n(r);
+  if (!t)
+    return [`${o} must be an object.`];
+  switch (t.kind) {
+    case "label":
+      return [];
+    case "field":
+      return u(t.field, `${o}.field`);
+    case "value":
+      return typeof t.valueId != "string" || !t.valueId.trim() ? [`${o}.valueId is required.`] : [];
+    default:
+      return [`${o}.kind must be label, field, or value.`];
+  }
+}
+function H(r, o) {
+  return r === "asc" || r === "desc" ? [] : [`${o} must be asc or desc.`];
+}
+function I(r, o) {
+  if (r === void 0)
+    return [];
+  if (!Array.isArray(r))
+    return [`${o} must be an array.`];
+  const t = [];
+  return r.forEach((i, s) => {
+    const a = n(i);
+    if (!a) {
+      t.push(`${o}.${s} must be an object.`);
+      return;
+    }
+    t.push(...u(a.field, `${o}.${s}.field`));
+  }), t;
+}
+function M(r, o) {
+  return !Array.isArray(r) || r.length === 0 ? [`${o} must be a non-empty array.`] : [];
+}
+function Ce(r) {
+  switch (r) {
+    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 qe(r) {
+  const o = n(r.computation), t = n(r.visualSpec);
+  return (o == null ? void 0 : o.kind) === "presentation_only" || (o == null ? void 0 : o.kind) === "derived" || (o == null ? void 0 : o.kind) === "unsupported" || r.visual === "text_block" || (t == null ? void 0 : t.visualType) === "text_block";
+}
+function xe(r, o) {
+  const t = n(r);
+  if (!t)
+    return [`${o} must be an object.`];
+  const i = [];
+  return he.has(t.visualType) || i.push(`${o}.visualType must be a supported visual type.`), t.limit !== void 0 && (typeof t.limit != "number" || !Number.isInteger(t.limit) || t.limit <= 0) && i.push(`${o}.limit must be a positive integer.`), t.tableBehavior !== void 0 && i.push(
+    ...Ee(
+      t.tableBehavior,
+      `${o}.tableBehavior`
+    )
+  ), i;
+}
+function Ee(r, o) {
+  const t = n(r);
+  if (!t)
+    return [`${o} must be an object.`];
+  const i = [];
+  return t.tableMode !== "bounded" && t.tableMode !== "server_paginated" && t.tableMode !== "server_windowed" && i.push(`${o}.tableMode must be a supported table mode.`), i.push(
+    ...Fe(t.height, `${o}.height`),
+    ...De(t.pagination, `${o}.pagination`),
+    ...Te(t.sorting, `${o}.sorting`),
+    ...Oe(t.totals, `${o}.totals`)
+  ), typeof t.serverSideRequired != "boolean" && i.push(`${o}.serverSideRequired must be a boolean.`), i;
+}
+function Fe(r, o) {
+  const t = n(r);
+  if (!t)
+    return [`${o} must be an object.`];
+  const i = [];
+  return (typeof t.maxPx != "number" || !Number.isInteger(t.maxPx) || t.maxPx <= 0) && i.push(`${o}.maxPx must be a positive integer.`), t.scroll !== "vertical" && t.scroll !== "both" && i.push(`${o}.scroll must be vertical or both.`), typeof t.stickyHeader != "boolean" && i.push(`${o}.stickyHeader must be a boolean.`), i;
+}
+function De(r, o) {
+  const t = n(r);
+  if (!t)
+    return [`${o} must be an object.`];
+  const i = [];
+  return t.mode !== "none" && t.mode !== "server" && t.mode !== "client_for_bounded_rows" && i.push(`${o}.mode must be a supported pagination mode.`), t.pageSize !== void 0 && (typeof t.pageSize != "number" || !Number.isInteger(t.pageSize) || t.pageSize <= 0) && i.push(`${o}.pageSize must be a positive integer.`), t.readsFrom !== void 0 && t.readsFrom !== "result.pagination" && i.push(`${o}.readsFrom must be result.pagination.`), i;
+}
+function Te(r, o) {
+  const t = n(r);
+  if (!t)
+    return [`${o} must be an object.`];
+  const i = [];
+  return t.mode !== "server" && t.mode !== "client_for_bounded_rows" && i.push(`${o}.mode must be a supported sorting mode.`), t.defaultField !== void 0 && (typeof t.defaultField != "string" || !t.defaultField.trim()) && i.push(`${o}.defaultField must be a non-empty string.`), t.defaultDirection !== void 0 && t.defaultDirection !== "asc" && t.defaultDirection !== "desc" && i.push(`${o}.defaultDirection must be asc or desc.`), t.resetPageOnChange !== void 0 && typeof t.resetPageOnChange != "boolean" && i.push(`${o}.resetPageOnChange must be a boolean.`), i;
+}
+function Oe(r, o) {
+  const t = n(r);
+  if (!t)
+    return [`${o} must be an object.`];
+  const i = [];
+  return typeof t.displayedRows != "boolean" && i.push(`${o}.displayedRows must be a boolean.`), t.allFilteredRows !== "not_needed" && t.allFilteredRows !== "server_provided" && t.allFilteredRows !== "separate_aggregate_query_required" && i.push(`${o}.allFilteredRows must be a supported totals mode.`), i;
+}
+function Ne(r, o) {
+  const t = n(r);
+  if (!t)
+    return [`${o} must be an object.`];
+  const i = [];
+  switch (t.kind) {
+    case "server_query":
+      v(t.queryKind) || i.push(`${o}.queryKind must be a supported codegen query kind.`), t.queryOwnership !== void 0 && t.queryOwnership !== "view_owned" && t.queryOwnership !== "shared_query" && i.push(
+        `${o}.queryOwnership must be view_owned or shared_query.`
+      ), t.sourceKeys !== void 0 && !d(t.sourceKeys) && i.push(`${o}.sourceKeys must be an array of strings.`), t.fieldNames !== void 0 && !d(t.fieldNames) && i.push(`${o}.fieldNames must be an array of strings.`);
+      break;
+    case "derived":
+      (typeof t.upstreamViewId != "string" || !t.upstreamViewId.trim()) && i.push(`${o}.upstreamViewId is required.`), (typeof t.derivation != "string" || !t.derivation.trim()) && i.push(`${o}.derivation is required.`);
+      break;
+    case "presentation_only":
+      break;
+    case "unsupported":
+      (typeof t.reason != "string" || !t.reason.trim()) && i.push(`${o}.reason is required.`), (typeof t.suggestedModelingFix != "string" || !t.suggestedModelingFix.trim()) && i.push(`${o}.suggestedModelingFix is required.`);
+      break;
+    default:
+      i.push(`${o}.kind must be a supported computation kind.`);
+  }
+  return i;
+}
+function Pe(r, o) {
+  const t = n(r);
+  if (!t)
+    return [`${o} must be an object.`];
+  const i = [];
+  for (const s of ["title", "requestedQuestion", "suggestedModelingFix"])
+    (typeof t[s] != "string" || !t[s].trim()) && i.push(`${o}.${s} is required.`);
+  return be.has(t.reason) || i.push(`${o}.reason must be a supported unsupported insight reason.`), i;
+}
+function v(r) {
+  return le.has(r);
+}
+function Q(r) {
+  return ue.has(r);
+}
+function m(r, o) {
+  return r === void 0 ? [] : u(r, o);
+}
+function u(r, o) {
+  const t = n(r);
+  if (!t)
+    return [`${o} must be an object.`];
+  const i = [];
+  return (typeof t.name != "string" || !t.name.trim()) && i.push(`${o}.name is required.`), !t.source && typeof t.sourceKey != "string" && i.push(`${o} must include source or sourceKey.`), i;
+}
+function n(r) {
+  return r && typeof r == "object" && !Array.isArray(r) ? r : void 0;
+}
+function d(r) {
+  return Array.isArray(r) && r.every((o) => typeof o == "string");
+}
+const c = e.record(e.string(), e.unknown()), R = e.array(c), l = e.enum([
+  "SUM",
+  "COUNT",
+  "AVG",
+  "MIN",
+  "MAX",
+  "MEDIAN",
+  "DISTINCT"
+]), C = e.enum([
+  "postgres",
+  "mysql",
+  "mssql",
+  "snowflake",
+  "clickhouse",
+  "bigquery",
+  "redshift",
+  "duckdb",
+  "sqlite",
+  "unknown"
+]), Y = 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"
+]), W = e.enum([
+  "semantic_model",
+  "caller_override",
+  "default_sum"
+]), j = e.union([e.number(), e.string(), e.null()]), T = e.enum([
+  "millisecond",
+  "second",
+  "minute",
+  "hour",
+  "day"
+]), Z = 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: T.optional(),
+    outputStyle: e.enum(["compact", "digital", "long"]).optional(),
+    largestUnit: T.optional(),
+    smallestUnit: T.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()
+]), Me = 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: l
+  }).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 w(r, o) {
+  return e.object(r).passthrough().superRefine((t, i) => {
+    for (const s of o)
+      Object.prototype.hasOwnProperty.call(t, s) || i.addIssue({
+        code: "custom",
+        path: [s],
+        message: `Required field "${s}" is missing.`
+      });
+  });
+}
+const X = 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(), Ke = 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(), Be = e.object({
+  kind: e.literal("sql"),
+  connectionId: e.string(),
+  dialect: C.optional(),
+  label: e.string().optional()
+}).passthrough(), $ = e.union([
+  X,
+  Ke,
+  Be
+]), f = e.object({
+  name: e.string(),
+  label: e.string().optional(),
+  role: q.optional(),
+  dataType: x.optional(),
+  source: $.optional(),
+  aggregate: l.optional()
+}).passthrough(), Ve = e.object({
+  kind: e.literal("field"),
+  field: f,
+  aggregate: l.optional()
+}).passthrough(), J = 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(Ve),
+  defaultAggregate: l.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: Z.optional(),
+  tags: e.array(e.string()).optional()
+}).passthrough(), K = f.and(
+  e.object({
+    semanticAggregate: l.optional(),
+    effectiveAggregate: l.optional(),
+    aggregateSource: W.optional(),
+    derivedField: J.optional()
+  }).passthrough()
+), Le = X, Ge = 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(), Ue = e.object({
+  kind: e.literal("sql"),
+  connectionId: e.string().optional(),
+  dialect: C.optional(),
+  label: e.string().optional()
+}).passthrough(), ze = e.union([
+  Le,
+  Ge,
+  Ue
+]), He = e.object({
+  key: e.string().optional(),
+  name: e.string(),
+  label: e.string().optional(),
+  role: q.optional(),
+  dataType: x.optional(),
+  source: ze.optional(),
+  aggregate: l.optional(),
+  semanticAggregate: l.optional(),
+  effectiveAggregate: l.optional(),
+  aggregateSource: W.optional(),
+  derivedField: e.never().optional()
+}).passthrough(), ee = e.object({
+  key: e.string(),
+  name: e.string(),
+  label: e.string(),
+  role: q.optional(),
+  dataType: x.optional(),
+  aggregate: l.optional(),
+  source: $.optional(),
+  derivedField: J.optional()
+}).passthrough(), te = 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(), N = e.object({
+  code: e.string(),
+  message: e.string(),
+  path: e.string().optional(),
+  fieldRole: e.enum(["measure", "date", "dimension", "input", "source", "sql"]).optional(),
+  repairHint: te.optional()
+}).passthrough(), oe = e.object({
+  ok: e.boolean(),
+  errors: e.array(N),
+  warnings: e.array(N),
+  repairHints: e.array(te)
+}).passthrough(), Qe = e.object({
+  page: e.number(),
+  pageSize: e.number(),
+  pageCount: e.number(),
+  totalCount: e.number(),
+  hasNextPage: e.boolean(),
+  hasPrevPage: e.boolean()
+}).passthrough(), k = {
+  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: Qe.optional()
+}, Ye = e.object({
+  ...k,
+  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(), We = e.object({
+  ...k,
+  kind: e.literal("records"),
+  columns: e.array(ee),
+  records: R
+}).passthrough(), Ze = e.object({
+  ...k,
+  kind: e.literal("inputOptions"),
+  options: e.array(
+    w(
+      {
+        label: e.string(),
+        value: e.unknown(),
+        count: e.number().optional(),
+        disambiguation: e.array(e.string()).optional()
+      },
+      ["value"]
+    )
+  )
+}).passthrough(), Xe = e.object({
+  ...k,
+  kind: e.literal("sql"),
+  columns: e.array(ee),
+  records: R,
+  sqlShape: e.object({
+    statementType: e.string().optional(),
+    explicitLimit: e.number().optional(),
+    hasPythonCode: e.boolean().optional()
+  }).passthrough().optional()
+}).passthrough(), Je = e.object({
+  enabled: e.boolean().optional(),
+  position: e.enum(["before", "after"]).optional(),
+  label: e.string().optional()
+}).passthrough(), V = e.object({
+  id: e.enum(["rows", "columns"]),
+  levels: e.array(
+    e.object({
+      instanceId: e.string(),
+      fieldKey: e.string(),
+      label: e.string(),
+      field: f,
+      grain: Y.optional(),
+      subtotal: Je.optional()
+    }).passthrough()
+  ),
+  nodeIds: e.array(e.string())
+}).passthrough(), b = w(
+  {
+    instanceId: e.string(),
+    fieldKey: e.string(),
+    value: e.unknown(),
+    label: e.string()
+  },
+  ["value"]
+), et = e.union([
+  e.object({ kind: e.literal("label") }).passthrough(),
+  e.object({
+    kind: e.literal("field"),
+    field: f,
+    aggregate: l.optional()
+  }).passthrough(),
+  e.object({
+    kind: e.literal("value"),
+    valueId: e.string(),
+    rowPath: e.array(b).optional(),
+    columnPath: e.array(b).optional()
+  }).passthrough()
+]), tt = e.enum([
+  "present",
+  "presentNull",
+  "missing",
+  "densified"
+]), ot = e.enum([
+  "value",
+  "rowSubtotal",
+  "columnSubtotal",
+  "subtotalIntersection",
+  "rowGrandTotal",
+  "columnGrandTotal",
+  "matrixGrandTotal"
+]), it = e.object({
+  instanceId: e.string(),
+  fieldKey: e.string(),
+  field: f,
+  role: e.enum(["row", "column", "measure", "sort", "filter"]),
+  label: e.string().optional()
+}).passthrough(), rt = e.union([
+  e.object({
+    kind: e.literal("additive"),
+    aggregate: l.optional()
+  }).passthrough(),
+  e.object({
+    kind: e.literal("semiAdditive"),
+    aggregate: l.optional(),
+    grain: Y.optional()
+  }).passthrough(),
+  e.object({
+    kind: e.literal("nonAdditive"),
+    aggregate: l.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()
+]), st = e.object({
+  instanceId: e.string(),
+  fieldKey: e.string(),
+  label: e.string(),
+  field: f,
+  aggregate: l.optional(),
+  format: Z.optional(),
+  totalBehavior: Me.optional(),
+  semantics: rt
+}).passthrough(), nt = e.object({
+  id: e.string(),
+  measureId: e.string(),
+  aggregate: l.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(), at = e.object({
+  kind: e.string(),
+  label: e.string().optional(),
+  payload: e.record(e.string(), e.unknown()).optional()
+}).passthrough(), lt = w(
+  {
+    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: l.optional(),
+    childCount: e.number().optional(),
+    actions: e.array(at).optional()
+  },
+  ["value"]
+), ut = 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(), ct = w(
+  {
+    rowId: e.string(),
+    columnId: e.string().optional(),
+    measureId: e.string(),
+    value: e.unknown(),
+    formattedValue: e.string().optional(),
+    presence: tt,
+    role: ot,
+    calculationId: e.string().optional()
+  },
+  ["value"]
+), dt = 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(), pt = w(
+  {
+    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: et
+  },
+  ["by"]
+), mt = 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(), gt = e.object({
+  axis: e.enum(["row", "column"]),
+  path: e.array(b),
+  depth: e.number().optional()
+}).passthrough(), ht = 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(gt).optional()
+}).passthrough(), bt = 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(), ft = e.object({
+  ...k,
+  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(), it),
+  measuresById: e.record(e.string(), st),
+  calculationsById: e.record(e.string(), nt).optional(),
+  axes: e.object({
+    rows: V,
+    columns: V
+  }).passthrough(),
+  nodesById: e.record(e.string(), lt),
+  layout: ut,
+  cells: e.array(ct),
+  totals: dt,
+  sort: e.array(pt),
+  formattingContext: bt,
+  pageInfo: mt.optional(),
+  expansion: ht.optional()
+}).passthrough(), yt = e.union([
+  Ye,
+  We,
+  Ze,
+  Xe,
+  ft
+]), St = e.object({
+  status: e.enum([
+    "not_required",
+    "resolved",
+    "missing",
+    "ambiguous",
+    "fanout_risk",
+    "unknown"
+  ]),
+  requiredSources: e.array($).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: $.optional(),
+    joinedSources: e.array($).optional(),
+    joinCount: e.number().optional()
+  }).passthrough().optional(),
+  fanoutRisk: e.object({
+    status: e.enum(["none", "warning", "error", "unknown"]),
+    message: e.string().optional()
+  }).passthrough().optional()
+}).passthrough(), L = e.enum([
+  "ambiguous_fields",
+  "empty_result",
+  "missing_grounded_fields",
+  "missing_relationship",
+  "no_grounded_query",
+  "partial_result",
+  "presentation_incomplete",
+  "query_validation_failed",
+  "unsafe_join"
+]), ie = 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(K).optional()
+    }).passthrough()
+  ),
+  blocked: e.array(
+    e.object({
+      slotId: e.string().optional(),
+      queryId: e.string().optional(),
+      reasonCode: L,
+      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: L,
+      message: e.string(),
+      recommendedNextStep: e.string().optional()
+    }).passthrough()
+  ).optional()
+}).passthrough(), re = e.object({
+  scope: e.literal("filtered_query"),
+  measures: e.record(j)
+}).passthrough(), se = e.object({
+  answeredObligations: e.array(e.string()),
+  missingObligations: e.array(e.string()),
+  warnings: e.array(N).optional()
+}).passthrough(), vt = 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(K).optional(),
+  result: yt.optional(),
+  validation: oe,
+  coverage: se.optional(),
+  missingFields: e.array(e.string()).optional(),
+  warnings: e.array(e.string()).optional(),
+  relationshipDiagnostics: St.optional(),
+  diagnosticFeedback: ie.optional(),
+  population: re.optional(),
+  metadata: e.record(e.string(), e.unknown()).optional()
+}).passthrough();
+function $t(r) {
+  switch (r) {
+    case "boolean":
+      return e.boolean().optional();
+    case "compactExecutionFieldArray":
+      return e.array(He).optional();
+    case "coverage":
+      return se.optional();
+    case "diagnosticFeedback":
+      return ie.optional();
+    case "executionFieldArray":
+      return e.array(K).optional();
+    case "executionResult":
+      return vt.optional();
+    case "number":
+      return e.number().finite().optional();
+    case "population":
+      return re.optional();
+    case "record":
+      return c.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 oe.optional();
+  }
+}
+const wt = Object.fromEntries(
+  Object.entries(P).map(
+    ([r, o]) => [r, $t(o)]
+  )
+), kt = e.object(wt).strict(), B = 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(), g = 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: l.optional(),
+  sourceKey: e.string().optional(),
+  source: B.optional()
+}).passthrough(), ne = e.object({
+  id: e.string().optional(),
+  builder: e.literal("semaphor.inputOptions"),
+  source: B.optional(),
+  sourceKey: e.string().optional(),
+  valueFieldRef: g,
+  labelFieldRef: g,
+  filterFieldRef: g.optional(),
+  population: e.unknown().optional(),
+  dependencies: e.unknown().optional(),
+  limit: e.number().int().positive().optional(),
+  spec: c.optional()
+}).passthrough(), ae = e.object({
+  appliesToViewIds: e.array(e.string()).optional(),
+  viewId: e.string().optional(),
+  fieldRef: g,
+  relationshipHint: e.unknown().optional(),
+  relationshipsUsed: e.array(c).optional()
+}).passthrough(), At = e.object({
+  id: e.string(),
+  label: e.string().optional(),
+  type: e.string().optional(),
+  serverSide: e.boolean().optional(),
+  fieldRef: g.optional(),
+  optionQuery: ne.optional(),
+  bindings: e.array(ae).optional(),
+  appliesToViewIds: e.array(e.string()),
+  relationshipHint: e.unknown().optional(),
+  relationshipsUsed: e.array(c).optional()
+}).passthrough(), It = e.object({
+  builder: e.enum([
+    "semaphor.metric",
+    "semaphor.records",
+    "semaphor.matrix",
+    "semaphor.analysis",
+    "semaphor.sql"
+  ]),
+  spec: c,
+  fallbackReason: c.optional()
+}).passthrough(), jt = 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: c.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: It.optional(),
+  fields: e.array(g).optional(),
+  computation: c.optional(),
+  uxExpectations: e.array(e.string()).optional(),
+  validation: c.optional()
+}).passthrough(), _t = e.object({
+  inputId: e.string(),
+  label: e.string().optional(),
+  type: e.string().optional(),
+  serverSide: e.boolean().optional(),
+  fieldRef: g.optional(),
+  optionQuery: ne.optional(),
+  bindings: e.array(ae),
+  appliesToViewIds: e.array(e.string()),
+  notAppliedToViewIds: e.array(e.string())
+}).passthrough(), Ft = e.object({
+  schemaVersion: e.literal(O),
+  title: e.string(),
+  purpose: e.string().optional(),
+  userGoal: e.string().optional(),
+  nextStep: e.string().optional(),
+  sources: e.array(B),
+  inputs: e.array(At),
+  views: e.array(jt),
+  filterContracts: e.array(_t),
+  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(c),
+    filterScopeByInput: e.array(c),
+    bindingsByView: e.record(e.string(), e.array(c)),
+    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: c.optional()
+}).passthrough().superRefine((r, o) => {
+  const t = U(r);
+  for (const i of t.issues)
+    o.addIssue({
+      code: e.ZodIssueCode.custom,
+      message: i
+    });
+}), Rt = new Set(
+  Object.keys(P)
+);
+function Dt() {
+  return Object.keys(
+    P
+  );
+}
+function Ct(r) {
+  return Rt.has(r);
+}
+function Tt(r) {
+  if (!r || typeof r != "object" || Array.isArray(r))
+    throw new Error("Semaphor analyze result must be an object.");
+  const t = Object.keys(r).filter(
+    (i) => !Ct(i)
+  );
+  if (t.length)
+    throw new Error(
+      `Semaphor analyze result contains unsupported top-level field(s): ${t.join(", ")}.`
+    );
+  return kt.parse(r);
+}
+export {
+  se as A,
+  vt as B,
+  wt as C,
+  kt as D,
+  Ft as E,
+  P as S,
+  O as a,
+  xt as b,
+  Et as c,
+  Ke as d,
+  Be as e,
+  $ as f,
+  Dt as g,
+  f as h,
+  Ct as i,
+  J as j,
+  K as k,
+  ee as l,
+  N as m,
+  oe as n,
+  Ye as o,
+  Tt as p,
+  We as q,
+  Ze as r,
+  X as s,
+  Xe as t,
+  ft as u,
+  U as v,
+  yt as w,
+  St as x,
+  ie as y,
+  re as z
+};