@metabase/cli 0.2.2 → 0.3.0

package/dist/validate-BWchyW0V.mjs

@@ -0,0 +1,1469 @@
+import { h as escapeJsonPointerSegment, i as ConfigError, t as isPlainObject } from "./predicates-Bkm2IoeX.mjs";
+import { z } from "zod";
+import Ajv2020 from "ajv/dist/2020.js";
+import addFormats from "ajv-formats";
+//#region src/core/schema/data/schemas/common/parameter.json
+var parameter_default = {
+	title: "Parameter",
+	description: "A filter control parameter for cards and dashboards. Parameters allow users to interactively filter data via UI controls.\n",
+	type: "object",
+	required: [
+		"id",
+		"name",
+		"slug",
+		"type"
+	],
+	properties: {
+		"id": {
+			"type": "string",
+			"minLength": 1,
+			"description": "Unique identifier within the dashboard or card. UUIDs are recommended, but Metabase accepts any unique non-empty string.\n"
+		},
+		"name": {
+			"type": "string",
+			"description": "Display name"
+		},
+		"slug": {
+			"type": "string",
+			"description": "URL-friendly identifier"
+		},
+		"type": {
+			"type": "string",
+			"description": "Filter widget type: string/=, string/!=, string/contains, string/starts-with, string/ends-with, number/=, number/!=, number/>=, number/<=, number/between, date/single, date/range, date/month-year, date/quarter-year, date/relative, date/all-options, boolean/=, temporal-unit\n"
+		},
+		"default": { "description": "Default value (type depends on filter type)" },
+		"required": {
+			"type": "boolean",
+			"description": "Whether a value is required"
+		},
+		"sectionId": {
+			"type": "string",
+			"description": "UI section grouping. Restricts which columns are available for mapping. For id — only PK and FK columns. For location — only location columns (country, city, etc.). Normally matches the first part of the parameter type.\n",
+			"enum": [
+				"string",
+				"number",
+				"date",
+				"boolean",
+				"temporal-unit",
+				"id",
+				"location"
+			]
+		},
+		"temporal_units": {
+			"type": "array",
+			"description": "Allowed temporal units (for temporal-unit type)",
+			"items": {
+				"type": "string",
+				"enum": [
+					"minute",
+					"hour",
+					"day",
+					"week",
+					"month",
+					"quarter",
+					"year"
+				]
+			}
+		},
+		"values_query_type": {
+			"type": "string",
+			"enum": [
+				"list",
+				"search",
+				"none"
+			]
+		},
+		"values_source_type": {
+			"type": ["string", "null"],
+			"enum": [
+				null,
+				"card",
+				"static-list"
+			]
+		},
+		"values_source_config": {
+			"type": "object",
+			"description": "Source configuration. For static-list: {values: [[val, label], ...]}. For card: {card_id, value_field, label_field}.\n",
+			"properties": {
+				"values": {
+					"type": "array",
+					"description": "Static list of [value, label] pairs"
+				},
+				"card_id": {
+					"type": "string",
+					"description": "Card entity_id to source values from"
+				},
+				"value_field": { "description": "Field clause for extracting values from card results" },
+				"label_field": { "description": "Field clause for extracting labels from card results" }
+			},
+			"additionalProperties": true
+		}
+	},
+	$defs: { "parameter_target": {
+		"description": "Parameter target for dashboard parameter mappings. Uses legacy MBQL format: [field, Field-FK, null-or-options].\n",
+		"type": "array",
+		"minItems": 2,
+		"allOf": [
+			{
+				"if": { "prefixItems": [{ "const": "dimension" }] },
+				"then": {
+					"prefixItems": [{ "const": "dimension" }, {
+						"type": "array",
+						"minItems": 2,
+						"allOf": [
+							{
+								"if": { "prefixItems": [{ "const": "field" }] },
+								"then": { "$ref": "ref.yaml#/$defs/legacy_field_ref" }
+							},
+							{
+								"if": { "prefixItems": [{ "const": "expression" }] },
+								"then": { "$ref": "ref.yaml#/$defs/legacy_expression_ref" }
+							},
+							{
+								"if": { "prefixItems": [{ "const": "template-tag" }] },
+								"then": {
+									"prefixItems": [{ "const": "template-tag" }, { "type": "string" }],
+									"minItems": 2,
+									"maxItems": 2
+								}
+							}
+						]
+					}],
+					"items": { "anyOf": [{
+						"type": "object",
+						"properties": { "stage-number": { "type": "integer" } }
+					}, { "type": "null" }] },
+					"maxItems": 3
+				}
+			},
+			{
+				"if": { "prefixItems": [{ "const": "variable" }] },
+				"then": {
+					"prefixItems": [{ "const": "variable" }, {
+						"type": "array",
+						"prefixItems": [{ "const": "template-tag" }, { "type": "string" }],
+						"minItems": 2,
+						"maxItems": 2
+					}],
+					"minItems": 2,
+					"maxItems": 2
+				}
+			},
+			{
+				"if": { "prefixItems": [{ "const": "text-tag" }] },
+				"then": {
+					"prefixItems": [{ "const": "text-tag" }, { "type": "string" }],
+					"minItems": 2,
+					"maxItems": 2
+				}
+			}
+		]
+	} }
+};
+//#endregion
+//#region src/core/schema/data/schemas/common/query.json
+var query_default = {
+	title: "Query",
+	description: "A query definition in serialized pMBQL format. Contains a flat list of stages (no recursive source-query nesting). Each stage is either an MBQL structured stage or a native SQL stage.\n",
+	type: "object",
+	required: [
+		"lib/type",
+		"database",
+		"stages"
+	],
+	properties: {
+		"lib/type": {
+			"type": "string",
+			"const": "mbql/query"
+		},
+		"database": { "$ref": "id.yaml#/$defs/database_id" },
+		"stages": {
+			"type": "array",
+			"minItems": 1,
+			"items": { "$ref": "#/$defs/stage" }
+		}
+	},
+	$defs: {
+		"options": {
+			"description": "Base options object for pMBQL clauses. Always present as the second element of every clause array. Empty {} when no options apply.\n",
+			"type": "object",
+			"properties": {
+				"base-type": { "type": "string" },
+				"effective-type": { "type": "string" },
+				"lib/uuid": {
+					"type": "string",
+					"format": "uuid"
+				},
+				"lib/expression-name": { "type": "string" }
+			}
+		},
+		"case_sensitive_options": {
+			"description": "Options for string filter operators.",
+			"allOf": [{ "$ref": "#/$defs/options" }, {
+				"type": "object",
+				"properties": { "case-sensitive": { "type": "boolean" } }
+			}]
+		},
+		"time_interval_options": {
+			"description": "Options for the time-interval operator.",
+			"allOf": [{ "$ref": "#/$defs/options" }, {
+				"type": "object",
+				"properties": { "include-current": { "type": "boolean" } }
+			}]
+		},
+		"datetime_parse_options": {
+			"description": "Options for the datetime parsing operator.",
+			"allOf": [{ "$ref": "#/$defs/options" }, {
+				"type": "object",
+				"properties": { "mode": {
+					"type": "string",
+					"enum": [
+						"iso",
+						"simple",
+						"unix-seconds",
+						"unix-milliseconds",
+						"unix-microseconds",
+						"unix-nanoseconds",
+						"iso-bytes",
+						"simple-bytes"
+					]
+				} }
+			}]
+		},
+		"stage": {
+			"type": "object",
+			"required": ["lib/type"],
+			"allOf": [{
+				"if": { "properties": { "lib/type": { "const": "mbql.stage/mbql" } } },
+				"then": { "$ref": "#/$defs/mbql_stage" }
+			}, {
+				"if": { "properties": { "lib/type": { "const": "mbql.stage/native" } } },
+				"then": { "$ref": "#/$defs/native_stage" }
+			}]
+		},
+		"mbql_stage": {
+			"type": "object",
+			"properties": {
+				"lib/type": { "const": "mbql.stage/mbql" },
+				"source-table": { "$ref": "id.yaml#/$defs/table_id" },
+				"source-card": { "$ref": "id.yaml#/$defs/entity_id" },
+				"joins": {
+					"type": "array",
+					"items": { "$ref": "#/$defs/join" }
+				},
+				"expressions": {
+					"type": "array",
+					"items": { "$ref": "#/$defs/expression" }
+				},
+				"fields": {
+					"type": "array",
+					"items": {
+						"type": "array",
+						"allOf": [{
+							"if": { "prefixItems": [{ "const": "field" }] },
+							"then": { "$ref": "ref.yaml#/$defs/field_ref" }
+						}, {
+							"if": { "prefixItems": [{ "const": "expression" }] },
+							"then": { "$ref": "ref.yaml#/$defs/expression_ref" }
+						}]
+					}
+				},
+				"filters": {
+					"type": "array",
+					"items": { "$ref": "#/$defs/expression" }
+				},
+				"aggregation": {
+					"type": "array",
+					"items": { "$ref": "#/$defs/expression" }
+				},
+				"breakout": {
+					"type": "array",
+					"items": { "$ref": "#/$defs/expression" }
+				},
+				"order-by": {
+					"type": "array",
+					"items": { "$ref": "#/$defs/expression" }
+				},
+				"limit": { "type": ["integer", "null"] }
+			}
+		},
+		"expression": {
+			"description": "An MBQL expression clause. Either a literal value or an array [operator, options, ...args] where options is always an object.\n",
+			"type": [
+				"string",
+				"number",
+				"boolean",
+				"null",
+				"array"
+			],
+			"if": { "type": "array" },
+			"then": {
+				"minItems": 1,
+				"allOf": [
+					{
+						"if": { "prefixItems": [{ "const": "field" }] },
+						"then": { "$ref": "ref.yaml#/$defs/field_ref" }
+					},
+					{
+						"if": { "prefixItems": [{ "const": "expression" }] },
+						"then": { "$ref": "ref.yaml#/$defs/expression_ref" }
+					},
+					{
+						"if": { "prefixItems": [{ "const": "aggregation" }] },
+						"then": { "$ref": "ref.yaml#/$defs/aggregation_ref" }
+					},
+					{
+						"if": { "prefixItems": [{ "const": "metric" }] },
+						"then": { "$ref": "ref.yaml#/$defs/metric_ref" }
+					},
+					{
+						"if": { "prefixItems": [{ "const": "measure" }] },
+						"then": { "$ref": "ref.yaml#/$defs/measure_ref" }
+					},
+					{
+						"if": { "prefixItems": [{ "const": "segment" }] },
+						"then": { "$ref": "ref.yaml#/$defs/segment_ref" }
+					},
+					{
+						"if": { "prefixItems": [{ "const": "value" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "value" },
+								{ "$ref": "#/$defs/options" },
+								{ "type": [
+									"string",
+									"number",
+									"boolean"
+								] }
+							],
+							"minItems": 3,
+							"maxItems": 3
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "enum": [
+							"+",
+							"-",
+							"*",
+							"/"
+						] }] },
+						"then": {
+							"prefixItems": [
+								{ "enum": [
+									"+",
+									"-",
+									"*",
+									"/"
+								] },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"items": { "$ref": "#/$defs/expression" },
+							"minItems": 3
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "enum": ["and", "or"] }] },
+						"then": {
+							"prefixItems": [
+								{ "enum": ["and", "or"] },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"items": { "$ref": "#/$defs/expression" },
+							"minItems": 4
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "not" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "not" },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"minItems": 3,
+							"maxItems": 3
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "enum": [
+							"=",
+							"!=",
+							"<",
+							">",
+							"<=",
+							">="
+						] }] },
+						"then": {
+							"prefixItems": [
+								{ "enum": [
+									"=",
+									"!=",
+									"<",
+									">",
+									"<=",
+									">="
+								] },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"items": { "$ref": "#/$defs/expression" },
+							"minItems": 4
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "enum": ["in", "not-in"] }] },
+						"then": {
+							"prefixItems": [
+								{ "enum": ["in", "not-in"] },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"items": { "$ref": "#/$defs/expression" },
+							"minItems": 4
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "between" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "between" },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"minItems": 5,
+							"maxItems": 5
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "inside" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "inside" },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "#/$defs/expression" },
+								{ "type": "number" },
+								{ "type": "number" },
+								{ "type": "number" },
+								{ "type": "number" }
+							],
+							"minItems": 8,
+							"maxItems": 8
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "enum": [
+							"is-null",
+							"not-null",
+							"is-empty",
+							"not-empty"
+						] }] },
+						"then": {
+							"prefixItems": [
+								{ "enum": [
+									"is-null",
+									"not-null",
+									"is-empty",
+									"not-empty"
+								] },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"minItems": 3,
+							"maxItems": 3
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "enum": [
+							"contains",
+							"does-not-contain",
+							"starts-with",
+							"ends-with"
+						] }] },
+						"then": {
+							"prefixItems": [
+								{ "enum": [
+									"contains",
+									"does-not-contain",
+									"starts-with",
+									"ends-with"
+								] },
+								{ "$ref": "#/$defs/case_sensitive_options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"items": { "$ref": "#/$defs/expression" },
+							"minItems": 4
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "time-interval" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "time-interval" },
+								{ "$ref": "#/$defs/time_interval_options" },
+								{ "$ref": "#/$defs/expression" },
+								{
+									"if": { "type": "integer" },
+									"then": { "type": "integer" },
+									"else": { "enum": [
+										"current",
+										"last",
+										"next"
+									] }
+								},
+								{ "$ref": "temporal_bucketing.yaml#/$defs/datetime_truncation_unit" }
+							],
+							"minItems": 5,
+							"maxItems": 5
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "relative-time-interval" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "relative-time-interval" },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "type": "integer" },
+								{ "$ref": "temporal_bucketing.yaml#/$defs/datetime_truncation_unit" },
+								{ "type": "integer" },
+								{ "$ref": "temporal_bucketing.yaml#/$defs/datetime_truncation_unit" }
+							],
+							"minItems": 7,
+							"maxItems": 7
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "enum": ["now", "today"] }] },
+						"then": {
+							"prefixItems": [{ "enum": ["now", "today"] }, { "$ref": "#/$defs/options" }],
+							"minItems": 2,
+							"maxItems": 2
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "interval" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "interval" },
+								{ "$ref": "#/$defs/options" },
+								{ "type": "integer" },
+								{ "$ref": "temporal_bucketing.yaml#/$defs/datetime_truncation_unit" }
+							],
+							"minItems": 4,
+							"maxItems": 4
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "enum": [
+							"abs",
+							"ceil",
+							"floor",
+							"round",
+							"sqrt",
+							"exp",
+							"log",
+							"length",
+							"trim",
+							"ltrim",
+							"rtrim",
+							"upper",
+							"lower",
+							"host",
+							"domain",
+							"subdomain",
+							"path",
+							"get-year",
+							"get-quarter",
+							"get-month",
+							"get-day",
+							"get-hour",
+							"get-minute",
+							"get-second",
+							"text",
+							"integer",
+							"float",
+							"day-name",
+							"month-name",
+							"quarter-name",
+							"date"
+						] }] },
+						"then": {
+							"prefixItems": [
+								{ "enum": [
+									"abs",
+									"ceil",
+									"floor",
+									"round",
+									"sqrt",
+									"exp",
+									"log",
+									"length",
+									"trim",
+									"ltrim",
+									"rtrim",
+									"upper",
+									"lower",
+									"host",
+									"domain",
+									"subdomain",
+									"path",
+									"get-year",
+									"get-quarter",
+									"get-month",
+									"get-day",
+									"get-hour",
+									"get-minute",
+									"get-second",
+									"text",
+									"integer",
+									"float",
+									"day-name",
+									"month-name",
+									"quarter-name",
+									"date"
+								] },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"minItems": 3,
+							"maxItems": 3
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "datetime" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "datetime" },
+								{ "$ref": "#/$defs/datetime_parse_options" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"minItems": 3,
+							"maxItems": 3
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "enum": ["get-day-of-week", "get-week"] }] },
+						"then": {
+							"prefixItems": [
+								{ "enum": ["get-day-of-week", "get-week"] },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{
+									"type": "string",
+									"enum": [
+										"iso",
+										"us",
+										"instance"
+									]
+								}
+							],
+							"minItems": 3,
+							"maxItems": 4
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "power" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "power" },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"minItems": 4,
+							"maxItems": 4
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "enum": ["replace", "split-part"] }] },
+						"then": {
+							"prefixItems": [
+								{ "enum": ["replace", "split-part"] },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"minItems": 5,
+							"maxItems": 5
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "substring" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "substring" },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"minItems": 4,
+							"maxItems": 5
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "collate" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "collate" },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "type": "string" }
+							],
+							"minItems": 4,
+							"maxItems": 4
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "regex-match-first" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "regex-match-first" },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "type": "string" }
+							],
+							"minItems": 4,
+							"maxItems": 4
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "concat" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "concat" },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"items": { "$ref": "#/$defs/expression" },
+							"minItems": 4
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "coalesce" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "coalesce" },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"items": { "$ref": "#/$defs/expression" },
+							"minItems": 4
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "enum": ["datetime-add", "datetime-subtract"] }] },
+						"then": {
+							"prefixItems": [
+								{ "enum": ["datetime-add", "datetime-subtract"] },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "type": "integer" },
+								{ "$ref": "temporal_bucketing.yaml#/$defs/datetime_truncation_unit" }
+							],
+							"minItems": 5,
+							"maxItems": 5
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "datetime-diff" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "datetime-diff" },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "#/$defs/datetime_diff_unit" }
+							],
+							"minItems": 5,
+							"maxItems": 5
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "convert-timezone" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "convert-timezone" },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "type": "string" },
+								{ "type": "string" }
+							],
+							"minItems": 4,
+							"maxItems": 5
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "temporal-extract" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "temporal-extract" },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "temporal_bucketing.yaml#/$defs/datetime_extraction_unit" },
+								{
+									"type": "string",
+									"enum": [
+										"iso",
+										"us",
+										"instance"
+									]
+								}
+							],
+							"minItems": 4,
+							"maxItems": 5
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "enum": ["count", "cum-count"] }] },
+						"then": {
+							"prefixItems": [{ "enum": ["count", "cum-count"] }, { "$ref": "#/$defs/options" }],
+							"items": { "$ref": "#/$defs/expression" },
+							"minItems": 2,
+							"maxItems": 3
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "enum": [
+							"sum",
+							"avg",
+							"min",
+							"max",
+							"distinct",
+							"stddev",
+							"var",
+							"median",
+							"cum-sum"
+						] }] },
+						"then": {
+							"prefixItems": [
+								{ "enum": [
+									"sum",
+									"avg",
+									"min",
+									"max",
+									"distinct",
+									"stddev",
+									"var",
+									"median",
+									"cum-sum"
+								] },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"minItems": 3,
+							"maxItems": 3
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "percentile" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "percentile" },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "type": "number" }
+							],
+							"minItems": 4,
+							"maxItems": 4
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "enum": ["count-where", "share"] }] },
+						"then": {
+							"prefixItems": [
+								{ "enum": ["count-where", "share"] },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"minItems": 3,
+							"maxItems": 3
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "enum": ["sum-where", "distinct-where"] }] },
+						"then": {
+							"prefixItems": [
+								{ "enum": ["sum-where", "distinct-where"] },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"minItems": 4,
+							"maxItems": 4
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "enum": ["case", "if"] }] },
+						"then": {
+							"prefixItems": [
+								{ "enum": ["case", "if"] },
+								{ "$ref": "#/$defs/options" },
+								{
+									"type": "array",
+									"items": {
+										"type": "array",
+										"prefixItems": [{ "$ref": "#/$defs/expression" }, { "$ref": "#/$defs/expression" }],
+										"minItems": 2,
+										"maxItems": 2
+									}
+								},
+								{ "$ref": "#/$defs/expression" }
+							],
+							"minItems": 3,
+							"maxItems": 4
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "const": "offset" }] },
+						"then": {
+							"prefixItems": [
+								{ "const": "offset" },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" },
+								{ "type": "integer" }
+							],
+							"minItems": 4,
+							"maxItems": 4
+						}
+					},
+					{
+						"if": { "prefixItems": [{ "enum": ["asc", "desc"] }] },
+						"then": {
+							"prefixItems": [
+								{ "enum": ["asc", "desc"] },
+								{ "$ref": "#/$defs/options" },
+								{ "$ref": "#/$defs/expression" }
+							],
+							"minItems": 3,
+							"maxItems": 3
+						}
+					}
+				]
+			}
+		},
+		"datetime_diff_unit": {
+			"type": "string",
+			"enum": [
+				"second",
+				"minute",
+				"hour",
+				"day",
+				"week",
+				"month",
+				"quarter",
+				"year"
+			]
+		},
+		"join": {
+			"type": "object",
+			"required": [
+				"stages",
+				"conditions",
+				"alias"
+			],
+			"properties": {
+				"stages": {
+					"type": "array",
+					"minItems": 1,
+					"items": { "$ref": "#/$defs/stage" }
+				},
+				"conditions": {
+					"type": "array",
+					"minItems": 1,
+					"items": { "$ref": "#/$defs/expression" }
+				},
+				"alias": { "type": "string" },
+				"strategy": {
+					"type": "string",
+					"enum": [
+						"left-join",
+						"right-join",
+						"inner-join",
+						"full-join"
+					]
+				},
+				"fields": {
+					"if": { "type": "string" },
+					"then": { "enum": ["all", "none"] },
+					"else": {
+						"type": "array",
+						"items": { "$ref": "#/$defs/expression" }
+					}
+				}
+			}
+		},
+		"native_stage": {
+			"type": "object",
+			"required": ["lib/type", "native"],
+			"properties": {
+				"lib/type": { "const": "mbql.stage/native" },
+				"native": { "type": "string" },
+				"template-tags": {
+					"type": "object",
+					"additionalProperties": { "$ref": "#/$defs/template_tag" }
+				}
+			}
+		},
+		"template_tag": {
+			"type": "object",
+			"required": [
+				"type",
+				"name",
+				"id"
+			],
+			"properties": {
+				"type": {
+					"type": "string",
+					"enum": [
+						"text",
+						"number",
+						"date",
+						"boolean",
+						"dimension",
+						"temporal-unit",
+						"card",
+						"snippet",
+						"table"
+					]
+				},
+				"name": { "type": "string" },
+				"id": {
+					"type": "string",
+					"format": "uuid"
+				},
+				"display-name": { "type": "string" },
+				"default": { "description": "Default value (type depends on tag type)" },
+				"required": { "type": "boolean" }
+			},
+			"allOf": [
+				{
+					"if": { "properties": { "type": { "const": "dimension" } } },
+					"then": {
+						"required": ["dimension", "widget-type"],
+						"properties": {
+							"dimension": { "$ref": "#/$defs/expression" },
+							"widget-type": { "type": "string" },
+							"options": { "type": "object" },
+							"alias": { "type": "string" }
+						}
+					}
+				},
+				{
+					"if": { "properties": { "type": { "const": "temporal-unit" } } },
+					"then": {
+						"required": ["dimension"],
+						"properties": {
+							"dimension": { "$ref": "#/$defs/expression" },
+							"alias": { "type": "string" }
+						}
+					}
+				},
+				{
+					"if": { "properties": { "type": { "const": "card" } } },
+					"then": {
+						"required": ["card-id"],
+						"properties": { "card-id": { "$ref": "id.yaml#/$defs/entity_id" } }
+					}
+				},
+				{
+					"if": { "properties": { "type": { "const": "snippet" } } },
+					"then": {
+						"required": ["snippet-name", "snippet-id"],
+						"properties": {
+							"snippet-name": { "type": "string" },
+							"snippet-id": { "$ref": "id.yaml#/$defs/entity_id" }
+						}
+					}
+				},
+				{
+					"if": { "properties": { "type": { "const": "table" } } },
+					"then": {
+						"required": ["table-id"],
+						"properties": {
+							"table-id": { "$ref": "id.yaml#/$defs/table_id" },
+							"emit-alias": { "type": "boolean" }
+						}
+					}
+				}
+			]
+		}
+	}
+};
+//#endregion
+//#region src/core/schema/data/schemas/common/ref.json
+var ref_default = {
+	title: "Ref",
+	description: "Column and entity reference types used in MBQL expressions, parameter mappings, and visualization settings. Options are always the second element (an object, never null).\n",
+	$defs: {
+		"field_options": {
+			"description": "Options for field refs.",
+			"allOf": [{ "$ref": "query.yaml#/$defs/options" }, {
+				"type": "object",
+				"properties": {
+					"temporal-unit": { "$ref": "temporal_bucketing.yaml#/$defs/datetime_bucketing_unit" },
+					"join-alias": { "type": "string" },
+					"binning": {
+						"type": "object",
+						"required": ["strategy"],
+						"properties": { "strategy": {
+							"type": "string",
+							"enum": [
+								"default",
+								"num-bins",
+								"bin-width"
+							]
+						} },
+						"allOf": [{
+							"if": { "properties": { "strategy": { "const": "bin-width" } } },
+							"then": {
+								"required": ["bin-width"],
+								"properties": { "bin-width": {
+									"type": "number",
+									"exclusiveMinimum": 0
+								} }
+							}
+						}, {
+							"if": { "properties": { "strategy": { "const": "num-bins" } } },
+							"then": {
+								"required": ["num-bins"],
+								"properties": { "num-bins": {
+									"type": "integer",
+									"minimum": 1
+								} }
+							}
+						}]
+					},
+					"source-field": { "$ref": "id.yaml#/$defs/field_id" },
+					"source-field-name": { "type": "string" },
+					"source-field-join-alias": { "type": "string" }
+				}
+			}]
+		},
+		"field_ref": {
+			"description": "[field, options, Field-FK-or-name]",
+			"type": "array",
+			"prefixItems": [
+				{ "const": "field" },
+				{ "$ref": "#/$defs/field_options" },
+				{
+					"if": { "type": "array" },
+					"then": { "$ref": "id.yaml#/$defs/field_id" }
+				}
+			],
+			"minItems": 3,
+			"maxItems": 3
+		},
+		"expression_ref": {
+			"description": "[expression, options, name]",
+			"type": "array",
+			"prefixItems": [
+				{ "const": "expression" },
+				{ "$ref": "query.yaml#/$defs/options" },
+				{ "type": "string" }
+			],
+			"minItems": 3,
+			"maxItems": 3
+		},
+		"aggregation_ref": {
+			"description": "[aggregation, options, uuid] — uuid matches the lib/uuid on the aggregation clause",
+			"type": "array",
+			"prefixItems": [
+				{ "const": "aggregation" },
+				{ "$ref": "query.yaml#/$defs/options" },
+				{
+					"type": "string",
+					"format": "uuid"
+				}
+			],
+			"minItems": 3,
+			"maxItems": 3
+		},
+		"metric_ref": {
+			"description": "[metric, options, entity_id]",
+			"type": "array",
+			"prefixItems": [
+				{ "const": "metric" },
+				{ "$ref": "query.yaml#/$defs/options" },
+				{ "type": "string" }
+			],
+			"minItems": 3,
+			"maxItems": 3
+		},
+		"measure_ref": {
+			"description": "[measure, options, entity_id]",
+			"type": "array",
+			"prefixItems": [
+				{ "const": "measure" },
+				{ "$ref": "query.yaml#/$defs/options" },
+				{ "type": "string" }
+			],
+			"minItems": 3,
+			"maxItems": 3
+		},
+		"segment_ref": {
+			"description": "[segment, options, entity_id]",
+			"type": "array",
+			"prefixItems": [
+				{ "const": "segment" },
+				{ "$ref": "query.yaml#/$defs/options" },
+				{ "type": "string" }
+			],
+			"minItems": 3,
+			"maxItems": 3
+		},
+		"legacy_field_ref": {
+			"description": "[field, Field-FK-or-name, null-or-options] — legacy format used in parameter targets",
+			"type": "array",
+			"prefixItems": [
+				{ "const": "field" },
+				{
+					"if": { "type": "array" },
+					"then": { "$ref": "id.yaml#/$defs/field_id" }
+				},
+				{ "type": ["object", "null"] }
+			],
+			"minItems": 3,
+			"maxItems": 3
+		},
+		"legacy_expression_ref": {
+			"description": "[expression, name] or [expression, name, null-or-options] — legacy format used in parameter targets",
+			"type": "array",
+			"prefixItems": [
+				{ "const": "expression" },
+				{ "type": "string" },
+				{ "type": ["object", "null"] }
+			],
+			"minItems": 2,
+			"maxItems": 3
+		}
+	}
+};
+//#endregion
+//#region src/core/schema/data/schemas/common/temporal_bucketing.json
+var temporal_bucketing_default = {
+	title: "Temporal Bucketing",
+	description: "Datetime truncation, extraction, and bucketing unit definitions.",
+	$defs: {
+		"datetime_truncation_unit": {
+			"description": "Truncation units — truncate a datetime to a boundary. Also used for intervals and datetime arithmetic.\n",
+			"type": "string",
+			"enum": [
+				"millisecond",
+				"second",
+				"minute",
+				"hour",
+				"day",
+				"week",
+				"month",
+				"quarter",
+				"year"
+			]
+		},
+		"datetime_extraction_unit": {
+			"description": "Extraction units — extract a numeric component from a datetime.\n",
+			"type": "string",
+			"enum": [
+				"second-of-minute",
+				"minute-of-hour",
+				"hour-of-day",
+				"day-of-week",
+				"day-of-week-iso",
+				"day-of-month",
+				"day-of-year",
+				"week-of-year",
+				"week-of-year-iso",
+				"week-of-year-us",
+				"week-of-year-instance",
+				"month-of-year",
+				"quarter-of-year",
+				"year-of-era"
+			]
+		},
+		"datetime_bucketing_unit": {
+			"description": "All datetime units — truncation + extraction + default. Used for field temporal-unit option.\n",
+			"anyOf": [
+				{ "const": "default" },
+				{ "$ref": "#/$defs/datetime_truncation_unit" },
+				{ "$ref": "#/$defs/datetime_extraction_unit" }
+			]
+		}
+	}
+};
+//#endregion
+//#region src/core/schema/validate.ts
+const ValidationIssue = z.object({
+	path: z.string(),
+	message: z.string()
+});
+z.object({
+	ok: z.boolean(),
+	errors: z.array(ValidationIssue)
+});
+const POSITIVE_INTEGER = {
+	type: "integer",
+	minimum: 1
+};
+const idSchema = {
+	title: "ID",
+	description: "MBQL identifier $defs — every id is a positive integer.",
+	$defs: {
+		entity_id: POSITIVE_INTEGER,
+		user_id: POSITIVE_INTEGER,
+		database_id: POSITIVE_INTEGER,
+		table_id: POSITIVE_INTEGER,
+		field_id: POSITIVE_INTEGER
+	}
+};
+let validator = null;
+function getValidator() {
+	if (validator !== null) return validator;
+	const ajv = new Ajv2020({
+		allErrors: true,
+		strictTuples: false,
+		allowUnionTypes: true
+	});
+	addFormats(ajv);
+	ajv.addSchema(idSchema, "id.yaml");
+	ajv.addSchema(parameter_default, "parameter.yaml");
+	ajv.addSchema(ref_default, "ref.yaml");
+	ajv.addSchema(temporal_bucketing_default, "temporal_bucketing.yaml");
+	ajv.addSchema(query_default, "query.yaml");
+	const compiled = ajv.getSchema("query.yaml");
+	if (compiled === void 0) throw new Error("internal: query.yaml validator not registered");
+	validator = compiled;
+	return validator;
+}
+const UUID_HINT_MESSAGE = "must be a UUID v4 (RFC 4122) — run `mb uuid` (or `mb uuid --count N`) to mint one. The MBQL 5 schema rejects placeholder strings (`a1`, `uuid-1`, etc.); agents must call the CLI for UUIDs rather than authoring them.";
+const FIELD_SLOT1_HINT_MESSAGE = "must be the field options object — MBQL 5 field refs are [\"field\", {options}, fieldId]; the legacy MBQL 4 shape [\"field\", id, opts] is not accepted here. (Tip: `mb uuid` mints `lib/uuid` strings if you need them.)";
+function clauseSlot1HintMessage(operator, slot1) {
+	return `must be the clause options object — every MBQL 5 clause is ["${operator}", {options}, ...args]; got ${describeJsonValue(slot1)} at index 1`;
+}
+const FormatErrorParams = z.object({ format: z.string() });
+function isUuidFormatIssue(issue) {
+	if (issue.keyword !== "format") return false;
+	const parsed = FormatErrorParams.safeParse(issue.params);
+	return parsed.success && parsed.data.format === "uuid";
+}
+function runValidator(validatorFn, value) {
+	if (validatorFn(value)) return {
+		ok: true,
+		errors: []
+	};
+	const overrides = collectMessageOverrides(value);
+	return {
+		ok: false,
+		errors: (validatorFn.errors ?? []).map((issue) => {
+			if (issue.message === void 0) throw new Error(`Ajv issue at ${issue.instancePath} has no message`);
+			const path = issue.instancePath === "" ? "/" : issue.instancePath;
+			if (isUuidFormatIssue(issue)) return {
+				path,
+				message: UUID_HINT_MESSAGE
+			};
+			return {
+				path,
+				message: overrides.get(path) ?? issue.message
+			};
+		})
+	};
+}
+function collectMessageOverrides(root) {
+	const overrides = /* @__PURE__ */ new Map();
+	visit(root, "");
+	return overrides;
+	function visit(node, path) {
+		if (Array.isArray(node)) {
+			const slot1 = clauseSlot1Message(node);
+			if (slot1 !== null) overrides.set(`${path}/1`, slot1);
+			const slot2 = refSlot2Message(node);
+			if (slot2 !== null) overrides.set(`${path}/2`, slot2);
+			for (let index = 0; index < node.length; index += 1) visit(node[index], `${path}/${index}`);
+			return;
+		}
+		if (!isPlainObject(node)) return;
+		for (const key of Object.keys(node)) visit(node[key], `${path}/${escapeJsonPointerSegment(key)}`);
+	}
+}
+function clauseSlot1Message(clause) {
+	if (clause.length < 2) return null;
+	const operator = clause[0];
+	if (typeof operator !== "string") return null;
+	const slot1 = clause[1];
+	if (isPlainObject(slot1)) return null;
+	if (operator === "field") return FIELD_SLOT1_HINT_MESSAGE;
+	return clauseSlot1HintMessage(operator, slot1);
+}
+function refSlot2Message(clause) {
+	if (clause.length !== 3) return null;
+	const kind = clause[0];
+	if (typeof kind !== "string") return null;
+	if (typeof clause[2] === "string") return null;
+	return refHintForKind(kind);
+}
+function refHintForKind(kind) {
+	switch (kind) {
+		case "aggregation": return "must be the target aggregation's lib/uuid (string), not a numeric position";
+		case "expression": return "must be the target expression's name (string), not a numeric position";
+		default: return null;
+	}
+}
+function describeJsonValue(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	if (typeof value === "string") return `string ${JSON.stringify(value)}`;
+	if (typeof value === "number" || typeof value === "boolean") return `${typeof value} ${String(value)}`;
+	return typeof value;
+}
+function validateQuery(value) {
+	return runValidator(getValidator(), value);
+}
+function isMbql5Query(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	return "lib/type" in value && value["lib/type"] === "mbql/query";
+}
+function isLegacyEnvelopeWrappingMbql5(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	if (!("type" in value) || value["type"] !== "query") return false;
+	if (!("query" in value)) return false;
+	const inner = value["query"];
+	if (typeof inner !== "object" || inner === null || Array.isArray(inner)) return false;
+	return "lib/type" in inner && inner["lib/type"] === "mbql/query";
+}
+function assertNotLegacyEnvelopeWrappingMbql5(value, options) {
+	if (!isLegacyEnvelopeWrappingMbql5(value)) return;
+	throw new ConfigError(`${options.contextLabel}: MBQL 5 query nested inside a legacy {type:"query", query:…} envelope. For MBQL 5, ${options.bodyNoun} is the mbql/query value itself: {"lib/type":"mbql/query", database:N, stages:[…]}.`);
+}
+z.object({
+	schema: z.unknown(),
+	defs: z.object({
+		"id.yaml": z.unknown(),
+		"parameter.yaml": z.unknown(),
+		"ref.yaml": z.unknown(),
+		"temporal_bucketing.yaml": z.unknown()
+	})
+});
+function getQuerySchemaBundle() {
+	return {
+		schema: query_default,
+		defs: {
+			"id.yaml": idSchema,
+			"parameter.yaml": parameter_default,
+			"ref.yaml": ref_default,
+			"temporal_bucketing.yaml": temporal_bucketing_default
+		}
+	};
+}
+//#endregion
+export { validateQuery as i, getQuerySchemaBundle as n, isMbql5Query as r, assertNotLegacyEnvelopeWrappingMbql5 as t };