import {z} from 'zod'

export type Owner = string;

export type ChartId = string;

export type SectionId = string;

export type AplString = string;

export type BooleanString = 'true' | 'false' | '';

export type TimeSeriesQueryOptions = {displayNull?: ('auto' | 'null' | 'span' | 'zero' | '') | undefined, overlayCharts?: BooleanString | undefined, shownColumns?: string | undefined, timeSeriesVariant?: ('area' | 'bars' | 'line' | 'lines' | '') | undefined, timeSeriesView?: ('charts' | 'resultsTable' | 'charts|resultsTable' | '') | undefined};

export type TimeSeriesNonMetricsAplQuery = {apl: AplString, queryOptions?: TimeSeriesQueryOptions | undefined};

export type MplString = string;

export type TimeSeriesNativeMplQuery = {mpl: MplString, queryOptions?: TimeSeriesQueryOptions | undefined};

export type TimeSeriesChartQuery = TimeSeriesNonMetricsAplQuery | TimeSeriesNativeMplQuery;

export type TimeSeriesChart = {id: ChartId, sectionId?: SectionId | undefined, type: 'TimeSeries', name?: string | undefined, query: TimeSeriesChartQuery};

export type HeatmapQueryOptions = {timeSeriesView?: ('charts' | 'resultsTable' | 'charts|resultsTable' | '') | undefined};

export type HeatmapNonMetricsAplQuery = {apl: AplString, queryOptions?: HeatmapQueryOptions | undefined};

export type HeatmapNativeMplQuery = {mpl: MplString, queryOptions?: HeatmapQueryOptions | undefined};

export type HeatmapChartQuery = HeatmapNonMetricsAplQuery | HeatmapNativeMplQuery;

export type HeatmapChart = {id: ChartId, sectionId?: SectionId | undefined, type: 'Heatmap', name?: string | undefined, query: HeatmapChartQuery, colorScheme?: ('Blue' | 'Orange' | 'Red' | 'Purple' | 'Teal' | 'Yellow' | 'Green' | 'Pink' | 'Grey' | 'Brown') | undefined};

export type SimpleNonMetricsAplQuery = {apl: AplString};

export type SimpleNativeMplQuery = {mpl: MplString};

export type SimpleChartQuery = SimpleNonMetricsAplQuery | SimpleNativeMplQuery;

export type AdvancedColumnSetting = {name: string, width?: number | undefined};

export type ColumnSetting = string | AdvancedColumnSetting;

export type DatasetStreamSettings = {fontSize?: string | undefined, highlightSeverity?: boolean | undefined, showRaw?: boolean | undefined, showEvent?: boolean | undefined, showTimestamp?: boolean | undefined, wrapLines?: boolean | undefined, hideNulls?: boolean | undefined, fitColumns?: boolean | undefined};

export type TableSettings = {columns?: Array<ColumnSetting> | undefined, settings?: DatasetStreamSettings | undefined};

export type LogStreamChart = {id: ChartId, sectionId?: SectionId | undefined, type: 'LogStream', name?: string | undefined, query: SimpleChartQuery, tableSettings?: TableSettings | undefined};

export type PieChart = {id: ChartId, sectionId?: SectionId | undefined, type: 'Pie', name?: string | undefined, query: SimpleChartQuery};

export type ScatterChart = {id: ChartId, sectionId?: SectionId | undefined, type: 'Scatter', name?: string | undefined, query: SimpleChartQuery};

export type TableChart = {id: ChartId, sectionId?: SectionId | undefined, type: 'Table', name?: string | undefined, query: SimpleChartQuery, tableSettings?: TableSettings | undefined};

export type TopKChart = {id: ChartId, sectionId?: SectionId | undefined, type: 'TopK', name?: string | undefined, query: SimpleChartQuery};

export type CssColor = string;

export type StatisticChartColorProps = {background?: CssColor | undefined, chartFillColor?: CssColor | undefined, labelColor?: CssColor | undefined, textColor?: CssColor | undefined};

export type StatisticChart = {id: ChartId, sectionId?: SectionId | undefined, type: 'Statistic', name?: string | undefined, query: SimpleChartQuery, colorScheme?: ('Blue' | 'Orange' | 'Red' | 'Purple' | 'Teal' | 'Yellow' | 'Green' | 'Pink' | 'Grey' | 'Brown') | undefined, customUnits?: string | undefined, showChart?: (boolean | string) | undefined, hideValue?: boolean | undefined, chartHeight?: (string | number) | undefined, errorThreshold?: ('Above' | 'AboveOrEqual' | 'Below' | 'BelowOrEqual' | 'AboveOrBelow') | undefined, errorThresholdValue?: string | undefined, warningThreshold?: ('Above' | 'AboveOrEqual' | 'Below' | 'BelowOrEqual' | 'AboveOrBelow') | undefined, warningThresholdValue?: string | undefined, roundTo?: number | undefined, invertTheme?: boolean | undefined, background?: CssColor | undefined, textColor?: CssColor | undefined, labelColor?: CssColor | undefined, chartFillColor?: CssColor | undefined, okColorProps?: StatisticChartColorProps | undefined, warningColorProps?: StatisticChartColorProps | undefined, errorColorProps?: StatisticChartColorProps | undefined};

export type GaugeChartSegment = {from: number, to: number};

export type GaugeChart = {id: ChartId, sectionId?: SectionId | undefined, type: 'Gauge', name?: string | undefined, query: SimpleChartQuery, segments: Array<GaugeChartSegment>, colorScale?: ('green-to-red' | 'red-to-green') | undefined, showRing?: boolean | undefined, labelMode?: ('none' | 'boundaries' | 'intervals') | undefined, showSparkline?: boolean | undefined, scaleToTimeRange?: boolean | undefined, scaleBaseDurationMs?: number | undefined, customUnits?: string | undefined};

export type NoteChart = {id: ChartId, sectionId?: SectionId | undefined, type: 'Note', text: string, variant?: ('' | 'default' | 'plain' | null) | undefined};

export type MonitorListColumns = {status: boolean, history: boolean, dataset: boolean, type: boolean, notifiers: boolean};

export type MonitorListChart = {id: ChartId, sectionId?: SectionId | undefined, type: 'MonitorList', name?: string | undefined, selectedMonitors: Array<string>, columns: MonitorListColumns};

export type SmartFilterId = string;

export type SmartFilterName = string;

export type SmartFilterActive = boolean;

export type SmartFilterSearch = {id: SmartFilterId, name: SmartFilterName, active?: SmartFilterActive | undefined, type: 'search'};

export type SmartFilterOption = {key: string, value: string, default?: boolean | undefined, unset?: boolean | undefined};

export type SmartFilterOptions = Array<SmartFilterOption> | unknown | '' | null;

export type SmartFilterSelectList = {id: SmartFilterId, name: SmartFilterName, active?: SmartFilterActive | undefined, options?: SmartFilterOptions | undefined, type: 'select', selectType: 'list'};

export type SmartFilterAplQuery = {apl: string};

export type SmartFilterNativeMplQuery = {mpl: string};

export type SmartFilterQuery = SmartFilterAplQuery | SmartFilterNativeMplQuery;

export type SmartFilterSelectQuery = {id: SmartFilterId, name: SmartFilterName, active?: SmartFilterActive | undefined, options?: (Array<SmartFilterOption> | unknown | '' | null) | undefined, type: 'select', selectType: 'query', query?: SmartFilterQuery | undefined};

export type SmartFilterSelect = SmartFilterSelectList | SmartFilterSelectQuery;

export type SmartFilterConfig = SmartFilterSearch | SmartFilterSelect;

export type LogoUrl = string;

export type SmartFilterChart = {id: ChartId, sectionId?: SectionId | undefined, type: 'SmartFilter', name?: string | undefined, filters: Array<SmartFilterConfig>, logo?: LogoUrl | undefined, logoDark?: LogoUrl | undefined};

export type SpacerChart = {id: ChartId, sectionId?: SectionId | undefined, type: 'Spacer', name?: string | undefined, variant?: ('transparent' | 'dashed' | 'solid') | undefined};

export type VisualizeConfigurationVersion = number;

export type VisualizeAxisFieldType = 'datetime' | 'integer' | 'float';

export type VisualizeAxisColumnRef = {name: string, type: VisualizeAxisFieldType};

export type VisualizeNumericFieldType = 'integer' | 'float';

export type VisualizeNumericColumnRef = {name: string, type: VisualizeNumericFieldType};

export type VisualizeCategoricalFieldType = 'string' | 'boolean';

export type VisualizeCategoricalColumnRef = {name: string, type: VisualizeCategoricalFieldType};

export type ScatterVisualizationBindings = {x: VisualizeAxisColumnRef, y: VisualizeNumericColumnRef, series?: VisualizeCategoricalColumnRef | undefined};

export type VisualizeColorSettings = {palette: 'axiom' | 'polychrome', assignment: 'series-name' | 'series-order'};

export type VisualizeAxisSettings = {scale: 'linear' | 'log', range: 'fit' | 'includeZero'};

export type VisualizeLegendSettings = {position: 'none' | 'bottom' | 'right'};

export type ScatterVisualizationSettings = {colors?: VisualizeColorSettings | undefined, xAxis?: VisualizeAxisSettings | undefined, yAxis?: VisualizeAxisSettings | undefined, legend?: VisualizeLegendSettings | undefined};

export type ScatterVisualization = {version: VisualizeConfigurationVersion, type: 'scatter', bindings: ScatterVisualizationBindings, settings: ScatterVisualizationSettings};

export type BarVisualizationBindings = {category: VisualizeCategoricalColumnRef, value: VisualizeNumericColumnRef, series?: VisualizeCategoricalColumnRef | undefined};

export type VisualizeStandardAggregation = 'avg' | 'sum' | 'count' | 'min' | 'max';

export type VisualizeCategoryLimit = number;

export type VisualizeStandardAggregationSettings = {aggregation: VisualizeStandardAggregation, categoryLimit: VisualizeCategoryLimit, colors?: VisualizeColorSettings | undefined, yAxis?: VisualizeAxisSettings | undefined, legend?: VisualizeLegendSettings | undefined};

export type VisualizePercentile = number;

export type VisualizePercentileAggregationSettings = {aggregation: 'percentile', percentile: VisualizePercentile, categoryLimit: VisualizeCategoryLimit, colors?: VisualizeColorSettings | undefined, yAxis?: VisualizeAxisSettings | undefined, legend?: VisualizeLegendSettings | undefined};

export type VisualizeBarSettings = VisualizeStandardAggregationSettings | VisualizePercentileAggregationSettings;

export type BarVisualization = {version: VisualizeConfigurationVersion, type: 'bar', bindings: BarVisualizationBindings, settings: VisualizeBarSettings};

export type HorizontalBarVisualizationBindings = {category: VisualizeCategoricalColumnRef, value: VisualizeNumericColumnRef, series?: VisualizeCategoricalColumnRef | undefined};

export type HorizontalBarVisualization = {version: VisualizeConfigurationVersion, type: 'horizontalBar', bindings: HorizontalBarVisualizationBindings, settings: VisualizeBarSettings};

export type HistogramVisualizationBindings = {value: VisualizeNumericColumnRef};

export type VisualizeBinCount = number;

export type HistogramVisualizationSettings = {binCount: VisualizeBinCount, colors?: VisualizeColorSettings | undefined, yAxis?: VisualizeAxisSettings | undefined};

export type HistogramVisualization = {version: VisualizeConfigurationVersion, type: 'histogram', bindings: HistogramVisualizationBindings, settings: HistogramVisualizationSettings};

export type FrequencyBarVisualizationBindings = {category: VisualizeCategoricalColumnRef};

export type FrequencyBarVisualizationSettings = {categoryLimit: VisualizeCategoryLimit, colors?: VisualizeColorSettings | undefined, yAxis?: VisualizeAxisSettings | undefined};

export type FrequencyBarVisualization = {version: VisualizeConfigurationVersion, type: 'frequencyBar', bindings: FrequencyBarVisualizationBindings, settings: FrequencyBarVisualizationSettings};

export type VisualizeHeatmapBindings = {x: VisualizeCategoricalColumnRef, y: VisualizeCategoricalColumnRef};

export type VisualizeHeatmapSettings = {categoryLimit: VisualizeCategoryLimit};

export type VisualizeHeatmap = {version: VisualizeConfigurationVersion, type: 'heatmap', bindings: VisualizeHeatmapBindings, settings: VisualizeHeatmapSettings};

export type VisualizeConfiguration = ScatterVisualization | BarVisualization | HorizontalBarVisualization | HistogramVisualization | FrequencyBarVisualization | VisualizeHeatmap;

export type VisualizeChart = {id: ChartId, sectionId?: SectionId | undefined, type: 'Visualize', name?: string | undefined, query: SimpleChartQuery, visualization: VisualizeConfiguration};

export type Chart = TimeSeriesChart | HeatmapChart | LogStreamChart | PieChart | ScatterChart | TableChart | TopKChart | StatisticChart | GaugeChart | NoteChart | MonitorListChart | SmartFilterChart | SpacerChart | VisualizeChart;

export type LayoutItem = {i: ChartId, x: number, y: number | null, w: number, h: number, minW?: number | undefined, minH?: number | undefined, maxW?: number | undefined, maxH?: number | undefined, static?: boolean | undefined};

export type Section = {id: SectionId, title: string, defaultCollapsed?: boolean | undefined};

export type SchemaVersion = 2;

export type DatetimeString = string;

export type TimeWindowStart = string;

export type TimeWindowEnd = string;

export type DashboardUID = string;

export type DashboardDocument = {name: string, owner: Owner, description?: string | undefined, charts: Array<Chart>, layout: Array<LayoutItem>, sections?: Array<Section> | undefined, refreshTime: 0 | 15 | 60 | 300, schemaVersion: SchemaVersion, against?: ('-1h' | '-3h' | '-6h' | '-12h' | '-1d' | '-3d' | '-7d' | '-1w' | '-2w' | '-3w' | '-30d' | '-60d' | '-90d') | undefined, againstTimestamp?: DatetimeString | undefined, timeWindowStart: TimeWindowStart, timeWindowEnd: TimeWindowEnd, uid?: DashboardUID | undefined};

export type LabelID = string;

export type DashboardUpsertRequest = {dashboard: DashboardDocument, labelIds?: Array<LabelID> | undefined, message?: string | undefined, overwrite?: boolean | undefined, uid?: string | undefined, version?: number | undefined};

export type CreateApiDashboardsArgs = {body: DashboardUpsertRequest};

export type CreateApiDashboardsOptions = {baseUrl?: string | undefined, bearerAuth?: string | undefined, fetch?: typeof fetch | undefined};

export const owner = z.string();

export const chartId = z.string().min(1).max(200);

export const sectionId = z.string();

export const aplString = z.string().min(1).max(500000);

export const booleanString = z.enum(["true", "false", ""]);

export const timeSeriesQueryOptions = z.object({displayNull: z.enum(["auto", "null", "span", "zero", ""]).optional(), overlayCharts: booleanString.optional(), shownColumns: z.string().max(10000).optional(), timeSeriesVariant: z.enum(["area", "bars", "line", "lines", ""]).optional(), timeSeriesView: z.enum(["charts", "resultsTable", "charts|resultsTable", ""]).optional()});

export const timeSeriesNonMetricsAplQuery = z.object({apl: aplString, queryOptions: timeSeriesQueryOptions.optional()});

export const mplString = z.string().min(1).max(500000);

export const timeSeriesNativeMplQuery = z.object({mpl: mplString, queryOptions: timeSeriesQueryOptions.optional()});

export const timeSeriesChartQuery = z.union([timeSeriesNonMetricsAplQuery, timeSeriesNativeMplQuery]);

export const timeSeriesChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("TimeSeries"), name: z.string().min(1).max(500).optional(), query: timeSeriesChartQuery});

export const heatmapQueryOptions = z.object({timeSeriesView: z.enum(["charts", "resultsTable", "charts|resultsTable", ""]).optional()});

export const heatmapNonMetricsAplQuery = z.object({apl: aplString, queryOptions: heatmapQueryOptions.optional()});

export const heatmapNativeMplQuery = z.object({mpl: mplString, queryOptions: heatmapQueryOptions.optional()});

export const heatmapChartQuery = z.union([heatmapNonMetricsAplQuery, heatmapNativeMplQuery]);

export const heatmapChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Heatmap"), name: z.string().min(1).max(500).optional(), query: heatmapChartQuery, colorScheme: z.enum(["Blue", "Orange", "Red", "Purple", "Teal", "Yellow", "Green", "Pink", "Grey", "Brown"]).optional()});

export const simpleNonMetricsAplQuery = z.object({apl: aplString});

export const simpleNativeMplQuery = z.object({mpl: mplString});

export const simpleChartQuery = z.union([simpleNonMetricsAplQuery, simpleNativeMplQuery]);

export const advancedColumnSetting = z.object({name: z.string().max(500), width: z.number().int().gt(0).lte(9007199254740991).optional()});

export const columnSetting = z.union([z.string().max(500), advancedColumnSetting]);

export const datasetStreamSettings = z.object({fontSize: z.string().max(20).optional(), highlightSeverity: z.boolean().optional(), showRaw: z.boolean().optional(), showEvent: z.boolean().optional(), showTimestamp: z.boolean().optional(), wrapLines: z.boolean().optional(), hideNulls: z.boolean().optional(), fitColumns: z.boolean().optional()});

export const tableSettings = z.object({columns: z.array(columnSetting).optional(), settings: datasetStreamSettings.optional()});

export const logStreamChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("LogStream"), name: z.string().min(1).max(500).optional(), query: simpleChartQuery, tableSettings: tableSettings.optional()});

export const pieChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Pie"), name: z.string().min(1).max(500).optional(), query: simpleChartQuery});

export const scatterChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Scatter"), name: z.string().min(1).max(500).optional(), query: simpleChartQuery});

export const tableChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Table"), name: z.string().min(1).max(500).optional(), query: simpleChartQuery, tableSettings: tableSettings.optional()});

export const topKChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("TopK"), name: z.string().min(1).max(500).optional(), query: simpleChartQuery});

export const cssColor = z.string().max(200);

export const statisticChartColorProps = z.object({background: cssColor.optional(), chartFillColor: cssColor.optional(), labelColor: cssColor.optional(), textColor: cssColor.optional()});

export const statisticChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Statistic"), name: z.string().min(1).max(500).optional(), query: simpleChartQuery, colorScheme: z.enum(["Blue", "Orange", "Red", "Purple", "Teal", "Yellow", "Green", "Pink", "Grey", "Brown"]).optional(), customUnits: z.string().max(200).optional(), showChart: z.union([z.boolean(), z.string()]).optional(), hideValue: z.boolean().optional(), chartHeight: z.union([z.string().max(100), z.number()]).optional(), errorThreshold: z.enum(["Above", "AboveOrEqual", "Below", "BelowOrEqual", "AboveOrBelow"]).optional(), errorThresholdValue: z.string().max(100).optional(), warningThreshold: z.enum(["Above", "AboveOrEqual", "Below", "BelowOrEqual", "AboveOrBelow"]).optional(), warningThresholdValue: z.string().max(100).optional(), roundTo: z.number().int().gte(0).lte(10).optional(), invertTheme: z.boolean().optional(), background: cssColor.optional(), textColor: cssColor.optional(), labelColor: cssColor.optional(), chartFillColor: cssColor.optional(), okColorProps: statisticChartColorProps.optional(), warningColorProps: statisticChartColorProps.optional(), errorColorProps: statisticChartColorProps.optional()});

export const gaugeChartSegment = z.object({from: z.number(), to: z.number()});

export const gaugeChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Gauge"), name: z.string().min(1).max(500).optional(), query: simpleChartQuery, segments: z.array(gaugeChartSegment), colorScale: z.enum(["green-to-red", "red-to-green"]).optional(), showRing: z.boolean().optional(), labelMode: z.enum(["none", "boundaries", "intervals"]).optional(), showSparkline: z.boolean().optional(), scaleToTimeRange: z.boolean().optional(), scaleBaseDurationMs: z.number().gt(0).optional(), customUnits: z.string().max(200).optional()});

export const noteChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Note"), text: z.string().min(1).max(100000), variant: z.enum(["", "default", "plain"]).nullable().optional()});

export const monitorListColumns = z.object({status: z.boolean(), history: z.boolean(), dataset: z.boolean(), type: z.boolean(), notifiers: z.boolean()});

export const monitorListChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("MonitorList"), name: z.string().min(1).max(500).optional(), selectedMonitors: z.array(z.string().min(1).max(200)), columns: monitorListColumns});

export const smartFilterId = z.string().max(200);

export const smartFilterName = z.string().max(200);

export const smartFilterActive = z.boolean();

export const smartFilterSearch = z.object({id: smartFilterId, name: smartFilterName, active: smartFilterActive.optional(), type: z.literal("search")});

export const smartFilterOption = z.object({key: z.string().max(500), value: z.string().max(10000), default: z.boolean().optional(), unset: z.boolean().optional()});

export const smartFilterOptions = z.union([z.array(smartFilterOption), z.unknown(), z.literal("").nullable()]);

export const smartFilterSelectList = z.object({id: smartFilterId, name: smartFilterName, active: smartFilterActive.optional(), options: smartFilterOptions.optional(), type: z.literal("select"), selectType: z.literal("list")});

export const smartFilterAplQuery = z.object({apl: z.string().min(1).max(500000)});

export const smartFilterNativeMplQuery = z.object({mpl: z.string().min(1).max(500000)});

export const smartFilterQuery = z.union([smartFilterAplQuery, smartFilterNativeMplQuery]);

export const smartFilterSelectQuery = z.object({id: smartFilterId, name: smartFilterName, active: smartFilterActive.optional(), options: z.union([z.array(smartFilterOption), z.unknown(), z.literal("").nullable()]).optional(), type: z.literal("select"), selectType: z.literal("query"), query: smartFilterQuery.optional()});

export const smartFilterSelect = z.union([smartFilterSelectList, smartFilterSelectQuery]);

export const smartFilterConfig = z.union([smartFilterSearch, smartFilterSelect]);

export const logoUrl = z.string().max(2000);

export const smartFilterChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("SmartFilter"), name: z.string().min(1).max(500).optional(), filters: z.array(smartFilterConfig), logo: logoUrl.optional(), logoDark: logoUrl.optional()});

export const spacerChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Spacer"), name: z.string().min(1).max(500).optional(), variant: z.enum(["transparent", "dashed", "solid"]).optional()});

export const visualizeConfigurationVersion = z.literal(1);

export const visualizeAxisFieldType = z.enum(["datetime", "integer", "float"]);

export const visualizeAxisColumnRef = z.object({name: z.string().min(1).max(500), type: visualizeAxisFieldType});

export const visualizeNumericFieldType = z.enum(["integer", "float"]);

export const visualizeNumericColumnRef = z.object({name: z.string().min(1).max(500), type: visualizeNumericFieldType});

export const visualizeCategoricalFieldType = z.enum(["string", "boolean"]);

export const visualizeCategoricalColumnRef = z.object({name: z.string().min(1).max(500), type: visualizeCategoricalFieldType});

export const scatterVisualizationBindings = z.object({x: visualizeAxisColumnRef, y: visualizeNumericColumnRef, series: visualizeCategoricalColumnRef.optional()});

export const visualizeColorSettings = z.object({palette: z.enum(["axiom", "polychrome"]), assignment: z.enum(["series-name", "series-order"])});

export const visualizeAxisSettings = z.object({scale: z.enum(["linear", "log"]), range: z.enum(["fit", "includeZero"])});

export const visualizeLegendSettings = z.object({position: z.enum(["none", "bottom", "right"])});

export const scatterVisualizationSettings = z.object({colors: visualizeColorSettings.optional(), xAxis: visualizeAxisSettings.optional(), yAxis: visualizeAxisSettings.optional(), legend: visualizeLegendSettings.optional()});

export const scatterVisualization = z.object({version: visualizeConfigurationVersion, type: z.literal("scatter"), bindings: scatterVisualizationBindings, settings: scatterVisualizationSettings});

export const barVisualizationBindings = z.object({category: visualizeCategoricalColumnRef, value: visualizeNumericColumnRef, series: visualizeCategoricalColumnRef.optional()});

export const visualizeStandardAggregation = z.enum(["avg", "sum", "count", "min", "max"]);

export const visualizeCategoryLimit = z.number().int().gte(1).lte(100);

export const visualizeStandardAggregationSettings = z.object({aggregation: visualizeStandardAggregation, categoryLimit: visualizeCategoryLimit, colors: visualizeColorSettings.optional(), yAxis: visualizeAxisSettings.optional(), legend: visualizeLegendSettings.optional()});

export const visualizePercentile = z.number().gte(0).lte(100);

export const visualizePercentileAggregationSettings = z.object({aggregation: z.literal("percentile"), percentile: visualizePercentile, categoryLimit: visualizeCategoryLimit, colors: visualizeColorSettings.optional(), yAxis: visualizeAxisSettings.optional(), legend: visualizeLegendSettings.optional()});

export const visualizeBarSettings = z.union([visualizeStandardAggregationSettings, visualizePercentileAggregationSettings]);

export const barVisualization = z.object({version: visualizeConfigurationVersion, type: z.literal("bar"), bindings: barVisualizationBindings, settings: visualizeBarSettings});

export const horizontalBarVisualizationBindings = z.object({category: visualizeCategoricalColumnRef, value: visualizeNumericColumnRef, series: visualizeCategoricalColumnRef.optional()});

export const horizontalBarVisualization = z.object({version: visualizeConfigurationVersion, type: z.literal("horizontalBar"), bindings: horizontalBarVisualizationBindings, settings: visualizeBarSettings});

export const histogramVisualizationBindings = z.object({value: visualizeNumericColumnRef});

export const visualizeBinCount = z.number().int().gte(1).lte(200);

export const histogramVisualizationSettings = z.object({binCount: visualizeBinCount, colors: visualizeColorSettings.optional(), yAxis: visualizeAxisSettings.optional()});

export const histogramVisualization = z.object({version: visualizeConfigurationVersion, type: z.literal("histogram"), bindings: histogramVisualizationBindings, settings: histogramVisualizationSettings});

export const frequencyBarVisualizationBindings = z.object({category: visualizeCategoricalColumnRef});

export const frequencyBarVisualizationSettings = z.object({categoryLimit: visualizeCategoryLimit, colors: visualizeColorSettings.optional(), yAxis: visualizeAxisSettings.optional()});

export const frequencyBarVisualization = z.object({version: visualizeConfigurationVersion, type: z.literal("frequencyBar"), bindings: frequencyBarVisualizationBindings, settings: frequencyBarVisualizationSettings});

export const visualizeHeatmapBindings = z.object({x: visualizeCategoricalColumnRef, y: visualizeCategoricalColumnRef});

export const visualizeHeatmapSettings = z.object({categoryLimit: visualizeCategoryLimit});

export const visualizeHeatmap = z.object({version: visualizeConfigurationVersion, type: z.literal("heatmap"), bindings: visualizeHeatmapBindings, settings: visualizeHeatmapSettings});

export const visualizeConfiguration = z.union([scatterVisualization, barVisualization, horizontalBarVisualization, histogramVisualization, frequencyBarVisualization, visualizeHeatmap]);

export const visualizeChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Visualize"), name: z.string().min(1).max(500).optional(), query: simpleChartQuery, visualization: visualizeConfiguration});

export const chart = z.union([timeSeriesChart, heatmapChart, logStreamChart, pieChart, scatterChart, tableChart, topKChart, statisticChart, gaugeChart, noteChart, monitorListChart, smartFilterChart, spacerChart, visualizeChart]);

export const layoutItem = z.object({i: chartId, x: z.number().int().gte(0).lte(11), y: z.number().gte(0).nullable(), w: z.number().int().gte(1).lte(12), h: z.number().gte(0.5).lte(100), minW: z.number().int().gte(1).lte(12).optional(), minH: z.number().gte(0.5).lte(100).optional(), maxW: z.number().int().gte(1).lte(12).optional(), maxH: z.number().int().gte(1).lte(100).optional(), static: z.boolean().optional()});

export const section = z.object({id: sectionId, title: z.string().min(1).max(200), defaultCollapsed: z.boolean().optional()});

export const schemaVersion = z.literal(2);

export const datetimeString = z.string().max(100);

export const timeWindowStart = z.string().min(1).max(100);

export const timeWindowEnd = z.string().min(1).max(100);

export const dashboardUID = z.string();

export const dashboardDocument = z.object({name: z.string().min(1).max(100), owner: owner, description: z.string().max(1000).optional(), charts: z.array(chart), layout: z.array(layoutItem), sections: z.array(section).optional(), refreshTime: z.union([z.literal(0), z.literal(15), z.literal(60), z.literal(300)]), schemaVersion: schemaVersion, against: z.enum(["-1h", "-3h", "-6h", "-12h", "-1d", "-3d", "-7d", "-1w", "-2w", "-3w", "-30d", "-60d", "-90d"]).optional(), againstTimestamp: datetimeString.optional(), timeWindowStart: timeWindowStart, timeWindowEnd: timeWindowEnd, uid: dashboardUID.optional()});

export const labelID = z.string();

export const labelColor = z.object({name: z.enum(["red", "coral", "orange", "amber", "yellow", "lime", "green", "teal", "blue", "iris", "purple", "pink"]), type: z.literal("palette")});

export const label = z.object({color: labelColor, description: z.string().nullable().optional(), id: labelID, name: z.string()});

export const dashboardResource = z.object({createdAt: z.string().nullable().optional(), createdBy: z.string().nullable().optional(), dashboard: dashboardDocument, id: z.string(), labelIds: z.array(labelID), labelNames: z.array(z.string()).optional(), labels: z.array(label).optional(), type: z.enum(["managed", "integration"]), uid: z.string(), updatedAt: z.string().nullable().optional(), updatedBy: z.string().nullable().optional(), updatedByAgent: z.boolean().optional(), version: z.number().int().nullable().optional()});

export const dashboardWriteResponse = z.object({dashboard: dashboardResource, overwritten: z.boolean().optional(), status: z.enum(["created", "updated"])});

export const validateResponse = async <Output>(
  schema: {
    readonly '~standard': {
      readonly validate: (value: unknown) => ({ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }) | Promise<{ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }>
    }
  },
  value: unknown
): Promise<Output> => {
  const result = await schema['~standard'].validate(value)

  if (result.issues !== undefined) {
    const detail = result.issues
      .map(({ message, path }) =>
        path?.length
          ? `${path.map((segment) => String(typeof segment === 'object' ? segment.key : segment)).join('.')}: ${message}`
          : message
      )
      .join('; ')

    throw new Error(`Response does not match the schema: ${detail}`, { cause: { issues: result.issues } })
  }

  return result.value
};

/**
 * Create dashboard
 * 
 * POST /dashboards
 */
export const createApiDashboards = async (args: CreateApiDashboardsArgs, options?: CreateApiDashboardsOptions) => {
const {baseUrl = "https://api.axiom.co/v2", fetch: fetchFn = fetch, bearerAuth} = options ?? {}

const query = new URLSearchParams()
const headers = new Headers()
headers.set('content-type', "application/json")
headers.set('accept', "application/json")

if (bearerAuth !== undefined) headers.set('authorization', `Bearer ${bearerAuth}`)

const url = `${baseUrl.replace(/\/+$/, '')}/dashboards${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "POST", headers, body: JSON.stringify(args.body)})

if (!res.ok) throw new Error(`Request failed with status ${res.status}`, {cause: {status: res.status, body: await res.text()}})

return validateResponse(dashboardWriteResponse, await res.json())
};