@astrato-io/visualizations 0.0.0-stage → 0.6.4

package/chunks/src-BC7cGcJ-.js

@@ -0,0 +1,2024 @@
+import { La as e, Xs as t, Ya as n, ds as r } from "./interfaces-VUY4_yVO.js";
+import { hn as i } from "./event-bus-KiSiCJrC.js";
+import { t as a } from "./gauge-target-type-BkKXAqkX.js";
+import { Au as o, Dd as s, Kd as c, Lu as l, Mu as u, Od as d, Pd as ee, Pu as te, Sd as ne, _d as re, ad as ie, bd as ae, cd as oe, dd as se, fd as ce, jd as f, kd as le, nd as ue, td as de, ud as fe, yd as pe } from "./src-Dun_jXtz.js";
+import { C as me, S as p, _ as m, b as he, f as ge, v as _e, x as ve } from "./src-C0LgoUWY.js";
+import { $ as ye, A as be, B as xe, C as Se, F as Ce, G as we, H as Te, I as Ee, J as De, K as Oe, L as h, M as ke, N as Ae, P as je, Q as Me, R as Ne, S as Pe, U as g, V as Fe, W as Ie, X as Le, Y as Re, Z as ze, _ as Be, a as Ve, c as He, d as _, et as Ue, f as We, g as v, h as y, i as Ge, j as b, k as Ke, n as qe, nt as Je, o as Ye, q as Xe, r as Ze, rt as Qe, s as $e, t as x, tt as et, u as S, v as C, w, x as tt, y as T, z as E } from "./shared-CKDL4hx9.js";
+import { a as nt, i as D, o as O, r as rt, t as it } from "./data-item-resolution-1lvYB5ln.js";
+import { z as k } from "zod";
+var at = async (e) => (await import("./app-filter-bar.compiler-j_CVoWTa.js")).compileAppFilterBarVisualizationDefinition(e), ot = async (e) => (await import("./bar.compiler-oqaPzIut.js")).compileBarVisualizationDefinition(e), st = async (e) => (await import("./filter.compiler-CuLtc_02.js")).compileFilterVisualizationDefinition(e), ct = async (e) => (await import("./line.compiler-BpA_6Tc7.js")).compileLineVisualizationDefinition(e), lt = async (e) => (await import("./number.compiler-DbkWcG4S.js")).compileNumberVisualizationDefinition(e), ut = async (e) => (await import("./table.compiler-BrXkm4Fz.js")).compileTableVisualizationDefinition(e), dt = (e, ...t) => e, A = {
+	horsepower: "[Cars].[Horsepower]",
+	latestLaunch: "[Cars].[Latest Launch]",
+	manufacturer: "[Cars].[Manufacturer]",
+	model: "[Cars].[Model]",
+	sales: "[Cars].[Sales In Thousands]"
+}, j = (e, t) => ({
+	fieldKey: t,
+	format: { formatType: "none" },
+	ref: e
+}), M = (e, t) => ({
+	fieldKey: t,
+	ref: e
+}), N = (e, t = A.sales, n = "SUM") => ({
+	aggregation: n,
+	fieldKey: t,
+	format: {
+		formatType: "number2Decimal",
+		negativeType: "parenthesis"
+	},
+	ref: e
+}), P = {
+	filters: [{
+		fieldKey: A.manufacturer,
+		operator: "inList",
+		values: [
+			"Acura",
+			"Audi",
+			"BMW"
+		]
+	}],
+	operator: "and"
+}, F = {
+	position: "right",
+	title: "Cars comparison",
+	visible: !0
+}, I = {
+	dimension: {
+		labelsVisible: !0,
+		title: "Manufacturer",
+		titleVisible: !0
+	},
+	primaryMeasure: {
+		labelsVisible: !0,
+		title: "Sales",
+		titleVisible: !0
+	},
+	secondaryMeasure: {
+		labelsVisible: !0,
+		title: "Horsepower",
+		titleVisible: !0
+	}
+}, ft = {
+	dimension: {
+		labelsVisible: !0,
+		title: "Manufacturer",
+		titleVisible: !0
+	},
+	primaryMeasure: {
+		labelsVisible: !0,
+		title: "Sales",
+		titleVisible: !0
+	},
+	secondaryDimension: {
+		labelsVisible: !0,
+		title: "Model",
+		titleVisible: !0
+	}
+}, pt = {
+	dimension: {
+		labelsVisible: !0,
+		title: "Manufacturer",
+		titleVisible: !0
+	},
+	primaryMeasure: {
+		labelsVisible: !0,
+		title: "Sales",
+		titleVisible: !0
+	}
+}, mt = {
+	dimension: {
+		labelsVisible: !0,
+		title: "Horsepower",
+		titleVisible: !0
+	},
+	primaryMeasure: {
+		labelsVisible: !0,
+		title: "Count",
+		titleVisible: !0
+	}
+}, ht = {
+	primaryMeasure: {
+		labelsVisible: !0,
+		title: "Sales",
+		titleVisible: !0
+	},
+	secondaryMeasure: {
+		labelsVisible: !0,
+		title: "Horsepower",
+		titleVisible: !0
+	}
+}, gt = {
+	dimension: {
+		labelsVisible: !0,
+		title: "Measure",
+		titleVisible: !0
+	},
+	primaryMeasure: {
+		labelsVisible: !0,
+		title: "Value",
+		titleVisible: !0
+	}
+}, L = "presentation.axes.primaryMeasure.bands shades the plot between two primary measure axis values; start and end are measure values, and the bands replace any on the base vSpec.", R = [
+	"dimensions",
+	"filters",
+	"measures",
+	"value-formatting"
+], _t = dt([
+	{
+		additionalExamples: [{
+			definition: {
+				data: {
+					dimensions: [j("manufacturer", A.manufacturer)],
+					measures: [N("sales")]
+				},
+				presentation: { coloring: {
+					overwrites: [{
+						color: "#0F766E",
+						value: "Audi"
+					}, {
+						color: "#D97706",
+						operator: "inList",
+						values: ["BMW", "Buick"]
+					}],
+					rules: [{
+						color: "#DC2626",
+						measure: "sales",
+						operator: "less",
+						value: 20
+					}]
+				} },
+				type: "bar",
+				version: 1
+			},
+			title: "Colors bound to dimension values and a measure threshold"
+		}],
+		documentation: {
+			constraints: [
+				"Sorting and Top N refer to definition-local refs, not generated data-item IDs.",
+				"Every dimension and measure must resolve to an available field with a compatible role.",
+				"Set axis per measure to plot it against the primary or the secondary measure axis.",
+				L,
+				"Set range on a measure axis to fix its min, max, or both, for example to give several charts one shared scale; leave both unset and set startsAtZero to keep an auto-fitted axis anchored at zero. Set inverted on a measure axis to reverse its values, for example to put rank 1 at the top.",
+				"Set scale to log on a measure axis to draw it logarithmically, with gridlines at powers of ten. Zero and negative values are drawn at the floor of a log axis."
+			],
+			dataRequirements: ["At least one dimension.", "At least one measure."],
+			summary: "Categorical comparison chart with sorting, limiting, per-measure axes, labels, and orientation controls.",
+			title: "Bar chart"
+		},
+		example: {
+			data: {
+				dimensions: [{
+					...j("manufacturer", A.manufacturer),
+					showNullValues: !1
+				}],
+				measures: [{
+					...N("sales"),
+					dataLabels: {
+						placements: ["outside", "inside"],
+						visible: !0
+					}
+				}]
+			},
+			filterGroup: P,
+			limiting: {
+				queryLimit: 100,
+				topN: {
+					by: "sales",
+					count: 10,
+					direction: "desc",
+					showOthers: !1
+				}
+			},
+			presentation: {
+				axes: {
+					...I,
+					primaryMeasure: {
+						...I.primaryMeasure,
+						bands: [{
+							color: "#E6E6E6",
+							end: 15e4,
+							label: "Target range",
+							start: 1e5
+						}]
+					}
+				},
+				legend: F,
+				orientation: "vertical"
+			},
+			sorting: [{
+				by: "sales",
+				direction: "desc"
+			}],
+			type: "bar",
+			version: 1
+		},
+		supportedFeatures: [
+			"axes",
+			"axis-bands",
+			"axis-range",
+			"axis-scale",
+			"conditional-coloring",
+			"data-labels",
+			"dimensions",
+			"filters",
+			"legend",
+			"measure-axis",
+			"measures",
+			"orientation",
+			"query-limit",
+			"sorting",
+			"top-n",
+			"value-formatting"
+		],
+		type: "bar"
+	},
+	{
+		documentation: {
+			constraints: [
+				"The single dimension is assigned the combo category role.",
+				"Set seriesType per measure to create bar, line, or point series; omission keeps the existing line default.",
+				"Data labels apply only to bar series.",
+				"Sorting refers to definition-local refs, not generated data-item IDs.",
+				"Set axis per measure to plot it against the primary or the secondary measure axis. Bar series share one axis: state it on any bar measure, and every bar measure that states one must state the same axis.",
+				L,
+				"Set range on a measure axis to fix its min, max, or both, for example to give several charts one shared scale; leave both unset and set startsAtZero to keep an auto-fitted axis anchored at zero. Set inverted on a measure axis to reverse its values, for example to put rank 1 at the top.",
+				"Set scale to log on a measure axis to draw it logarithmically, with gridlines at powers of ten. Zero and negative values are drawn at the floor of a log axis."
+			],
+			dataRequirements: ["Exactly one dimension.", "Between one and ten measures."],
+			summary: "Combined categorical chart supporting multiple measures, per-measure axes, sorting, limiting, labels, legend, and orientation.",
+			title: "Combo chart"
+		},
+		example: {
+			data: {
+				dimensions: [j("manufacturer", A.manufacturer)],
+				measures: [{
+					...N("sales"),
+					dataLabels: { visible: !0 },
+					seriesType: "bar"
+				}, {
+					...N("horsepower", A.horsepower, "AVG"),
+					axis: "secondary",
+					seriesType: "line"
+				}]
+			},
+			filterGroup: P,
+			limiting: { queryLimit: 100 },
+			presentation: {
+				axes: pt,
+				dataLabels: { visible: !0 },
+				legend: F,
+				orientation: "vertical"
+			},
+			sorting: [{
+				by: "sales",
+				direction: "desc"
+			}],
+			type: "combo",
+			version: 1
+		},
+		supportedFeatures: [
+			...R,
+			"axes",
+			"axis-bands",
+			"axis-range",
+			"axis-scale",
+			"data-labels",
+			"legend",
+			"measure-axis",
+			"orientation",
+			"query-limit",
+			"series-type",
+			"sorting"
+		],
+		type: "combo"
+	},
+	{
+		documentation: {
+			constraints: ["All measures are assigned the gauge-value role.", "Distribution definitions enable the established gauge comparison mode."],
+			dataRequirements: ["Zero or one dimension.", "Between one and twenty measures."],
+			summary: "Gauge distribution across one or more values, optionally grouped by a dimension.",
+			title: "Distribution gauge"
+		},
+		example: {
+			data: {
+				dimensions: [j("manufacturer", A.manufacturer)],
+				measures: [N("sales"), N("averageSales", A.sales, "AVG")]
+			},
+			filterGroup: P,
+			presentation: {
+				displayMode: "bar",
+				legend: F
+			},
+			type: "distribution-gauge",
+			version: 1
+		},
+		supportedFeatures: [
+			...R,
+			"conditional-coloring",
+			"display-mode",
+			"legend"
+		],
+		type: "distribution-gauge"
+	},
+	{
+		documentation: {
+			constraints: ["Dimension order is significant and maps to the two dot-chart dimension roles.", "Set range on the primary measure axis to fix its min, max, or both, for example to give several charts one shared scale; leave both unset and set startsAtZero to keep an auto-fitted axis anchored at zero. Set inverted on the primary measure axis to reverse its values."],
+			dataRequirements: ["Exactly two dimensions.", "Exactly one measure."],
+			summary: "Dot comparison using two categorical dimensions and one measure.",
+			title: "Dot chart"
+		},
+		example: {
+			data: {
+				dimensions: [j("manufacturer", A.manufacturer), j("model", A.model)],
+				measures: [N("sales")]
+			},
+			filterGroup: P,
+			presentation: {
+				axes: pt,
+				legend: F,
+				orientation: "horizontal"
+			},
+			type: "dot",
+			version: 1
+		},
+		supportedFeatures: [
+			...R,
+			"conditional-coloring",
+			"axes",
+			"axis-range",
+			"legend",
+			"orientation"
+		],
+		type: "dot"
+	},
+	{
+		documentation: {
+			constraints: [
+				"With a dimension, the first measure is the gauge value and the optional second measure is the target.",
+				"Without a dimension, supplied measures are gauge values.",
+				"When a target measure is supplied, the compiler enables the established data-target mode."
+			],
+			dataRequirements: ["Zero or one dimension.", "Between one and twenty measures; with one dimension, at most two measures."],
+			summary: "Gauge values with an optional grouping dimension and optional data target.",
+			title: "Gauge chart"
+		},
+		example: {
+			data: {
+				dimensions: [j("manufacturer", A.manufacturer)],
+				measures: [N("sales"), N("targetSales", A.sales, "AVG")]
+			},
+			filterGroup: P,
+			presentation: {
+				displayMode: "radial",
+				legend: F
+			},
+			type: "gauge",
+			version: 1
+		},
+		supportedFeatures: [
+			...R,
+			"conditional-coloring",
+			"display-mode",
+			"legend"
+		],
+		type: "gauge"
+	},
+	{
+		documentation: {
+			constraints: ["Dimension order maps to horizontal then vertical roles.", "Measure order maps to color then optional size roles."],
+			dataRequirements: ["Exactly two dimensions.", "One or two measures."],
+			summary: "Two-dimensional matrix colored and optionally sized by measures.",
+			title: "Heat map"
+		},
+		example: {
+			data: {
+				dimensions: [j("manufacturer", A.manufacturer), j("model", A.model)],
+				measures: [N("sales"), N("horsepower", A.horsepower, "AVG")]
+			},
+			filterGroup: P,
+			limiting: { queryLimit: 100 },
+			presentation: {
+				axes: ft,
+				legend: F
+			},
+			sorting: [{
+				by: "sales",
+				direction: "desc"
+			}],
+			type: "heatMap",
+			version: 1
+		},
+		supportedFeatures: [
+			...R,
+			"conditional-coloring",
+			"axes",
+			"legend",
+			"query-limit",
+			"sorting"
+		],
+		type: "heatMap"
+	},
+	{
+		documentation: {
+			constraints: [
+				"The compiler creates the canonical generated count measure; callers do not provide measures.",
+				L,
+				"Set range on the primary measure axis to fix its min, max, or both, for example to give several charts one shared scale; leave both unset and set startsAtZero to keep an auto-fitted axis anchored at zero. Set inverted on the primary measure axis to reverse its values."
+			],
+			dataRequirements: ["Exactly one numeric dimension.", "No caller-supplied measures."],
+			summary: "Distribution of a numeric field into generated bins and counts.",
+			title: "Histogram"
+		},
+		example: {
+			data: { dimensions: [j("horsepower", A.horsepower)] },
+			filterGroup: P,
+			presentation: {
+				axes: mt,
+				legend: F,
+				orientation: "vertical"
+			},
+			type: "histogram",
+			version: 1
+		},
+		supportedFeatures: [
+			"axes",
+			"axis-bands",
+			"axis-range",
+			"dimensions",
+			"filters",
+			"legend",
+			"orientation",
+			"value-formatting"
+		],
+		type: "histogram"
+	},
+	{
+		additionalExamples: [{
+			definition: {
+				data: {
+					dimensions: [j("manufacturer", A.manufacturer)],
+					measures: [{
+						...N("sales"),
+						dataPointShape: "circle"
+					}]
+				},
+				presentation: { axes: { primaryMeasure: {
+					inverted: !0,
+					range: {
+						max: 100,
+						min: 1
+					},
+					title: "Rank"
+				} } },
+				type: "line",
+				version: 1
+			},
+			title: "Fixed, inverted measure axis"
+		}, {
+			definition: {
+				data: {
+					dimensions: [j("manufacturer", A.manufacturer), j("model", A.model)],
+					measures: [{
+						...N("sales"),
+						dataPointShape: "circle"
+					}]
+				},
+				presentation: { coloring: { overwrites: [{
+					color: "#7C3AED",
+					operator: "startsWith",
+					value: "A"
+				}] } },
+				type: "line",
+				version: 1
+			},
+			title: "Series colored by dimension value"
+		}],
+		documentation: {
+			constraints: [
+				"Each measure may select the primary or secondary axis using its axis property.",
+				"Visible data labels require dataPointShape on every measure.",
+				L,
+				"Set range on a measure axis to fix its min, max, or both, for example to give several charts one shared scale; leave both unset and set startsAtZero to keep an auto-fitted axis anchored at zero. Set inverted on a measure axis to reverse its values, for example to put rank 1 at the top.",
+				"Set scale to log on a measure axis to draw it logarithmically, with gridlines at powers of ten. Zero and negative values are drawn at the floor of a log axis.",
+				"Value colors in presentation.coloring require at least two dimensions; measure color rules are not supported."
+			],
+			dataRequirements: ["At least one dimension.", "At least one measure."],
+			summary: "Trend chart with sorting, query limiting, dual measure axes, labels, legend, and orientation.",
+			title: "Line chart"
+		},
+		example: {
+			data: {
+				dimensions: [j("manufacturer", A.manufacturer)],
+				measures: [{
+					...N("sales"),
+					axis: "primary",
+					dataPointShape: "circle"
+				}, {
+					...N("horsepower", A.horsepower, "AVG"),
+					axis: "secondary",
+					dataPointShape: "square"
+				}]
+			},
+			filterGroup: P,
+			limiting: { queryLimit: 100 },
+			presentation: {
+				axes: I,
+				dataLabels: {
+					density: "medium",
+					visible: !0
+				},
+				legend: F,
+				orientation: "vertical"
+			},
+			sorting: [{
+				by: "sales",
+				direction: "desc"
+			}],
+			type: "line",
+			version: 1
+		},
+		supportedFeatures: [
+			"axes",
+			"axis-bands",
+			"axis-range",
+			"axis-scale",
+			"conditional-coloring",
+			"data-labels",
+			"data-points",
+			"dimensions",
+			"filters",
+			"legend",
+			"measure-axis",
+			"measures",
+			"orientation",
+			"query-limit",
+			"sorting",
+			"value-formatting"
+		],
+		type: "line"
+	},
+	{
+		documentation: {
+			constraints: [
+				"Without dimensions, at least two measures are required.",
+				"With dimensions, exactly one measure is supported.",
+				"Value colors in presentation.coloring require two dimensions; measure color rules are not supported."
+			],
+			dataRequirements: ["Zero to two dimensions.", "Two to five measures without dimensions, or one with dimensions."],
+			summary: "Radial comparison chart for one or more measures with optional categorical dimensions.",
+			title: "Radar chart"
+		},
+		example: {
+			data: {
+				dimensions: [j("manufacturer", A.manufacturer)],
+				measures: [N("sales")]
+			},
+			filterGroup: P,
+			presentation: { legend: F },
+			type: "radar",
+			version: 1
+		},
+		supportedFeatures: [
+			...R,
+			"conditional-coloring",
+			"legend"
+		],
+		type: "radar"
+	},
+	{
+		additionalExamples: [{
+			definition: {
+				data: {
+					dimensions: [j("manufacturer", A.manufacturer)],
+					measures: [N("sales")]
+				},
+				presentation: { coloring: { overwrites: [
+					{
+						color: "#134E4A",
+						value: "Audi"
+					},
+					{
+						color: "#2DD4BF",
+						value: "BMW"
+					},
+					{
+						color: "#CCFBF1",
+						value: "Buick"
+					}
+				] } },
+				type: "pie",
+				version: 1
+			},
+			title: "Ordered bands colored along a ramp"
+		}],
+		documentation: {
+			constraints: ["The first measure is the slice value; the optional second measure receives the length role."],
+			dataRequirements: ["Exactly one dimension.", "One or two measures."],
+			summary: "Part-to-whole chart with optional secondary radial measure.",
+			title: "Pie chart"
+		},
+		example: {
+			data: {
+				dimensions: [j("manufacturer", A.manufacturer)],
+				measures: [N("sales")]
+			},
+			filterGroup: P,
+			limiting: { queryLimit: 100 },
+			presentation: { legend: F },
+			sorting: [{
+				by: "sales",
+				direction: "desc"
+			}],
+			type: "pie",
+			version: 1
+		},
+		supportedFeatures: [
+			...R,
+			"conditional-coloring",
+			"legend",
+			"query-limit",
+			"sorting"
+		],
+		type: "pie"
+	},
+	{
+		documentation: {
+			constraints: ["At least one dimension or measure must be supplied.", "Trees with dimensions support at most one measure; measure-only trees may contain multiple measures."],
+			dataRequirements: ["Zero to ten dimensions.", "Zero to one hundred measures, or at most one with dimensions."],
+			summary: "Hierarchical tree built from dimensions, measures, or both.",
+			title: "Tree chart"
+		},
+		example: {
+			data: {
+				dimensions: [j("manufacturer", A.manufacturer), j("model", A.model)],
+				measures: [N("sales")]
+			},
+			filterGroup: P,
+			limiting: { queryLimit: 100 },
+			presentation: { layout: {
+				compact: !0,
+				direction: "top",
+				forceAutoFit: !1,
+				initialExpandedLevels: 1
+			} },
+			sorting: [{
+				by: "sales",
+				direction: "desc"
+			}],
+			type: "tree",
+			version: 1
+		},
+		supportedFeatures: [
+			...R,
+			"layout",
+			"query-limit",
+			"sorting"
+		],
+		type: "tree"
+	},
+	{
+		documentation: {
+			constraints: ["Dimension order defines hierarchy depth."],
+			dataRequirements: ["Between one and ten dimensions.", "Exactly one measure."],
+			summary: "Hierarchical area chart using ordered dimensions and one size measure.",
+			title: "Treemap"
+		},
+		example: {
+			data: {
+				dimensions: [j("manufacturer", A.manufacturer), j("model", A.model)],
+				measures: [N("sales")]
+			},
+			filterGroup: P,
+			presentation: { legend: F },
+			type: "treemap",
+			version: 1
+		},
+		supportedFeatures: [
+			...R,
+			"conditional-coloring",
+			"legend"
+		],
+		type: "treemap"
+	},
+	{
+		additionalExamples: [{
+			definition: {
+				data: {
+					dimensions: [j("manufacturer", A.manufacturer), j("model", A.model)],
+					measures: [N("sales")]
+				},
+				presentation: { coloring: { overwrites: [{
+					color: "#CA8A04",
+					dimension: "manufacturer",
+					value: "Audi"
+				}] } },
+				type: "sankey",
+				version: 1
+			},
+			title: "A color bound to a value of one flow stage"
+		}],
+		documentation: {
+			constraints: ["Dimension order defines the source-to-target flow stages.", "Every value color in presentation.coloring must name the dimension it applies to."],
+			dataRequirements: ["Between two and fifteen dimensions.", "Exactly one measure."],
+			summary: "Flow chart across an ordered sequence of categorical dimensions.",
+			title: "Sankey chart"
+		},
+		example: {
+			data: {
+				dimensions: [j("manufacturer", A.manufacturer), j("model", A.model)],
+				measures: [N("sales")]
+			},
+			filterGroup: P,
+			type: "sankey",
+			version: 1
+		},
+		supportedFeatures: [...R, "conditional-coloring"],
+		type: "sankey"
+	},
+	{
+		documentation: {
+			constraints: [
+				"Measure order maps to horizontal, vertical, and optional size roles.",
+				"The optional second dimension receives the image role.",
+				"Roles come from item order only; a ref is a label and does not select a role.",
+				"With a size measure, points scale between the setPointSize and setMaxPointSize operation values.",
+				"Set range on a measure axis to fix its min, max, or both, for example to give several charts one shared scale; leave both unset and set startsAtZero to keep an auto-fitted axis anchored at zero. Set inverted on a measure axis to reverse its values, for example to put rank 1 at the top."
+			],
+			dataRequirements: ["One or two dimensions.", "Two or three measures."],
+			summary: "Relationship chart using horizontal and vertical measures with optional size and image roles.",
+			title: "Scatter chart"
+		},
+		example: {
+			data: {
+				dimensions: [j("manufacturer", A.manufacturer)],
+				measures: [
+					N("sales"),
+					N("horsepower", A.horsepower, "AVG"),
+					N("size", A.sales, "AVG")
+				]
+			},
+			filterGroup: P,
+			presentation: {
+				axes: ht,
+				legend: F
+			},
+			type: "scatter",
+			version: 1
+		},
+		supportedFeatures: [
+			...R,
+			"conditional-coloring",
+			"axes",
+			"axis-range",
+			"legend",
+			"query-limit",
+			"sorting"
+		],
+		type: "scatter"
+	},
+	{
+		additionalExamples: [{
+			definition: {
+				data: {
+					dimensions: [j("manufacturer", A.manufacturer), j("model", A.model)],
+					measures: [N("sales")],
+					structure: "expandable"
+				},
+				filterGroup: P,
+				limiting: { queryLimit: 100 },
+				sorting: [{
+					by: "sales",
+					direction: "desc"
+				}],
+				type: "table",
+				version: 1
+			},
+			title: "Expandable table"
+		}, {
+			definition: {
+				data: {
+					columnDimensions: [j("model", A.model)],
+					measures: [N("sales")],
+					rowDimensions: [j("manufacturer", A.manufacturer)],
+					structure: "pivot"
+				},
+				filterGroup: P,
+				limiting: { queryLimit: 100 },
+				sorting: [{
+					by: "sales",
+					direction: "desc"
+				}],
+				type: "table",
+				version: 1
+			},
+			title: "Pivot table"
+		}],
+		documentation: {
+			constraints: [
+				"Normal table column order is preserved, and each column declares whether it is a dimension or measure.",
+				"Expandable table dimension order defines the expansion hierarchy.",
+				"Pivot tables explicitly separate row dimensions, column dimensions, and measures.",
+				"Measure definitions require valid aggregation for raw fields.",
+				"Presentation settings initialize table appearance and layout; later runtime operations preserve them.",
+				"Totals settings are optional; omitted totals properties preserve their values from the fresh default or preset vSpec."
+			],
+			dataRequirements: [
+				"Normal tables require at least one ordered dimension or measure column.",
+				"Expandable tables require at least one dimension and one measure.",
+				"Pivot tables require at least one row dimension, one column dimension, and one measure."
+			],
+			summary: "Normal, expandable, or pivot tabular output with formatting, filtering, sorting, query limiting, and totals.",
+			title: "Table"
+		},
+		example: {
+			data: {
+				columns: [
+					{
+						...j("manufacturer", A.manufacturer),
+						role: "dimension"
+					},
+					{
+						...j("model", A.model),
+						role: "dimension"
+					},
+					{
+						...N("sales"),
+						role: "measure"
+					}
+				],
+				structure: "normal"
+			},
+			filterGroup: P,
+			limiting: { queryLimit: 100 },
+			presentation: {
+				background: {
+					color: "#ffffff",
+					type: "single"
+				},
+				body: {
+					fontColor: "#1f1c3b",
+					fontFamily: "Roboto",
+					fontSize: 13,
+					horizontalAlign: "center",
+					verticalAlign: "middle"
+				},
+				borders: {
+					color: "#e0e0e0",
+					dividerColor: "#e0e0e0",
+					dividers: "all",
+					enabled: !0,
+					lineStyle: "line",
+					radius: 4,
+					strokeWidth: 1
+				},
+				header: {
+					backgroundColor: "#ffffff",
+					borderColor: "#e0e0e0",
+					fontColor: "#1f1c3b",
+					fontFamily: "Roboto",
+					fontSize: 13
+				},
+				highlight: {
+					backgroundColor: "#f2f2f2",
+					mode: "row"
+				},
+				layout: {
+					columnWidthBehavior: "responsive",
+					rowHeight: 41
+				}
+			},
+			sorting: [{
+				by: "sales",
+				direction: "desc"
+			}],
+			totals: {
+				applyTo: "both",
+				enabled: !0,
+				showRecordsCount: !0,
+				style: {
+					backgroundColor: "#f3f4f6",
+					fontColor: "#111827",
+					fontStyle: { bold: !0 },
+					position: "bottom",
+					responsiveHeight: !0
+				}
+			},
+			type: "table",
+			version: 1
+		},
+		supportedFeatures: [
+			"dimensions",
+			"filters",
+			"layout",
+			"measures",
+			"query-limit",
+			"sorting",
+			"table-structure",
+			"totals",
+			"value-formatting"
+		],
+		type: "table"
+	},
+	{
+		documentation: {
+			constraints: [
+				"Dimensions are not supported. Measure order defines the waterfall sequence.",
+				"Set range on the primary measure axis to fix its min, max, or both, for example to give several charts one shared scale; leave both unset and set startsAtZero to keep an auto-fitted axis anchored at zero. Set inverted on the primary measure axis to reverse its values.",
+				L
+			],
+			dataRequirements: ["Between one and one hundred measures."],
+			summary: "Sequential contribution chart composed from one or more measures.",
+			title: "Waterfall chart"
+		},
+		example: {
+			data: { measures: [{
+				...N("sales"),
+				dataLabels: { visible: !0 }
+			}, {
+				...N("horsepower", A.horsepower, "AVG"),
+				dataLabels: { visible: !0 }
+			}] },
+			filterGroup: P,
+			presentation: {
+				axes: gt,
+				dataLabels: { visible: !0 },
+				orientation: "vertical"
+			},
+			type: "waterfall",
+			version: 1
+		},
+		supportedFeatures: [
+			"axes",
+			"axis-bands",
+			"axis-range",
+			"data-labels",
+			"filters",
+			"measures",
+			"orientation",
+			"value-formatting"
+		],
+		type: "waterfall"
+	},
+	{
+		documentation: {
+			constraints: ["The dimension supplies words and the measure supplies their weight."],
+			dataRequirements: ["Exactly one dimension.", "Exactly one measure."],
+			summary: "Weighted word display using one label dimension and one measure.",
+			title: "Word cloud"
+		},
+		example: {
+			data: {
+				dimensions: [j("manufacturer", A.manufacturer)],
+				measures: [N("sales")]
+			},
+			filterGroup: P,
+			type: "word-cloud",
+			version: 1
+		},
+		supportedFeatures: [...R, "conditional-coloring"],
+		type: "word-cloud"
+	},
+	{
+		documentation: {
+			constraints: ["The selected field must be date- or timestamp-compatible."],
+			dataRequirements: ["Exactly one field."],
+			summary: "Date selection control with single/range modes, labels, quick select, and responsive settings.",
+			title: "Date picker"
+		},
+		example: {
+			data: { field: M("latestLaunch", A.latestLaunch) },
+			settings: {
+				endDateLabel: "To",
+				pickerState: "expanded",
+				pickerType: "range",
+				quickSelect: !0,
+				responsive: !0,
+				startDateLabel: "From",
+				timePickerVisibility: "never",
+				weekStart: "1"
+			},
+			type: "date-picker",
+			version: 1
+		},
+		supportedFeatures: ["dimensions", "filter-settings"],
+		type: "date-picker"
+	},
+	{
+		documentation: {
+			constraints: ["The selected field is used as a filter dimension."],
+			dataRequirements: ["Exactly one field."],
+			summary: "Interactive field filter with list/dropdown presentation and search/quick-select controls.",
+			title: "Filter"
+		},
+		example: {
+			data: { field: M("manufacturer", A.manufacturer) },
+			presentation: {
+				mode: "listbox",
+				quickSelect: !0,
+				responsive: !0,
+				searchable: !0,
+				showProgressBar: !1
+			},
+			type: "filter",
+			version: 1
+		},
+		supportedFeatures: ["dimensions", "filter-settings"],
+		type: "filter"
+	},
+	{
+		documentation: {
+			constraints: ["The URL must be absolute and valid; null clears the source."],
+			dataRequirements: ["No query data."],
+			summary: "Embedded external web content.",
+			title: "Iframe"
+		},
+		example: {
+			settings: { url: "https://example.com" },
+			type: "iframe",
+			version: 1
+		},
+		supportedFeatures: ["content"],
+		type: "iframe"
+	},
+	{
+		documentation: {
+			constraints: ["The source must use one of the supported image source variants."],
+			dataRequirements: ["No query data."],
+			summary: "Image content with fit, opacity, blur, saturation, and shadow controls.",
+			title: "Image"
+		},
+		example: {
+			settings: {
+				blur: 0,
+				fit: "contain",
+				opacity: .95,
+				saturation: .9,
+				shadow: !0,
+				source: {
+					imageUrl: "https://example.com/image.png",
+					sourceKind: "url"
+				}
+			},
+			type: "image",
+			version: 1
+		},
+		supportedFeatures: ["content", "object-settings"],
+		type: "image"
+	},
+	{
+		documentation: {
+			constraints: ["A raw field measure requires aggregation; semantic measures and calculations omit it."],
+			dataRequirements: ["Exactly one measure."],
+			summary: "Single aggregated or semantic value with value formatting and static filters.",
+			title: "Number"
+		},
+		example: {
+			data: { measure: N("sales") },
+			filterGroup: P,
+			type: "number",
+			version: 1
+		},
+		supportedFeatures: [
+			"filters",
+			"measures",
+			"value-formatting"
+		],
+		type: "number"
+	},
+	{
+		documentation: {
+			constraints: ["Image-specific settings apply only when the selected shape/background mode supports them."],
+			dataRequirements: ["No query data."],
+			summary: "Decorative shape with fill, stroke, sizing, rotation, and border controls.",
+			title: "Shape"
+		},
+		example: {
+			settings: {
+				backgroundColor: { code: "#2e6e9e" },
+				backgroundType: "color",
+				borderEnabled: !0,
+				borderRadius: 8,
+				heightBasedSize: !1,
+				lineThickness: 4,
+				preserveAspectRatio: !0,
+				rotate: 12,
+				scale: .7,
+				shape: "hexagon",
+				strokeColor: { code: "#18212b" }
+			},
+			type: "shape",
+			version: 1
+		},
+		supportedFeatures: ["object-settings"],
+		type: "shape"
+	},
+	{
+		documentation: {
+			constraints: ["Content interpretation follows the selected representation."],
+			dataRequirements: ["No query data."],
+			summary: "Text or Markdown content with typography, alignment, wrapping, and responsive controls.",
+			title: "Text object"
+		},
+		example: {
+			settings: {
+				align: "center",
+				content: "## Revenue overview",
+				fontFamily: "Arial",
+				fontSize: 30,
+				position: "middle",
+				representation: "markdown",
+				responsive: !0,
+				textColor: "#18212b",
+				wordWrap: !0
+			},
+			type: "simpleTextObject",
+			version: 1
+		},
+		supportedFeatures: ["content", "object-settings"],
+		type: "simpleTextObject"
+	},
+	{
+		documentation: {
+			constraints: ["The referenced variable must exist in the host variable service when variable behavior is used."],
+			dataRequirements: ["No query data; variable-backed input."],
+			summary: "Variable input control with input type, label, placeholder, and responsive settings.",
+			title: "Atomic input"
+		},
+		example: {
+			settings: {
+				customLabel: {
+					enabled: !0,
+					text: "Target"
+				},
+				inputType: "text",
+				placeholder: "Enter target",
+				responsive: !0,
+				variableId: "target-variable"
+			},
+			type: "atomic-input",
+			version: 1
+		},
+		supportedFeatures: ["input-settings"],
+		type: "atomic-input"
+	},
+	{
+		documentation: {
+			constraints: [
+				"Orientation defaults to horizontal. Use vertical for stacked sidebar filters; editors open beside the sidebar when space permits.",
+				"The bar displays active selections from its selection group, regardless of the fields allowed for creating new filters.",
+				"An empty selectableFieldKeys list allows users to create filters on any selectable field.",
+				"Selection mode overrides apply only to selections created by this bar; apply, cancel, and clear affect the shared selection group.",
+				"Chart breakdown switching is hidden by default. Enable showChartBreakdown only when the app uses dimension groups; a group must have multiple available fields for the control to appear."
+			],
+			dataRequirements: ["No query data; uses field metadata and selections supplied by the host."],
+			summary: "App filter bar settings for selection behavior, filter creation, associative filtering, and selectable fields.",
+			title: "Astrato App Filter Bar"
+		},
+		example: {
+			settings: {
+				enableAddingNewFilters: !0,
+				enableAssociativeFilter: !0,
+				selectableFieldKeys: ["[Cars].[Manufacturer]", "[Cars].[Model]"],
+				selectionMode: "inherit",
+				showChartBreakdown: !1,
+				showClearAll: !0
+			},
+			type: "astrato-app-filter-bar",
+			version: 1
+		},
+		supportedFeatures: ["selection-settings"],
+		type: "astrato-app-filter-bar"
+	},
+	{
+		documentation: {
+			constraints: ["The field must be numeric or date-compatible with the configured range and step.", "Providing range enables manual bounds; omitting it keeps data-derived bounds."],
+			dataRequirements: ["Exactly one field."],
+			summary: "Numeric or date range control with single/multi layout, step, and quick select.",
+			title: "Slider"
+		},
+		example: {
+			data: { field: M("horsepower", A.horsepower) },
+			settings: {
+				layout: "multi",
+				quickSelect: !0,
+				range: {
+					max: 500,
+					min: 0
+				},
+				step: 10
+			},
+			type: "slider",
+			version: 1
+		},
+		supportedFeatures: ["dimensions", "filter-settings"],
+		type: "slider"
+	}
+]), z = (e) => {
+	let t = _t.find((t) => t.type === e);
+	if (!t) throw Error(`Missing visualization definition documentation for ${e}`);
+	return t;
+}, B = (e, t) => k.toJSONSchema(e.meta({ title: t }), {
+	reused: "inline",
+	target: "draft-2020-12"
+}), V = z("bar"), vt = {
+	compile: ot,
+	documentation: V.documentation,
+	examples: [V.example, ...(V.additionalExamples ?? []).map(({ definition: e }) => e)],
+	jsonSchema: B(Je, `${V.documentation.title} definition`),
+	schema: Je,
+	supportedFeatures: V.supportedFeatures,
+	type: "bar",
+	version: 1
+}, H = z("astrato-app-filter-bar"), yt = {
+	compile: at,
+	documentation: H.documentation,
+	examples: [H.example],
+	jsonSchema: B(xe, `${H.documentation.title} definition`),
+	schema: xe,
+	supportedFeatures: H.supportedFeatures,
+	type: "astrato-app-filter-bar",
+	version: 1
+}, U = r(), bt = {
+	combo: {
+		coloringType: t.PerEachMeasure,
+		queryLimit: !0,
+		schema: Te,
+		sorting: !0,
+		type: "combo",
+		vSpecSchema: ee
+	},
+	"distribution-gauge": {
+		coloringType: t.PerEachMeasure,
+		measureRole: () => e.GAUGE_VALUE,
+		schema: g,
+		type: "distribution-gauge",
+		vSpecSchema: d
+	},
+	dot: {
+		coloringType: t.Categorical,
+		schema: Ie,
+		type: "dot",
+		vSpecSchema: s
+	},
+	gauge: {
+		coloringType: (e) => (e.data.dimensions?.length ?? 0) > 0 ? t.Categorical : t.PerEachMeasure,
+		measureRole: (t, n) => (n.data.dimensions?.length ?? 0) > 0 && t === 1 ? e.GAUGE_TARGET : e.GAUGE_VALUE,
+		schema: we,
+		type: "gauge",
+		vSpecSchema: le
+	},
+	heatMap: {
+		coloringType: t.Gradient,
+		dimensionRole: (e) => e === 0 ? n.HEAT_MAP_HORIZONTAL : n.HEAT_MAP_VERTICAL,
+		measureRole: (t) => t === 0 ? e.HEAT_MAP_COLOR : e.HEAT_MAP_SIZE,
+		queryLimit: !0,
+		schema: Oe,
+		sorting: !0,
+		type: "heatMap",
+		vSpecSchema: ne
+	},
+	histogram: {
+		coloringType: t.Single,
+		schema: Xe,
+		type: "histogram",
+		vSpecSchema: ae
+	},
+	pie: {
+		coloringType: t.Categorical,
+		measureRole: (t) => t === 0 ? e.PIE_CHART_SLICE : e.PIE_CHART_LENGTH,
+		queryLimit: !0,
+		schema: De,
+		sorting: !0,
+		type: "pie",
+		vSpecSchema: ce
+	},
+	radar: {
+		conditionalColoringFallbackType: t.Single,
+		schema: Re,
+		type: "radar",
+		vSpecSchema: se
+	},
+	sankey: {
+		schema: Le,
+		type: "sankey",
+		vSpecSchema: fe
+	},
+	scatter: {
+		coloringType: t.Categorical,
+		dimensionRole: (e) => e === 0 ? n.SCATTER_DIMENSION : n.SCATTER_IMAGE,
+		measureRole: (t) => [
+			e.SCATTER_HORIZONTAL,
+			e.SCATTER_VERTICAL,
+			e.SCATTER_SIZE
+		][t],
+		queryLimit: !0,
+		schema: ze,
+		sorting: !0,
+		type: "scatter",
+		vSpecSchema: oe
+	},
+	tree: {
+		queryLimit: !0,
+		schema: Me,
+		sorting: !0,
+		type: "tree",
+		vSpecSchema: l
+	},
+	treemap: {
+		schema: ye,
+		type: "treemap",
+		vSpecSchema: te
+	},
+	waterfall: {
+		schema: Ue,
+		type: "waterfall",
+		vSpecSchema: u
+	},
+	"word-cloud": {
+		conditionalColoringFallbackType: t.Single,
+		schema: et,
+		type: "word-cloud",
+		vSpecSchema: o
+	}
+}, xt = (e, t) => {
+	let n = [], r = t.presentation, i = Be(r?.axes);
+	if (i) return Promise.resolve({
+		issue: i,
+		success: !1
+	});
+	r?.orientation !== void 0 && n.push({
+		name: "setOrientation",
+		payload: r.orientation
+	}), r?.legend && n.push(...We(e.vSpec, r.legend)), Object.entries(r?.axes ?? {}).forEach(([e, t]) => {
+		t.titleVisible !== void 0 && n.push({
+			name: "setShowAxisTitle",
+			payload: {
+				axisName: e,
+				showAxisName: t.titleVisible
+			}
+		}), t.title !== void 0 && n.push({
+			name: "setAxisTitle",
+			payload: {
+				axisName: e,
+				axisTitle: t.title
+			}
+		}), t.labelsVisible !== void 0 && n.push({
+			name: "setShowAxisLabels",
+			payload: {
+				axisName: e,
+				showLabels: t.labelsVisible
+			}
+		}), t.ticksVisible !== void 0 && n.push({
+			name: "setShowAxisTicks",
+			payload: {
+				axisName: e,
+				showAxisTicks: t.ticksVisible
+			}
+		}), t.lineVisible !== void 0 && n.push({
+			name: "setShowAxisLine",
+			payload: {
+				axisName: e,
+				showAxisLine: t.lineVisible
+			}
+		}), n.push(...He(e, t)), "scale" in t && t.scale !== void 0 && n.push({
+			name: _e.SET_AXIS_SCALE,
+			payload: {
+				axisName: e,
+				scale: t.scale
+			}
+		});
+	});
+	let a = r?.axes?.primaryMeasure?.bands;
+	return a && n.push({
+		name: he.SET_MEASURE_AXIS_BANDS,
+		payload: { bands: a }
+	}), (t.data.measures ?? []).forEach((i) => {
+		let a = i.dataLabels ?? (t.type !== "combo" || i.seriesType === "bar" ? r?.dataLabels : void 0);
+		a && n.push({
+			name: "setMeasureDataLabelsShow",
+			payload: {
+				...T(e.resolvedRefs[i.ref]),
+				show: a.visible
+			}
+		});
+	}), y(e, n, ["presentation"]);
+}, St = (e, t) => {
+	let n = [];
+	if (t.type === "combo") {
+		(t.data.measures ?? []).forEach((t) => {
+			t.seriesType && n.push({
+				name: ge.SET_MEASURE_GRAPH_TYPE,
+				payload: {
+					...T(e.resolvedRefs[t.ref]),
+					graphType: t.seriesType
+				}
+			});
+		});
+		let r = t.data.measures ?? [], i = r.find((e) => e.seriesType === "bar"), a = r.find((e) => e.seriesType === "bar" && e.axis)?.axis;
+		r.forEach((t) => {
+			t.seriesType !== "bar" && t.axis && n.push({
+				name: m.CHANGE_MEASURE_AXIS,
+				payload: {
+					...T(e.resolvedRefs[t.ref]),
+					secondaryAxis: t.axis === "secondary"
+				}
+			});
+		}), i && a && n.push({
+			name: m.CHANGE_MEASURE_AXIS,
+			payload: {
+				...T(e.resolvedRefs[i.ref]),
+				secondaryAxis: a === "secondary"
+			}
+		});
+	}
+	if (t.type === "gauge" || t.type === "distribution-gauge") {
+		let e = t.type === "distribution-gauge";
+		e && n.push({
+			name: ve.SET_GAUGE_COMPARISON_MODE,
+			payload: !0
+		}), t.presentation?.displayMode && n.push({
+			name: e ? ve.SET_GAUGE_BAR_MODE : me.SET_GAUGE_BAR_MODE,
+			payload: t.presentation.displayMode === "bar"
+		}), !e && (t.data.dimensions?.length ?? 0) > 0 && (t.data.measures?.length ?? 0) > 1 && n.push({
+			name: me.SET_GAUGE_TARGET_TYPE,
+			payload: a.Data
+		});
+	}
+	if (t.type === "tree" && t.presentation?.layout) {
+		let e = t.presentation.layout;
+		e.compact !== void 0 && n.push({
+			name: p.SET_TREE_COMPACT,
+			payload: e.compact
+		}), e.forceAutoFit !== void 0 && n.push({
+			name: p.SET_TREE_FORCE_AUTO_FIT,
+			payload: e.forceAutoFit
+		}), e.direction !== void 0 && n.push({
+			name: p.SET_TREE_DIRECTION_ORIGIN,
+			payload: e.direction
+		}), e.initialExpandedLevels !== void 0 && n.push({
+			name: p.SET_TREE_INITIAL_EXPANDED_LEVELS,
+			payload: e.initialExpandedLevels
+		});
+	}
+	return y(e, n, ["presentation"]);
+}, Ct = (e, t, n) => {
+	let r = "coloring" in e.vSpec && e.vSpec.coloring !== void 0, i = t.presentation?.legend, a = !!i && Object.keys(i).length > 0 && i.visible !== !1, o = t.presentation?.coloring !== void 0, s = n.coloringType ?? (o ? n.conditionalColoringFallbackType : void 0);
+	return !s || r || !a && !o ? Promise.resolve({
+		state: e,
+		success: !0
+	}) : y(e, [{
+		name: "setColoringType",
+		payload: typeof s == "function" ? s(t) : s
+	}], a ? ["presentation", "legend"] : ["presentation", "coloring"]);
+}, wt = async (e, t) => {
+	let n = bt[t], r = n.schema.safeParse(e.definition);
+	if (!r.success) return {
+		issues: w(r.error, e.definition),
+		success: !1
+	};
+	let i = n.vSpecSchema.safeParse(e.baseVSpec);
+	if (!i.success) return {
+		issues: [_("invalid_structure", ["baseVSpec"], `Base ${t} vSpec is invalid.`, { details: { issues: i.error.issues } })],
+		success: !1
+	};
+	let a = i.data;
+	if (!C(a, [
+		"dimensions",
+		"measures",
+		"supportingMeasures",
+		"sortingMeasures"
+	])) return {
+		issues: [_("non_fresh_base_vspec", ["baseVSpec"], `${t} definitions require a fresh base vSpec.`)],
+		success: !1
+	};
+	let o = r.data, s = o.data.dimensions ?? [], c = o.data.measures ?? [], l = [...s, ...c].map((e) => e.ref), u = [
+		...D(s, e.availableFields, ["data", "dimensions"], "dimension"),
+		...D(c, e.availableFields, ["data", "measures"], "measure"),
+		...Se([{
+			items: s,
+			path: ["data", "dimensions"]
+		}, {
+			items: c,
+			path: ["data", "measures"]
+		}]),
+		...nt(o.filterGroup, e.availableFields),
+		...tt(o.sorting, l),
+		...Pe(o.presentation?.coloring, s.map((e) => e.ref), c.map((e) => e.ref)),
+		...t === "histogram" && s[0] ? O(s[0], e.availableFields, [
+			"data",
+			"dimensions",
+			0
+		], [
+			U.FieldType.DECIMAL,
+			U.FieldType.FLOAT,
+			U.FieldType.INT,
+			U.FieldType.REAL
+		], "a histogram dimension") : []
+	];
+	if (u.length > 0) return {
+		issues: u,
+		success: !1
+	};
+	let d = {
+		state: S(e, a),
+		success: !0
+	};
+	for (let [e, t] of s.entries()) {
+		if ("issue" in d) return {
+			issues: [d.issue],
+			success: !1
+		};
+		let r = n.dimensionRole?.(e, o);
+		d = await x(d.state, t, "dimension", "addDimension", {
+			key: t.fieldKey,
+			...r ? { role: r } : {}
+		}, [
+			"data",
+			"dimensions",
+			e
+		]);
+	}
+	for (let [t, r] of c.entries()) {
+		if ("issue" in d) return {
+			issues: [d.issue],
+			success: !1
+		};
+		let i = n.measureRole?.(t, o);
+		d = await x(d.state, r, "measure", "addMeasure", it(r, e.availableFields, i ? { role: i } : {}), [
+			"data",
+			"measures",
+			t
+		]);
+	}
+	return "issue" in d || (d = await Ze(d.state, s, "updateDimension", ["data", "dimensions"]), "issue" in d) || (d = await St(d.state, o), "issue" in d) || (d = await Ct(d.state, o, n), "issue" in d) || (d = await $e(d.state, s, "setDimensionTemporalGrouping", ["data", "dimensions"]), "issue" in d) || (d = await Ve(d.state, s, {
+		formatString: "setDimensionFormatString",
+		formatType: "setDimensionFormatType"
+	}, ["data", "dimensions"]), "issue" in d) || (d = await Ve(d.state, c, {
+		currency: "setMeasureCurrency",
+		currencyIsPrefix: "setMeasureCurrencyIsPrefix",
+		formatString: "setMeasureFormatString",
+		formatType: "setMeasureFormatType",
+		negativeType: "setMeasureNegativeType"
+	}, ["data", "measures"]), "issue" in d) || (d = await Ge(d.state, o.filterGroup), "issue" in d) || n.sorting && (d = await Ye(d.state, o.sorting, "changeSortOrderAndDirection", "toggleSortingItem"), "issue" in d) || n.queryLimit && o.limiting?.queryLimit !== void 0 && (d = await y(d.state, [{
+		name: "setQueryLimit",
+		payload: o.limiting.queryLimit
+	}], ["limiting"]), "issue" in d) || (d = await xt(d.state, o), "issue" in d) ? {
+		issues: [d.issue],
+		success: !1
+	} : (d = await qe(d.state, o.presentation?.coloring), "issue" in d ? {
+		issues: [d.issue],
+		success: !1
+	} : v(d.state, n.vSpecSchema));
+}, W = (e) => {
+	let t = z(e.type);
+	return {
+		compile: (t) => wt(t, e.type),
+		documentation: t.documentation,
+		examples: [t.example, ...(t.additionalExamples ?? []).map(({ definition: e }) => e)],
+		jsonSchema: B(e.schema, `${t.documentation.title} definition`),
+		schema: e.schema,
+		supportedFeatures: t.supportedFeatures,
+		type: e.type,
+		version: 1
+	};
+}, Tt = [
+	W({
+		schema: Te,
+		type: "combo"
+	}),
+	W({
+		schema: Ie,
+		type: "dot"
+	}),
+	W({
+		schema: ze,
+		type: "scatter"
+	}),
+	W({
+		schema: Xe,
+		type: "histogram"
+	}),
+	W({
+		schema: Oe,
+		type: "heatMap"
+	}),
+	W({
+		schema: Re,
+		type: "radar"
+	}),
+	W({
+		schema: we,
+		type: "gauge"
+	}),
+	W({
+		schema: g,
+		type: "distribution-gauge"
+	}),
+	W({
+		schema: De,
+		type: "pie"
+	}),
+	W({
+		schema: Me,
+		type: "tree"
+	}),
+	W({
+		schema: ye,
+		type: "treemap"
+	}),
+	W({
+		schema: Le,
+		type: "sankey"
+	}),
+	W({
+		schema: Ue,
+		type: "waterfall"
+	}),
+	W({
+		schema: et,
+		type: "word-cloud"
+	})
+], G = z("filter"), Et = {
+	compile: st,
+	documentation: G.documentation,
+	examples: [G.example],
+	jsonSchema: B(Fe, `${G.documentation.title} definition`),
+	schema: Fe,
+	supportedFeatures: G.supportedFeatures,
+	type: "filter",
+	version: 1
+}, K = z("line"), Dt = {
+	compile: ct,
+	documentation: K.documentation,
+	examples: [K.example, ...(K.additionalExamples ?? []).map(({ definition: e }) => e)],
+	jsonSchema: B(E, `${K.documentation.title} definition`),
+	schema: E,
+	supportedFeatures: K.supportedFeatures,
+	type: "line",
+	version: 1
+}, q = z("number"), Ot = {
+	compile: lt,
+	documentation: q.documentation,
+	examples: [q.example],
+	jsonSchema: B(Ne, `${q.documentation.title} definition`),
+	schema: Ne,
+	supportedFeatures: q.supportedFeatures,
+	type: "number",
+	version: 1
+}, J = (e, t) => Object.entries(e).flatMap(([e, n]) => n === void 0 || !t[e] ? [] : [{
+	name: t[e],
+	payload: n
+}]), kt = {
+	"atomic-input": {
+		createRequests: (e) => {
+			let t = e.customLabel;
+			return [...J(e, {
+				hideLabel: "setAtomicInputHideLabel",
+				inputType: "setAtomicInputType",
+				placeholder: "setAtomicInputPlaceholder",
+				responsive: "setAtomicInputResponsive",
+				variableId: "setAtomicInputVariableId"
+			}), ...t ? [{
+				name: "setAtomicInputCustomLabelEnabled",
+				payload: t.enabled
+			}, ...t.text === void 0 ? [] : [{
+				name: "setAtomicInputCustomLabelText",
+				payload: t.text
+			}]] : []];
+		},
+		schema: b,
+		type: "atomic-input",
+		vSpecSchema: c
+	},
+	iframe: {
+		createRequests: (e) => [{
+			name: "setIframeUrl",
+			payload: e.url
+		}],
+		schema: Ae,
+		type: "iframe",
+		vSpecSchema: pe
+	},
+	image: {
+		createRequests: (e) => J(e, {
+			blur: "setImageBlur",
+			fit: "setImageFit",
+			opacity: "setImageOpacity",
+			saturation: "setImageSaturation",
+			shadow: "setImageShadow",
+			source: "setImageSource"
+		}),
+		schema: je,
+		type: "image",
+		vSpecSchema: re
+	},
+	shape: {
+		createRequests: (e) => J(e, {
+			backgroundColor: "setShapeBackgroundColor",
+			backgroundType: "setShapeBackgroundType",
+			borderEnabled: "setShapeBorderEnabled",
+			borderRadius: "setShapeBorderRadius",
+			heightBasedSize: "setShapeHeightBasedSize",
+			imageFit: "setShapeImageFit",
+			imageURL: "setShapeImageURL",
+			lineThickness: "setShapeBorderWidth",
+			preserveAspectRatio: "setShapePreserveAspectRatio",
+			rotate: "setShapeRotation",
+			scale: "setShapeScale",
+			shape: "setShapeType",
+			strokeColor: "setShapeBorderColor"
+		}),
+		schema: Ce,
+		type: "shape",
+		vSpecSchema: ie
+	},
+	simpleTextObject: {
+		createRequests: (e) => [...e.content === void 0 ? [] : [{
+			name: "setTextContent",
+			payload: {
+				textContent: e.content,
+				representation: e.representation
+			}
+		}], ...J(e, {
+			align: "setTextHorizontalAlign",
+			fontFamily: "setTextFontFamily",
+			fontSize: "setTextFontSize",
+			position: "setTextVerticalAlign",
+			representation: "setTextRepresentation",
+			responsive: "setTextResponsiveEnabled",
+			textColor: "setTextColor",
+			wordWrap: "setTextWordWrap"
+		})],
+		schema: h,
+		type: "simpleTextObject",
+		vSpecSchema: ue
+	}
+}, Y = async (e, t) => {
+	let n = kt[t], r = n.schema.safeParse(e.definition);
+	if (!r.success) return {
+		issues: w(r.error, e.definition),
+		success: !1
+	};
+	let i = n.vSpecSchema.safeParse(e.baseVSpec);
+	if (!i.success) return {
+		issues: [_("invalid_structure", ["baseVSpec"], `Base ${t} vSpec is invalid.`, { details: { issues: i.error.issues } })],
+		success: !1
+	};
+	let a = S(e, i.data), o = r.data.settings, s = await y(a, n.createRequests(o), ["settings"]);
+	return "issue" in s ? {
+		issues: [s.issue],
+		success: !1
+	} : v(s.state, n.vSpecSchema);
+}, At = async (e) => {
+	let t = ke.safeParse(e.definition);
+	if (!t.success) return {
+		issues: w(t.error, e.definition),
+		success: !1
+	};
+	let n = f.safeParse(e.baseVSpec);
+	if (!n.success) return {
+		issues: [_("invalid_structure", ["baseVSpec"], "Base date-picker vSpec is invalid.", { details: { issues: n.error.issues } })],
+		success: !1
+	};
+	let r = n.data;
+	if (!C(r, ["dimensions", "measures"])) return {
+		issues: [_("non_fresh_base_vspec", ["baseVSpec"], "Date-picker definitions require a fresh vSpec.")],
+		success: !1
+	};
+	let i = t.data, a = [...rt(i.data.field, e.availableFields, ["data", "field"], "dimension"), ...O(i.data.field, e.availableFields, ["data", "field"], [
+		U.FieldType.DATE,
+		U.FieldType.TIMESTAMP,
+		U.FieldType.TIMESTAMP_TZ
+	], "a date-picker field")];
+	if (a.length > 0) return {
+		issues: a,
+		success: !1
+	};
+	let o = await x(S(e, r), i.data.field, "dimension", "addDatePickerDimension", { key: i.data.field.fieldKey }, ["data", "field"]);
+	return "issue" in o ? {
+		issues: [o.issue],
+		success: !1
+	} : (o = await y(o.state, J(i.settings ?? {}, {
+		endDateLabel: "setDatePickerEndDateLabel",
+		pickerState: "setDatePickerState",
+		pickerType: "setDatePickerType",
+		quickSelect: "setDatePickerQuickSelect",
+		responsive: "setDatePickerResponsive",
+		startDateLabel: "setDatePickerStartDateLabel",
+		timePickerVisibility: "setDatePickerTimePickerVisibility",
+		weekStart: "setDatePickerWeekStart"
+	}), ["settings"]), "issue" in o ? {
+		issues: [o.issue],
+		success: !1
+	} : v(o.state, f));
+}, jt = async (e) => {
+	let t = Ee.safeParse(e.definition);
+	if (!t.success) return {
+		issues: w(t.error, e.definition),
+		success: !1
+	};
+	let n = de.safeParse(e.baseVSpec);
+	if (!n.success) return {
+		issues: [_("invalid_structure", ["baseVSpec"], "Base slider vSpec is invalid.", { details: { issues: n.error.issues } })],
+		success: !1
+	};
+	let r = n.data;
+	if (!C(r, ["dimensions", "measures"])) return {
+		issues: [_("non_fresh_base_vspec", ["baseVSpec"], "Slider definitions require a fresh vSpec.")],
+		success: !1
+	};
+	let i = t.data, a = [...rt(i.data.field, e.availableFields, ["data", "field"], "dimension"), ...O(i.data.field, e.availableFields, ["data", "field"], [
+		U.FieldType.DATE,
+		U.FieldType.DECIMAL,
+		U.FieldType.FLOAT,
+		U.FieldType.INT,
+		U.FieldType.REAL,
+		U.FieldType.TIMESTAMP,
+		U.FieldType.TIMESTAMP_TZ
+	], "a slider field")];
+	if (a.length > 0) return {
+		issues: a,
+		success: !1
+	};
+	let o = await x(S(e, r), i.data.field, "dimension", "addSliderDimension", { key: i.data.field.fieldKey }, ["data", "field"]);
+	if ("issue" in o) return {
+		issues: [o.issue],
+		success: !1
+	};
+	let s = i.settings ?? {};
+	return o = await y(o.state, [...s.range === void 0 ? [] : [{
+		name: "setSliderManualRangeEnabled",
+		payload: !0
+	}], ...J(s, {
+		layout: "setSliderLayout",
+		quickSelect: "setSliderQuickSelect",
+		range: "setSliderRange",
+		step: "setSliderStep"
+	})], ["settings"]), "issue" in o ? {
+		issues: [o.issue],
+		success: !1
+	} : v(o.state, de);
+}, X = (e) => {
+	let t = z(e.type);
+	return {
+		compile: e.compile,
+		documentation: t.documentation,
+		examples: [t.example],
+		jsonSchema: B(e.schema, `${t.documentation.title} definition`),
+		schema: e.schema,
+		supportedFeatures: t.supportedFeatures,
+		type: e.type,
+		version: 1
+	};
+}, Mt = [
+	X({
+		compile: At,
+		schema: ke,
+		type: "date-picker"
+	}),
+	X({
+		compile: (e) => Y(e, "iframe"),
+		schema: Ae,
+		type: "iframe"
+	}),
+	X({
+		compile: (e) => Y(e, "image"),
+		schema: je,
+		type: "image"
+	}),
+	X({
+		compile: (e) => Y(e, "shape"),
+		schema: Ce,
+		type: "shape"
+	}),
+	X({
+		compile: (e) => Y(e, "simpleTextObject"),
+		schema: h,
+		type: "simpleTextObject"
+	}),
+	X({
+		compile: (e) => Y(e, "atomic-input"),
+		schema: b,
+		type: "atomic-input"
+	}),
+	X({
+		compile: jt,
+		schema: Ee,
+		type: "slider"
+	})
+], Z = z("table"), Nt = {
+	compile: ut,
+	documentation: Z.documentation,
+	examples: [Z.example, ...(Z.additionalExamples ?? []).map(({ definition: e }) => e)],
+	jsonSchema: B(be, `${Z.documentation.title} definition`),
+	schema: be,
+	supportedFeatures: Z.supportedFeatures,
+	type: "table",
+	version: 1
+}, Pt = (e, t) => `${t}:${e}`, Ft = [
+	yt,
+	vt,
+	...Tt,
+	...Mt,
+	Dt,
+	Nt,
+	Ot,
+	Et
+], It = new Map(Ft.map((e) => [Pt(e.type, e.version), e])), Q = (e, t = 1) => It.get(Pt(e, t)), Lt = () => [...It.values()].map(({ documentation: e, examples: t, jsonSchema: n, supportedFeatures: r, type: i, version: a }) => ({
+	documentation: e,
+	examples: t,
+	jsonSchema: n,
+	supportedFeatures: r,
+	type: i,
+	version: a
+})), $ = () => Ft.map((e) => e.type), Rt = (e) => {
+	if (typeof e != "object" || !e || Array.isArray(e)) return {
+		code: "invalid_structure",
+		message: "Visualization definition must be an object.",
+		path: []
+	};
+	let t = "version" in e ? e.version : void 0;
+	if (t !== 1) return {
+		allowedValues: [1],
+		code: "unsupported_version",
+		message: `Visualization definition version "${String(t)}" is not supported.`,
+		path: ["version"]
+	};
+	let n = "type" in e ? e.type : void 0;
+	if (!(typeof n == "string" && Q(n, t))) return {
+		allowedValues: $(),
+		code: "unsupported_visualization",
+		message: `Visualization type "${String(n)}" is not supported.`,
+		path: ["type"]
+	};
+}, zt = (e) => {
+	let t = Rt(e);
+	if (t) return {
+		issues: [t],
+		success: !1
+	};
+	let n = Q(e.type, e.version);
+	if (!n) return {
+		issues: [{
+			allowedValues: $(),
+			code: "unsupported_visualization",
+			message: "Visualization definition descriptor is not available.",
+			path: ["type"]
+		}],
+		success: !1
+	};
+	let r = n.schema.safeParse(e);
+	return r.success ? {
+		definition: r.data,
+		issues: [],
+		success: !0
+	} : {
+		issues: w(r.error, e),
+		success: !1
+	};
+}, Bt = async (e) => {
+	let t = Rt(e.definition);
+	if (t) return {
+		issues: [t],
+		success: !1
+	};
+	let n = e.definition, r = Q(n.type, n.version), a = k.array(Qe).safeParse(e.availableFields);
+	if (!a.success) return {
+		issues: w(a.error, e.availableFields, ["availableFields"]),
+		success: !1
+	};
+	let o = /* @__PURE__ */ new Map(), s = a.data.flatMap((e, t) => {
+		let n = o.get(e.fieldKey);
+		return o.set(e.fieldKey, t), n === void 0 ? [] : [{
+			code: "invalid_structure",
+			details: { duplicateIndex: n },
+			message: `Available field key "${e.fieldKey}" is duplicated.`,
+			path: [
+				"availableFields",
+				t,
+				"fieldKey"
+			]
+		}];
+	});
+	if (s.length > 0) return {
+		issues: s,
+		success: !1
+	};
+	let c = Ke(a.data), l = k.array(i).safeParse(c);
+	return l.success ? r ? r.compile({
+		...e,
+		availableFields: a.data
+	}) : {
+		issues: [{
+			allowedValues: $(),
+			code: "unsupported_visualization",
+			message: "Visualization definition descriptor is not available.",
+			path: ["type"]
+		}],
+		success: !1
+	} : {
+		issues: w(l.error, c, ["availableFields"]),
+		success: !1
+	};
+};
+export { Lt as i, zt as n, Q as r, Bt as t };