@metabase/cli 0.1.0 → 0.1.1

package/dist/validate-DCYx6jdL.mjs

@@ -0,0 +1,1496 @@
+import { ConfigError, escapeJsonPointerSegment, isPlainObject } from "./predicates-DiIiS3k7.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 title$3 = "Parameter";
+var description$3 = "A filter control parameter for cards and dashboards. Parameters allow users to interactively filter data via UI controls.\n";
+var type$1 = "object";
+var required$1 = [
+	"id",
+	"name",
+	"slug",
+	"type"
+];
+var properties$1 = {
+	"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
+	}
+};
+var $defs$3 = { "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
+			}
+		}
+	]
+} };
+var parameter_default = {
+	title: title$3,
+	description: description$3,
+	type: type$1,
+	required: required$1,
+	properties: properties$1,
+	$defs: $defs$3
+};
+
+//#endregion
+//#region src/core/schema/data/schemas/common/query.json
+var title$2 = "Query";
+var description$2 = "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";
+var type = "object";
+var required = [
+	"lib/type",
+	"database",
+	"stages"
+];
+var properties = {
+	"lib/type": {
+		"type": "string",
+		"const": "mbql/query"
+	},
+	"database": { "$ref": "id.yaml#/$defs/database_id" },
+	"stages": {
+		"type": "array",
+		"minItems": 1,
+		"items": { "$ref": "#/$defs/stage" }
+	}
+};
+var $defs$2 = {
+	"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" }
+					}
+				}
+			}
+		]
+	}
+};
+var query_default = {
+	title: title$2,
+	description: description$2,
+	type,
+	required,
+	properties,
+	$defs: $defs$2
+};
+
+//#endregion
+//#region src/core/schema/data/schemas/common/ref.json
+var title$1 = "Ref";
+var description$1 = "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";
+var $defs$1 = {
+	"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
+	}
+};
+var ref_default = {
+	title: title$1,
+	description: description$1,
+	$defs: $defs$1
+};
+
+//#endregion
+//#region src/core/schema/data/schemas/common/temporal_bucketing.json
+var title = "Temporal Bucketing";
+var description = "Datetime truncation, extraction, and bucketing unit definitions.";
+var $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" }
+		]
+	}
+};
+var temporal_bucketing_default = {
+	title,
+	description,
+	$defs
+};
+
+//#endregion
+//#region src/core/schema/validate.ts
+const ValidationIssue = z.object({
+	path: z.string(),
+	message: z.string()
+});
+const ValidationOutcome = 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 `metabase uuid` (or `metabase 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: `metabase 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);
+	const issues = validatorFn.errors ?? [];
+	const errors = issues.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
+		};
+		const overridden = overrides.get(path);
+		return {
+			path,
+			message: overridden ?? issue.message
+		};
+	});
+	return {
+		ok: false,
+		errors
+	};
+}
+function collectMessageOverrides(root) {
+	const overrides = 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:[…]}.`);
+}
+const QuerySchemaBundle = 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 { assertNotLegacyEnvelopeWrappingMbql5, getQuerySchemaBundle, isMbql5Query, validateQuery };