yamchart 0.10.1 → 0.10.2

package/dist/chunk-7HWFVUGP.js

@@ -0,0 +1,1239 @@
+import { createRequire as __yamchartCreateRequire } from 'module'; if (!globalThis.require) globalThis.require = __yamchartCreateRequire(import.meta.url);
+// ../../packages/schema/dist/connection.js
+import { z } from "zod";
+var EnvAuthSchema = z.object({
+  type: z.literal("env"),
+  user_var: z.string(),
+  password_var: z.string()
+});
+var KeyPairAuthSchema = z.object({
+  type: z.literal("key_pair"),
+  user_var: z.string(),
+  private_key_path: z.string()
+});
+var SecretManagerAuthSchema = z.object({
+  type: z.literal("secret_manager"),
+  provider: z.enum(["aws_secrets_manager", "gcp_secret_manager", "vault"]),
+  secret_id: z.string()
+});
+var ExternalBrowserAuthSchema = z.object({
+  type: z.literal("externalbrowser"),
+  user_var: z.string(),
+  cache_token: z.boolean().optional()
+});
+var ServiceAccountAuthSchema = z.object({
+  type: z.literal("service_account"),
+  credentials_var: z.string().optional(),
+  // env var NAME holding the SA JSON contents
+  key_file: z.string().optional()
+  // path to a SA .json key file
+});
+var AuthSchema = z.discriminatedUnion("type", [
+  EnvAuthSchema,
+  KeyPairAuthSchema,
+  SecretManagerAuthSchema,
+  ExternalBrowserAuthSchema,
+  ServiceAccountAuthSchema
+]);
+var PoolConfigSchema = z.object({
+  min_connections: z.number().int().positive().optional(),
+  max_connections: z.number().int().positive().optional(),
+  idle_timeout: z.number().int().positive().optional()
+});
+var QueryConfigSchema = z.object({
+  timeout: z.number().int().positive().optional(),
+  max_rows: z.number().int().positive().optional()
+});
+var DuckDBConfigSchema = z.object({
+  path: z.string()
+  // file path or :memory:
+});
+var PostgresConfigSchema = z.object({
+  host: z.string(),
+  port: z.number().int().positive().default(5432),
+  database: z.string(),
+  schema: z.string().optional(),
+  ssl: z.boolean().optional()
+});
+var SnowflakeConfigSchema = z.object({
+  account: z.string(),
+  warehouse: z.string(),
+  database: z.string(),
+  schema: z.string().optional(),
+  role: z.string().optional()
+});
+var MySQLConfigSchema = z.object({
+  host: z.string(),
+  port: z.number().int().positive().default(3306),
+  database: z.string(),
+  ssl: z.boolean().optional()
+});
+var SQLiteConfigSchema = z.object({
+  path: z.string()
+  // file path or :memory:
+});
+var BigQueryConfigSchema = z.object({
+  project_id: z.string(),
+  dataset: z.string().optional(),
+  location: z.string().optional(),
+  max_bytes_billed: z.number().optional()
+});
+var BaseConnectionSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().optional(),
+  pool: PoolConfigSchema.optional(),
+  query: QueryConfigSchema.optional(),
+  hunch_confidence_threshold: z.number().min(0).max(1).optional()
+});
+var DuckDBConnectionSchema = BaseConnectionSchema.extend({
+  type: z.literal("duckdb"),
+  config: DuckDBConfigSchema,
+  auth: z.undefined().optional()
+});
+var PostgresConnectionSchema = BaseConnectionSchema.extend({
+  type: z.literal("postgres"),
+  config: PostgresConfigSchema,
+  auth: AuthSchema.optional()
+});
+var SnowflakeConnectionSchema = BaseConnectionSchema.extend({
+  type: z.literal("snowflake"),
+  config: SnowflakeConfigSchema,
+  auth: AuthSchema
+});
+var MySQLConnectionSchema = BaseConnectionSchema.extend({
+  type: z.literal("mysql"),
+  config: MySQLConfigSchema,
+  auth: AuthSchema.optional()
+});
+var SQLiteConnectionSchema = BaseConnectionSchema.extend({
+  type: z.literal("sqlite"),
+  config: SQLiteConfigSchema,
+  auth: z.undefined().optional()
+});
+var BigQueryConnectionSchema = BaseConnectionSchema.extend({
+  type: z.literal("bigquery"),
+  config: BigQueryConfigSchema,
+  auth: AuthSchema
+});
+var ConnectionSchema = z.discriminatedUnion("type", [
+  DuckDBConnectionSchema,
+  PostgresConnectionSchema,
+  SnowflakeConnectionSchema,
+  MySQLConnectionSchema,
+  SQLiteConnectionSchema,
+  BigQueryConnectionSchema
+]);
+
+// ../../packages/schema/dist/runtime-config.js
+import { z as z4 } from "zod";
+
+// ../../packages/schema/dist/project.js
+import { z as z3 } from "zod";
+
+// ../../packages/schema/dist/semantic.js
+import { z as z2 } from "zod";
+var MeasureTypeSchema = z2.enum(["sum", "count", "avg", "min", "max", "count_distinct"]);
+var DimensionTypeSchema = z2.enum(["string", "number", "time", "boolean"]);
+var MeasureSchema = z2.object({
+  name: z2.string(),
+  type: MeasureTypeSchema,
+  description: z2.string().optional(),
+  format: z2.string().optional()
+});
+var DimensionSchema = z2.object({
+  name: z2.string(),
+  type: DimensionTypeSchema,
+  description: z2.string().optional()
+});
+var SemanticEntitySchema = z2.object({
+  name: z2.string(),
+  description: z2.string().optional(),
+  source: z2.enum(["catalog", "model"]),
+  source_table: z2.string(),
+  measures: z2.array(MeasureSchema),
+  dimensions: z2.array(DimensionSchema),
+  parameters: z2.array(z2.object({
+    name: z2.string(),
+    type: z2.string(),
+    default: z2.union([z2.string(), z2.number()]).optional(),
+    options: z2.array(z2.string()).optional()
+  })).optional()
+});
+var RelationshipSchema = z2.object({
+  from: z2.object({ entity: z2.string(), field: z2.string() }),
+  to: z2.object({ entity: z2.string(), field: z2.string() }),
+  type: z2.enum(["many_to_one", "one_to_many", "one_to_one"])
+});
+var SemanticModelSchema = z2.object({
+  entities: z2.array(SemanticEntitySchema),
+  relationships: z2.array(RelationshipSchema),
+  generated_at: z2.string()
+});
+var SemanticFilterOperatorSchema = z2.enum([
+  "equals",
+  "not_equals",
+  "contains",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "in",
+  "not_in"
+]);
+var SemanticFilterSchema = z2.object({
+  dimension: z2.string(),
+  operator: SemanticFilterOperatorSchema,
+  value: z2.union([z2.string(), z2.number(), z2.boolean(), z2.array(z2.union([z2.string(), z2.number()]))])
+});
+var SemanticQuerySchema = z2.object({
+  model: z2.string(),
+  measures: z2.array(z2.string()).min(1),
+  dimensions: z2.array(z2.string()).optional().default([]),
+  parameters: z2.record(z2.union([z2.string(), z2.number()])).optional(),
+  filters: z2.array(SemanticFilterSchema).optional().default([]),
+  order_by: z2.object({
+    field: z2.string(),
+    direction: z2.enum(["asc", "desc"]).default("asc")
+  }).optional(),
+  limit: z2.number().int().positive().max(1e4).optional().default(1e3)
+});
+var SemanticConfigSchema = z2.object({
+  include: z2.object({
+    paths: z2.array(z2.string()).default(["gold/", "marts/", "core/"]),
+    prefixes: z2.array(z2.string()).default(["dim_", "fct_", "fact_"])
+  }).optional().default({
+    paths: ["gold/", "marts/", "core/"],
+    prefixes: ["dim_", "fct_", "fact_"]
+  })
+}).optional();
+
+// ../../packages/schema/dist/project.js
+var DefaultsSchema = z3.object({
+  connection: z3.string().optional(),
+  theme: z3.string().optional(),
+  timezone: z3.string().optional(),
+  cache_ttl: z3.string().optional(),
+  base_url: z3.string().url().optional(),
+  week_start: z3.enum(["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"]).optional(),
+  table: z3.object({
+    max_display_rows: z3.number().int().positive().optional(),
+    max_export_rows: z3.number().int().positive().optional()
+  }).optional()
+});
+var GitSchema = z3.object({
+  provider: z3.enum(["github", "gitlab", "bitbucket"]).optional(),
+  repo: z3.string().optional(),
+  branch: z3.string().optional(),
+  preview_branches: z3.boolean().optional()
+});
+var SSOProviderSchema = z3.object({
+  client_id: z3.string(),
+  // Provide the secret directly, or name an env var that holds it (client_secret_var)
+  // so the secret never lives in git.
+  client_secret: z3.string().optional(),
+  client_secret_var: z3.string().optional(),
+  tenant: z3.string().optional(),
+  issuer: z3.string().optional(),
+  display_name: z3.string().optional(),
+  // Invite list: if non-empty, only these emails may sign in via this provider.
+  // Anyone not listed is rejected instead of auto-provisioned.
+  allowed_emails: z3.array(z3.string()).optional(),
+  // Emails provisioned with the admin role (implicitly allowed even if not in allowed_emails).
+  admin_emails: z3.array(z3.string()).optional()
+}).refine((c) => !!c.client_secret || !!c.client_secret_var, {
+  message: "SSO provider requires either client_secret or client_secret_var"
+});
+var AuthSchema2 = z3.object({
+  enabled: z3.boolean(),
+  db_path: z3.string().optional(),
+  session_ttl: z3.string().optional(),
+  providers: z3.object({
+    google: SSOProviderSchema.optional(),
+    microsoft: SSOProviderSchema.optional(),
+    oidc: SSOProviderSchema.optional()
+  }).optional()
+});
+var FeaturesSchema = z3.object({
+  enable_sql_editor: z3.boolean().optional(),
+  enable_csv_export: z3.boolean().optional(),
+  enable_scheduling: z3.boolean().optional(),
+  chat: z3.boolean().optional()
+});
+var SidebarLinkSchema = z3.object({
+  label: z3.string(),
+  url: z3.string(),
+  icon: z3.string().optional()
+});
+var SidebarConfigSchema = z3.object({
+  show: z3.boolean().optional(),
+  collapsed: z3.boolean().optional(),
+  links: z3.array(SidebarLinkSchema).optional(),
+  sections: z3.object({
+    dashboards: z3.boolean().optional(),
+    charts: z3.boolean().optional()
+  }).optional()
+});
+var ColorsSchema = z3.object({
+  primary: z3.string().optional(),
+  background: z3.string().optional(),
+  surface: z3.string().optional(),
+  sidebar: z3.string().optional(),
+  text: z3.string().optional()
+});
+var FontsSchema = z3.object({
+  heading: z3.string().optional(),
+  body: z3.string().optional(),
+  mono: z3.string().optional(),
+  size: z3.enum(["compact", "default", "comfortable"]).optional()
+});
+var LogoSchema = z3.union([
+  z3.string(),
+  z3.object({
+    light: z3.string(),
+    dark: z3.string()
+  })
+]);
+var ThemeSchema = z3.object({
+  mode: z3.enum(["light", "dark", "auto"]).optional(),
+  base: z3.enum(["modern", "executive", "minimal"]).optional(),
+  logo: LogoSchema.optional(),
+  favicon: z3.string().optional(),
+  title: z3.string().optional(),
+  colors: ColorsSchema.optional(),
+  palette: z3.array(z3.string()).optional(),
+  gradient: z3.boolean().default(false),
+  opacity: z3.number().min(0).max(1).default(1),
+  fonts: FontsSchema.optional(),
+  sidebar: SidebarConfigSchema.optional(),
+  customCss: z3.string().optional()
+});
+var EnvironmentOverrideSchema = z3.object({
+  defaults: DefaultsSchema.optional(),
+  git: GitSchema.optional(),
+  auth: AuthSchema2.optional(),
+  features: FeaturesSchema.optional(),
+  theme: ThemeSchema.optional(),
+  semantic: SemanticConfigSchema.optional()
+}).passthrough();
+function deepMerge(base, override) {
+  if (!override)
+    return { ...base };
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) {
+      result[key] = deepMerge(result[key], value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function resolveProjectConfig(raw, env) {
+  const { environments, ...base } = raw;
+  const envBlocks = environments;
+  const envOverride = env ? envBlocks?.[env] : void 0;
+  return deepMerge(base, envOverride);
+}
+var CatalogIncludeSchema = z3.object({
+  schemas: z3.array(z3.string()).optional(),
+  tags: z3.array(z3.string()).optional()
+});
+var CatalogConfigSchema = z3.object({
+  include: CatalogIncludeSchema.optional()
+});
+var KnowledgeConfigSchema = z3.object({
+  database_url_var: z3.string().default("KNOWLEDGE_DATABASE_URL")
+});
+var ProviderConfigSchema = z3.object({
+  provider: z3.enum(["anthropic", "openai", "gemini", "ollama", "ollama_cloud", "openai_compatible"]),
+  model: z3.string().optional(),
+  base_url: z3.string().optional(),
+  api_key_var: z3.string().optional(),
+  api_key: z3.string().optional()
+});
+var AiConfigSchema = z3.object({
+  default: z3.string().optional(),
+  providers: z3.record(ProviderConfigSchema).optional(),
+  tasks: z3.record(z3.string()).optional(),
+  embedding: ProviderConfigSchema.optional()
+}).refine((c) => !c.default || !c.providers || c.default in c.providers, { message: "ai.default must name a provider in ai.providers" }).refine((c) => !c.tasks || !c.providers || Object.values(c.tasks).every((n) => c.providers[n] !== void 0), { message: "every ai.tasks value must name a provider in ai.providers" });
+var ProjectSchema = z3.object({
+  version: z3.string().min(1),
+  name: z3.string().min(1),
+  description: z3.string().optional(),
+  defaults: DefaultsSchema.optional(),
+  environments: z3.record(z3.string(), EnvironmentOverrideSchema).optional(),
+  git: GitSchema.optional(),
+  auth: AuthSchema2.optional(),
+  features: FeaturesSchema.optional(),
+  theme: ThemeSchema.optional(),
+  semantic: SemanticConfigSchema,
+  catalog: CatalogConfigSchema.optional(),
+  knowledge: KnowledgeConfigSchema.optional(),
+  ai: AiConfigSchema.optional()
+});
+
+// ../../packages/schema/dist/runtime-config.js
+var ConnectionSecretsSchema = z4.object({
+  user: z4.string().optional(),
+  password: z4.string().optional(),
+  private_key: z4.string().optional(),
+  // Snowflake key_pair PEM
+  credentials_json: z4.string().optional()
+  // BigQuery service-account JSON contents
+});
+var baseRuntime = {
+  name: z4.string().min(1),
+  description: z4.string().optional(),
+  pool: PoolConfigSchema.optional(),
+  query: QueryConfigSchema.optional(),
+  secrets: ConnectionSecretsSchema.optional()
+};
+var RuntimeConnectionSchema = z4.discriminatedUnion("type", [
+  z4.object({ ...baseRuntime, type: z4.literal("duckdb"), config: DuckDBConfigSchema }),
+  z4.object({ ...baseRuntime, type: z4.literal("postgres"), config: PostgresConfigSchema }),
+  z4.object({ ...baseRuntime, type: z4.literal("mysql"), config: MySQLConfigSchema }),
+  z4.object({ ...baseRuntime, type: z4.literal("sqlite"), config: SQLiteConfigSchema }),
+  z4.object({ ...baseRuntime, type: z4.literal("snowflake"), config: SnowflakeConfigSchema }),
+  z4.object({ ...baseRuntime, type: z4.literal("bigquery"), config: BigQueryConfigSchema })
+]);
+var RuntimeConfigSchema = z4.object({
+  version: z4.literal(1).default(1),
+  connections: z4.array(RuntimeConnectionSchema).optional(),
+  knowledge: z4.object({ database_url: z4.string().min(1).optional() }).optional(),
+  ai: AiConfigSchema.optional()
+});
+
+// ../../packages/schema/dist/chart.js
+import { z as z5 } from "zod";
+var AxisTypeSchema = z5.enum(["temporal", "quantitative", "ordinal", "nominal"]);
+var AxisSchema = z5.object({
+  field: z5.string().min(1),
+  type: AxisTypeSchema,
+  format: z5.string().optional(),
+  label: z5.string().optional(),
+  scale: z5.enum(["linear", "log"]).optional()
+});
+var ChartTypeSchema = z5.enum([
+  "line",
+  "bar",
+  "area",
+  "pie",
+  "donut",
+  "table",
+  "metric",
+  "map",
+  "heatmap",
+  "funnel",
+  "sankey",
+  "treemap",
+  "waterfall",
+  "gauge"
+]);
+var GradientSchema = z5.union([
+  z5.boolean(),
+  z5.object({
+    from: z5.string(),
+    to: z5.string()
+  })
+]);
+var LongFormatSeriesSchema = z5.object({
+  field: z5.string().min(1),
+  colors: z5.record(z5.string(), z5.string()).optional()
+});
+var SeriesTransformSchema = z5.object({
+  type: z5.enum(["rolling_average"]),
+  window: z5.number().int().positive()
+});
+var WideFormatColumnSchema = z5.object({
+  field: z5.string().min(1),
+  name: z5.string().optional(),
+  type: z5.enum(["line", "bar", "area"]).optional(),
+  axis: z5.enum(["left", "right"]).optional(),
+  color: z5.string().optional(),
+  style: z5.enum(["solid", "dashed", "dotted"]).optional(),
+  opacity: z5.number().min(0).max(1).optional(),
+  gradient: GradientSchema.optional(),
+  transform: SeriesTransformSchema.optional(),
+  band: z5.string().optional()
+  // Pair with another column to render as shaded range band
+});
+var WideFormatSeriesSchema = z5.object({
+  columns: z5.array(WideFormatColumnSchema).min(1)
+});
+var SeriesConfigSchema = z5.union([
+  LongFormatSeriesSchema,
+  WideFormatSeriesSchema
+]);
+var ColorConditionSchema = z5.object({
+  when: z5.string(),
+  color: z5.string()
+});
+var ConditionalColorSchema = z5.object({
+  conditions: z5.array(ColorConditionSchema).min(1),
+  default: z5.string().optional()
+});
+var ColorSchema = z5.union([
+  z5.string(),
+  ConditionalColorSchema
+]);
+var LegendSchema = z5.object({
+  show: z5.boolean().optional(),
+  position: z5.enum(["top", "bottom", "left", "right"]).optional()
+});
+var LineAnnotationSchema = z5.object({
+  type: z5.literal("line"),
+  value: z5.number(),
+  label: z5.string().optional(),
+  color: z5.string().optional(),
+  style: z5.enum(["solid", "dashed", "dotted"]).optional()
+});
+var BandAnnotationSchema = z5.object({
+  type: z5.literal("band"),
+  from: z5.number(),
+  to: z5.number(),
+  label: z5.string().optional(),
+  color: z5.string().optional()
+});
+var XLineAnnotationSchema = z5.object({
+  type: z5.literal("x_line"),
+  x: z5.string(),
+  // x-axis value (date string or category)
+  label: z5.string().optional(),
+  color: z5.string().optional(),
+  style: z5.enum(["solid", "dashed", "dotted"]).optional()
+});
+var AnnotationSchema = z5.discriminatedUnion("type", [
+  LineAnnotationSchema,
+  BandAnnotationSchema,
+  XLineAnnotationSchema
+]);
+var GoalZoneSchema = z5.object({
+  tolerance: z5.number().min(0).max(1)
+});
+var GoalStyleSchema = z5.enum(["solid", "dashed", "dotted"]);
+var FixedGoalSchema = z5.object({
+  type: z5.literal("fixed"),
+  value: z5.number(),
+  label: z5.string().optional(),
+  color: z5.string().optional(),
+  style: GoalStyleSchema.optional(),
+  zone: GoalZoneSchema.optional()
+});
+var CumulativeGoalSchema = z5.object({
+  type: z5.literal("cumulative"),
+  value: z5.number(),
+  by: z5.string().min(1),
+  from: z5.string().optional(),
+  label: z5.string().optional(),
+  color: z5.string().optional(),
+  style: GoalStyleSchema.optional(),
+  zone: GoalZoneSchema.optional()
+});
+var GoalSourceSchema = z5.object({
+  model: z5.string().min(1),
+  value_field: z5.string().min(1),
+  date_field: z5.string().optional()
+});
+var ModelGoalSchema = z5.object({
+  type: z5.literal("model"),
+  source: GoalSourceSchema,
+  label: z5.string().optional(),
+  color: z5.string().optional(),
+  style: GoalStyleSchema.optional(),
+  zone: GoalZoneSchema.optional()
+});
+var GoalSchema = z5.discriminatedUnion("type", [
+  FixedGoalSchema,
+  CumulativeGoalSchema,
+  ModelGoalSchema
+]);
+var KpiGoalSchema = z5.object({
+  value: z5.number(),
+  label: z5.string().optional(),
+  show_progress: z5.boolean().optional(),
+  color: z5.string().optional()
+});
+var InteractionsSchema = z5.object({
+  tooltip: z5.boolean().default(true),
+  zoom: z5.boolean().default(false),
+  brush: z5.boolean().default(false)
+});
+var KpiFormatSchema = z5.object({
+  type: z5.enum(["number", "currency", "percent"]),
+  currency: z5.string().optional(),
+  // e.g., 'USD', 'EUR'
+  decimals: z5.number().optional()
+});
+var KpiComparisonSchema = z5.object({
+  enabled: z5.boolean(),
+  field: z5.string().min(1).optional(),
+  period: z5.enum(["previous"]).optional(),
+  label: z5.string().optional(),
+  type: z5.enum(["percent_change", "absolute"])
+}).refine((data) => !(data.field && data.period), { message: "Cannot set both field and period \u2014 use one or the other" }).refine((data) => data.field || data.period, { message: "Must set either field or period for comparison" });
+var KpiValueSchema = z5.object({
+  field: z5.string().min(1)
+});
+var KpiConfigSchema = z5.object({
+  type: z5.literal("kpi"),
+  value: KpiValueSchema,
+  format: KpiFormatSchema,
+  comparison: KpiComparisonSchema.optional(),
+  unit: z5.string().optional(),
+  // e.g., 'min', 'sessions', 'users'
+  goal: KpiGoalSchema.optional()
+});
+var CenterValueSchema = z5.object({
+  field: z5.string().optional(),
+  // 'total' for sum, or specific field
+  label: z5.string().optional(),
+  format: z5.string().optional()
+});
+var CompareSchema = z5.object({
+  period: z5.string(),
+  // previous_week, previous_month, previous_year, or a preset name
+  label: z5.string().optional(),
+  style: z5.enum(["solid", "dashed", "dotted"]).optional(),
+  opacity: z5.number().min(0).max(1).optional(),
+  color: z5.string().optional()
+});
+var StandardChartConfigSchema = z5.object({
+  type: ChartTypeSchema,
+  x: AxisSchema,
+  y: AxisSchema.optional(),
+  series: SeriesConfigSchema.optional(),
+  stacking: z5.enum(["stacked", "percent"]).optional(),
+  orientation: z5.enum(["vertical", "horizontal"]).optional(),
+  color: ColorSchema.optional(),
+  gradient: GradientSchema.optional(),
+  legend: LegendSchema.optional(),
+  annotations: z5.array(AnnotationSchema).optional(),
+  compare: z5.array(CompareSchema).optional(),
+  interactions: InteractionsSchema.optional(),
+  centerValue: CenterValueSchema.optional(),
+  // For donut charts
+  goals: z5.array(GoalSchema).optional()
+});
+var DualAxisConfigSchema = z5.object({
+  label: z5.string().optional(),
+  format: z5.string().optional(),
+  scale: z5.enum(["linear", "log"]).optional()
+});
+var DualAxesSchema = z5.object({
+  left: DualAxisConfigSchema.optional(),
+  right: DualAxisConfigSchema.optional()
+});
+var ComboChartConfigSchema = z5.object({
+  type: z5.literal("combo"),
+  x: AxisSchema,
+  series: WideFormatSeriesSchema,
+  stacking: z5.enum(["stacked", "percent"]).optional(),
+  axes: DualAxesSchema,
+  legend: LegendSchema.optional(),
+  interactions: InteractionsSchema.optional(),
+  gradient: GradientSchema.optional(),
+  goals: z5.array(GoalSchema).optional()
+});
+var ScatterSizeSchema = z5.object({
+  field: z5.string().min(1),
+  min: z5.number().optional(),
+  max: z5.number().optional(),
+  label: z5.string().optional()
+});
+var ScatterGroupSchema = z5.object({
+  field: z5.string().min(1)
+});
+var RegressionSchema = z5.object({
+  type: z5.literal("linear"),
+  show_equation: z5.boolean().optional(),
+  show_r_squared: z5.boolean().optional()
+});
+var ScatterChartConfigSchema = z5.object({
+  type: z5.literal("scatter"),
+  x: AxisSchema,
+  y: AxisSchema,
+  size: ScatterSizeSchema.optional(),
+  group: ScatterGroupSchema.optional(),
+  regression: RegressionSchema.optional(),
+  color: ColorSchema.optional(),
+  legend: LegendSchema.optional(),
+  interactions: InteractionsSchema.optional()
+});
+var HeatmapChartConfigSchema = z5.object({
+  type: z5.literal("heatmap"),
+  x: AxisSchema,
+  y: AxisSchema,
+  value: z5.object({
+    field: z5.string().min(1),
+    label: z5.string().optional()
+  }),
+  color_range: z5.object({
+    min: z5.string().optional(),
+    max: z5.string().optional()
+  }).optional(),
+  show_values: z5.boolean().optional()
+});
+var FunnelChartConfigSchema = z5.object({
+  type: z5.literal("funnel"),
+  stage: z5.object({ field: z5.string().min(1) }),
+  value: z5.object({ field: z5.string().min(1) }),
+  show_conversion: z5.boolean().optional(),
+  color: ColorSchema.optional()
+});
+var WaterfallChartConfigSchema = z5.object({
+  type: z5.literal("waterfall"),
+  category: z5.object({ field: z5.string().min(1) }),
+  value: z5.object({ field: z5.string().min(1) }),
+  total_field: z5.string().optional(),
+  series: LongFormatSeriesSchema.optional(),
+  // Stacked breakdown within each waterfall step
+  colors: z5.object({
+    increase: z5.string().optional(),
+    decrease: z5.string().optional(),
+    total: z5.string().optional()
+  }).optional()
+});
+var SankeyChartConfigSchema = z5.object({
+  type: z5.literal("sankey"),
+  source: z5.object({ field: z5.string().min(1) }),
+  target: z5.object({ field: z5.string().min(1) }),
+  value: z5.object({ field: z5.string().min(1) }),
+  levels: z5.array(z5.array(z5.string())).optional(),
+  orient: z5.enum(["horizontal", "vertical"]).optional(),
+  node_width: z5.number().positive().optional(),
+  node_gap: z5.number().nonnegative().optional(),
+  label_position: z5.enum(["left", "right", "top", "bottom", "inside"]).optional()
+});
+var GaugeThresholdSchema = z5.object({
+  value: z5.number(),
+  color: z5.string()
+});
+var GaugeChartConfigSchema = z5.object({
+  type: z5.literal("gauge"),
+  value: z5.object({ field: z5.string().min(1) }),
+  min: z5.number().optional(),
+  max: z5.number().optional(),
+  unit: z5.string().optional(),
+  thresholds: z5.array(GaugeThresholdSchema).optional(),
+  format: z5.string().optional(),
+  goal: KpiGoalSchema.optional()
+});
+var TableColumnSummarySchema = z5.enum(["sum", "avg", "min", "max", "count"]);
+var PivotAggregateSchema = z5.enum(["sum", "avg", "min", "max", "count"]);
+var PivotValueSchema = z5.object({
+  field: z5.string().min(1),
+  aggregate: PivotAggregateSchema.default("sum"),
+  format: z5.string().optional(),
+  heatmap: z5.boolean().optional()
+});
+var PivotHeatmapSchema = z5.object({
+  color: z5.string().optional(),
+  scope: z5.enum(["column", "global"]).optional()
+});
+var PivotConfigSchema = z5.object({
+  rows: z5.array(z5.string().min(1)).min(1),
+  columns: z5.string().min(1),
+  values: z5.array(PivotValueSchema).min(1),
+  subtotals: z5.boolean().optional(),
+  grandTotals: z5.boolean().optional(),
+  heatmap: PivotHeatmapSchema.optional()
+});
+var TableChartConfigSchema = z5.object({
+  type: z5.literal("table"),
+  columns: z5.array(z5.object({
+    field: z5.string().min(1),
+    label: z5.string().optional(),
+    format: z5.string().optional(),
+    sticky: z5.boolean().optional(),
+    summary: TableColumnSummarySchema.optional(),
+    overflow: z5.enum(["ellipsis", "wrap", "hidden"]).optional(),
+    font: z5.enum(["mono"]).optional()
+  })).optional(),
+  summary: z5.object({
+    label: z5.string().optional()
+  }).optional(),
+  sort: z5.object({
+    field: z5.string().min(1),
+    direction: z5.enum(["asc", "desc"]).optional()
+  }).optional(),
+  pagination: z5.object({
+    enabled: z5.boolean().optional(),
+    page_size: z5.number().int().positive().optional(),
+    mode: z5.enum(["paginated", "infinite_scroll"]).optional(),
+    server_side: z5.boolean().optional()
+  }).optional(),
+  max_rows: z5.number().int().positive().optional(),
+  export: z5.object({
+    enabled: z5.boolean().optional(),
+    max_rows: z5.number().int().positive().optional()
+  }).optional(),
+  pivot: PivotConfigSchema.optional()
+});
+var ChartConfigSchema = z5.union([
+  ScatterChartConfigSchema,
+  ComboChartConfigSchema,
+  HeatmapChartConfigSchema,
+  FunnelChartConfigSchema,
+  WaterfallChartConfigSchema,
+  GaugeChartConfigSchema,
+  SankeyChartConfigSchema,
+  TableChartConfigSchema,
+  StandardChartConfigSchema,
+  KpiConfigSchema
+]);
+var ParameterTypeSchema = z5.enum([
+  "date_range",
+  "select",
+  "multi_select",
+  "dynamic_select",
+  "text",
+  "number",
+  "boolean"
+]);
+var ParameterOptionSchema = z5.union([
+  z5.string(),
+  z5.object({
+    value: z5.string(),
+    label: z5.string()
+  })
+]);
+var ParameterSourceSchema = z5.object({
+  model: z5.string(),
+  value_field: z5.string(),
+  label_field: z5.string()
+});
+var ParameterSchema = z5.object({
+  name: z5.string().min(1),
+  type: ParameterTypeSchema,
+  label: z5.string().optional(),
+  description: z5.string().optional(),
+  default: z5.union([z5.string(), z5.number(), z5.array(z5.string())]).optional(),
+  options: z5.array(ParameterOptionSchema).optional(),
+  source: ParameterSourceSchema.optional()
+});
+var SourceSchema = z5.object({
+  model: z5.string().optional(),
+  sql: z5.string().optional(),
+  connection: z5.string().optional()
+  // optional per-chart connection override (default: project default)
+}).refine((data) => data.model !== void 0 || data.sql !== void 0, { message: "Source must specify either model or sql" }).refine((data) => !(data.model !== void 0 && data.sql !== void 0), { message: "Source cannot specify both model and sql" });
+var RefreshSchema = z5.object({
+  schedule: z5.string().optional(),
+  // cron expression
+  timezone: z5.string().optional(),
+  cache_ttl: z5.string().optional()
+  // e.g., "1h", "30m"
+});
+var DrillDownColumnSchema = z5.object({
+  field: z5.string().min(1),
+  label: z5.string().optional(),
+  format: z5.string().optional()
+});
+var DrillDownConfigSchema = z5.object({
+  chart: z5.string().optional(),
+  // target chart name (source side)
+  model: z5.string().optional(),
+  // model name for row-level detail data
+  field: z5.string().optional(),
+  // field to pass as filter, defaults to x-axis field (backward compat)
+  fields: z5.union([z5.string(), z5.array(z5.string())]).optional(),
+  // dimension field(s) for filtering
+  columns: z5.array(DrillDownColumnSchema).optional()
+  // data table columns (target side)
+}).refine((data) => data.chart || data.model || data.columns, {
+  message: "drillDown requires 'chart', 'model', or 'columns'"
+});
+var ChartSchema = z5.object({
+  // Identity
+  name: z5.string().min(1),
+  title: z5.string().min(1),
+  description: z5.string().optional(),
+  // Metadata
+  owner: z5.string().optional(),
+  tags: z5.array(z5.string()).optional(),
+  created: z5.string().optional(),
+  updated: z5.string().optional(),
+  // Data
+  source: SourceSchema,
+  parameters: z5.array(ParameterSchema).optional(),
+  // Visualization
+  chart: ChartConfigSchema,
+  // Caching
+  refresh: RefreshSchema.optional(),
+  // Drill-down navigation
+  drillDown: DrillDownConfigSchema.optional()
+});
+
+// ../../packages/schema/dist/model.js
+import { z as z6 } from "zod";
+var ParamTypeSchema = z6.enum(["string", "number", "date", "boolean", "string[]", "number[]"]);
+var ModelParamSchema = z6.object({
+  name: z6.string().min(1),
+  type: ParamTypeSchema,
+  default: z6.string().optional(),
+  options: z6.array(z6.string()).optional(),
+  // For enum-like params
+  description: z6.string().optional()
+});
+var ReturnColumnSchema = z6.object({
+  name: z6.string().min(1),
+  type: z6.string(),
+  description: z6.string().optional()
+});
+var ModelMetadataSchema = z6.object({
+  name: z6.string().min(1),
+  description: z6.string().optional(),
+  owner: z6.string().optional(),
+  tags: z6.array(z6.string()).optional(),
+  params: z6.array(ModelParamSchema).optional(),
+  returns: z6.array(ReturnColumnSchema).optional(),
+  tests: z6.array(z6.string()).optional()
+  // SQL assertions
+});
+var ModelSchema = z6.object({
+  metadata: ModelMetadataSchema,
+  sql: z6.string().min(1),
+  filePath: z6.string().optional()
+});
+
+// ../../packages/schema/dist/dashboard.js
+import { z as z7 } from "zod";
+var ChartWidgetSchema = z7.object({
+  type: z7.literal("chart"),
+  ref: z7.string().min(1),
+  cols: z7.number().min(1).max(12),
+  height: z7.number().min(38).optional(),
+  x: z7.number().min(0).max(11).optional(),
+  y: z7.number().min(0).optional()
+});
+var TextWidgetSchema = z7.object({
+  type: z7.literal("text"),
+  content: z7.string(),
+  cols: z7.number().min(1).max(12),
+  height: z7.number().min(38).optional(),
+  x: z7.number().min(0).max(11).optional(),
+  y: z7.number().min(0).optional()
+});
+var WidgetSchema = z7.discriminatedUnion("type", [
+  ChartWidgetSchema,
+  TextWidgetSchema
+]);
+var RowSchema = z7.object({
+  height: z7.number().min(38),
+  widgets: z7.array(WidgetSchema).min(1)
+});
+var LayoutSchema = z7.object({
+  gap: z7.number().min(0).default(16),
+  rows: z7.array(RowSchema).min(1)
+});
+var TabSchema = z7.object({
+  name: z7.string().min(1),
+  label: z7.string().min(1),
+  filters: z7.array(ParameterSchema).optional(),
+  layout: LayoutSchema
+});
+var DashboardSchema = z7.object({
+  // Identity
+  name: z7.string().min(1),
+  title: z7.string().min(1),
+  description: z7.string().optional(),
+  // Filters inherited by all widgets (shared across tabs)
+  filters: z7.array(ParameterSchema).optional(),
+  // Layout definition (mutually exclusive with tabs)
+  layout: LayoutSchema.optional(),
+  // Tabbed layout
+  tabs: z7.array(TabSchema).min(1).optional()
+}).superRefine((data, ctx) => {
+  if (data.layout && data.tabs) {
+    ctx.addIssue({
+      code: z7.ZodIssueCode.custom,
+      message: 'Dashboard must have either "layout" or "tabs", not both',
+      path: ["tabs"]
+    });
+  }
+  if (!data.layout && !data.tabs) {
+    ctx.addIssue({
+      code: z7.ZodIssueCode.custom,
+      message: 'Dashboard must have either "layout" or "tabs"',
+      path: []
+    });
+  }
+});
+
+// ../../packages/schema/dist/schedule.js
+import { z as z8 } from "zod";
+var SlackChannelSchema = z8.object({
+  webhook_url: z8.string().min(1),
+  channel: z8.string().optional()
+});
+var ChannelSchema = z8.object({
+  slack: SlackChannelSchema
+});
+var ConditionOperatorSchema = z8.enum(["lt", "gt", "lte", "gte", "eq"]);
+var ConditionSchema = z8.object({
+  field: z8.string().min(1),
+  operator: ConditionOperatorSchema,
+  value: z8.number()
+});
+var ReportScheduleSchema = z8.object({
+  name: z8.string().min(1),
+  type: z8.literal("report"),
+  schedule: z8.string().min(1),
+  timezone: z8.string().optional(),
+  channel: ChannelSchema,
+  charts: z8.array(z8.string().min(1)).min(1),
+  params: z8.record(z8.unknown()).optional(),
+  message: z8.string().optional(),
+  notify_on_error: z8.boolean().optional()
+});
+var AlertScheduleSchema = z8.object({
+  name: z8.string().min(1),
+  type: z8.literal("alert"),
+  schedule: z8.string().min(1),
+  timezone: z8.string().optional(),
+  channel: ChannelSchema,
+  chart: z8.string().min(1),
+  params: z8.record(z8.unknown()).optional(),
+  condition: ConditionSchema,
+  cooldown: z8.string().optional(),
+  message: z8.string().optional(),
+  notify_on_error: z8.boolean().optional()
+});
+var ScheduleSchema = z8.discriminatedUnion("type", [
+  ReportScheduleSchema,
+  AlertScheduleSchema
+]);
+
+// ../../packages/schema/dist/events.js
+import { z as z9 } from "zod";
+var EventSchema = z9.object({
+  date: z9.string(),
+  endDate: z9.string().optional(),
+  label: z9.string(),
+  description: z9.string().optional(),
+  color: z9.string().optional(),
+  charts: z9.array(z9.string()).optional()
+});
+var EventsFileSchema = z9.object({
+  events: z9.array(EventSchema).default([])
+});
+
+// ../../packages/schema/dist/semantic-curated.js
+import { z as z10 } from "zod";
+var CuratedMetricSchema = z10.object({
+  name: z10.string().min(1),
+  label: z10.string().optional(),
+  description: z10.string().optional(),
+  agg: MeasureTypeSchema,
+  // sum|count|avg|min|max|count_distinct
+  field: z10.string().optional(),
+  // column to aggregate
+  sql: z10.string().optional(),
+  // raw aggregate expression (derived metric)
+  filter: z10.string().optional(),
+  // references a named filter on the entity
+  synonyms: z10.array(z10.string()).optional(),
+  format: z10.string().optional(),
+  default_time_grain: z10.enum(["day", "week", "month", "quarter", "year"]).optional()
+}).refine((m) => Boolean(m.field) !== Boolean(m.sql), {
+  message: "metric must specify exactly one of `field` or `sql`"
+}).refine((m) => !(m.sql && m.filter), {
+  message: "a metric with raw `sql` cannot also set `filter` (embed the condition in the sql expression instead)"
+});
+var CuratedDimensionSchema = z10.object({
+  name: z10.string().min(1),
+  type: DimensionTypeSchema,
+  // string|number|time|boolean
+  description: z10.string().optional(),
+  synonyms: z10.array(z10.string()).optional()
+});
+var NamedFilterSchema = z10.object({
+  description: z10.string().optional(),
+  sql: z10.string().min(1),
+  synonyms: z10.array(z10.string()).optional()
+});
+var CuratedSourceSchema = z10.object({ table: z10.string().optional(), model: z10.string().optional() }).refine((s) => Boolean(s.table) !== Boolean(s.model), {
+  message: "source must specify exactly one of `table` or `model`"
+});
+var SemanticDefinitionSchema = z10.object({
+  entity: z10.string().min(1),
+  description: z10.string().optional(),
+  source: CuratedSourceSchema,
+  primary_key: z10.string().optional(),
+  time_dimension: z10.string().optional(),
+  dimensions: z10.array(CuratedDimensionSchema).default([]),
+  filters: z10.record(NamedFilterSchema).optional().default({}),
+  metrics: z10.array(CuratedMetricSchema).min(1)
+});
+
+// ../../packages/schema/dist/agent.js
+import { z as z11 } from "zod";
+var AgentDefinitionSchema = z11.object({
+  name: z11.string(),
+  title: z11.string().optional(),
+  description: z11.string(),
+  system_prompt: z11.string(),
+  tools: z11.array(z11.string()).default([]),
+  model: z11.string().optional(),
+  models: z11.array(z11.string()).optional()
+});
+
+// ../../packages/schema/dist/hunch.js
+import { z as z12 } from "zod";
+var HunchStatusSchema = z12.enum(["pending", "confirmed", "rejected"]);
+var HunchSampleSchema = z12.object({
+  columns: z12.array(z12.object({ name: z12.string() })),
+  rows: z12.array(z12.record(z12.unknown())),
+  ranAt: z12.string()
+});
+var NewHunchSchema = z12.object({
+  connection: z12.string(),
+  question: z12.string().min(1),
+  sql: z12.string().min(1),
+  generatedSql: z12.string().min(1),
+  tablesUsed: z12.array(z12.string()).default([]),
+  rationale: z12.string().optional(),
+  confidence: z12.number().min(0).max(1).optional()
+});
+var HunchSchema = NewHunchSchema.extend({
+  id: z12.string(),
+  status: HunchStatusSchema,
+  lastRunSample: HunchSampleSchema.optional(),
+  createdAt: z12.string(),
+  updatedAt: z12.string()
+});
+var ColumnProfileSchema = z12.object({
+  name: z12.string(),
+  type: z12.string(),
+  nullRate: z12.number().optional(),
+  distinctCount: z12.number().optional(),
+  min: z12.unknown().optional(),
+  max: z12.unknown().optional(),
+  topValues: z12.array(z12.object({ value: z12.unknown(), count: z12.number() })).optional()
+});
+var TableProfileSchema = z12.object({
+  table: z12.string(),
+  rowCount: z12.number().optional(),
+  columns: z12.array(ColumnProfileSchema),
+  sampleRows: z12.array(z12.record(z12.unknown()))
+});
+var SourceProfileSchema = z12.object({
+  connection: z12.string(),
+  profiledAt: z12.string(),
+  tables: z12.array(TableProfileSchema)
+});
+
+// ../../packages/schema/dist/blindspot.js
+import { z as z13 } from "zod";
+var BlindspotKindSchema = z13.enum(["context", "opportunity"]);
+var BlindspotStatusSchema = z13.enum(["open", "answered", "dismissed"]);
+var SuggestedModelSchema = z13.object({
+  name: z13.string().min(1),
+  description: z13.string(),
+  rationale: z13.string(),
+  columns: z13.array(z13.object({ name: z13.string(), description: z13.string().optional() }))
+});
+var NewBlindspotSchema = z13.object({
+  connection: z13.string(),
+  kind: BlindspotKindSchema,
+  title: z13.string().min(1),
+  detail: z13.string().min(1),
+  subject: z13.string().optional(),
+  suggestedModel: SuggestedModelSchema.optional(),
+  confidence: z13.number().min(0).max(1).optional()
+}).refine((b) => b.kind !== "opportunity" || b.suggestedModel !== void 0, {
+  message: "opportunity blindspots must include a suggestedModel"
+});
+var BlindspotSchema = z13.object({
+  id: z13.string(),
+  connection: z13.string(),
+  kind: BlindspotKindSchema,
+  title: z13.string(),
+  detail: z13.string(),
+  subject: z13.string().optional(),
+  suggestedModel: SuggestedModelSchema.optional(),
+  confidence: z13.number().optional(),
+  status: BlindspotStatusSchema,
+  answer: z13.string().optional(),
+  createdAt: z13.string(),
+  updatedAt: z13.string()
+});
+
+// ../../packages/schema/dist/knowledge-doc.js
+import { z as z14 } from "zod";
+var NewKnowledgeDocSchema = z14.object({
+  connection: z14.string(),
+  title: z14.string().min(1),
+  content: z14.string().min(1),
+  source: z14.enum(["ui", "file"]).default("ui")
+});
+var KnowledgeDocSchema = NewKnowledgeDocSchema.extend({
+  id: z14.string(),
+  createdAt: z14.string(),
+  updatedAt: z14.string()
+});
+
+// ../../packages/schema/dist/index.js
+var VERSION = "0.1.0";
+
+export {
+  PoolConfigSchema,
+  QueryConfigSchema,
+  DuckDBConfigSchema,
+  PostgresConfigSchema,
+  SnowflakeConfigSchema,
+  MySQLConfigSchema,
+  SQLiteConfigSchema,
+  BigQueryConfigSchema,
+  ConnectionSchema,
+  MeasureTypeSchema,
+  DimensionTypeSchema,
+  MeasureSchema,
+  DimensionSchema,
+  SemanticEntitySchema,
+  RelationshipSchema,
+  SemanticModelSchema,
+  SemanticFilterOperatorSchema,
+  SemanticFilterSchema,
+  SemanticQuerySchema,
+  SemanticConfigSchema,
+  deepMerge,
+  resolveProjectConfig,
+  ProviderConfigSchema,
+  AiConfigSchema,
+  ProjectSchema,
+  ConnectionSecretsSchema,
+  RuntimeConnectionSchema,
+  RuntimeConfigSchema,
+  ParameterSchema,
+  ChartSchema,
+  ModelMetadataSchema,
+  ModelSchema,
+  DashboardSchema,
+  ScheduleSchema,
+  EventSchema,
+  EventsFileSchema,
+  CuratedMetricSchema,
+  CuratedDimensionSchema,
+  NamedFilterSchema,
+  CuratedSourceSchema,
+  SemanticDefinitionSchema,
+  AgentDefinitionSchema,
+  HunchStatusSchema,
+  HunchSampleSchema,
+  NewHunchSchema,
+  HunchSchema,
+  ColumnProfileSchema,
+  TableProfileSchema,
+  SourceProfileSchema,
+  BlindspotKindSchema,
+  BlindspotStatusSchema,
+  SuggestedModelSchema,
+  NewBlindspotSchema,
+  BlindspotSchema,
+  NewKnowledgeDocSchema,
+  KnowledgeDocSchema,
+  VERSION
+};
+//# sourceMappingURL=chunk-7HWFVUGP.js.map