@undp/data-viz 1.2.8 → 1.3.1

package/dist/getSchema.js

@@ -0,0 +1,911 @@
+import { g as i } from "./getGraphList-DuColTJM.js";
+const y = "https://raw.githubusercontent.com/UNDP-Data/undp-viz-library-schemas/refs/heads/main/";
+function S(e) {
+  if (i.filter((t) => t.geoHubMapPresentation).map((t) => t.graphID).indexOf(e) !== -1)
+    return null;
+  switch (e) {
+    case "dataTable":
+      return "dataSchema/dataTableDataSchema.json";
+    case "dataCards":
+      return "dataSchema/dataTableDataSchema.json";
+    case "barChart":
+      return "dataSchema/barGraphDataSchema.json";
+    case "stackedBarChart":
+      return "dataSchema/stackedBarGraphDataSchema.json";
+    case "groupedBarChart":
+      return "dataSchema/groupedBarGraphDataSchema.json";
+    case "lineChart":
+      return "dataSchema/lineChartDataSchema.json";
+    case "dualAxisLineChart":
+      return "dataSchema/dualAxisLineChartDataSchema.json";
+    case "differenceLineChart":
+      return "dataSchema/differenceLineChartDataSchema.json";
+    case "multiLineChart":
+      return "dataSchema/multiLineChartDataSchema.json";
+    case "multiLineAltChart":
+      return "dataSchema/multiLineAltChartDataSchema.json";
+    case "stackedAreaChart":
+      return "dataSchema/areaChartDataSchema.json";
+    case "choroplethMap":
+      return "dataSchema/choroplethMapDataSchema.json";
+    case "threeDGlobe":
+      return "dataSchema/choroplethMapDataSchema.json";
+    case "bulletChart":
+      return "dataSchema/bulletChartDataSchema.json";
+    case "biVariateChoroplethMap":
+      return "dataSchema/biVariateChoroplethMapDataSchema.json";
+    case "dotDensityMap":
+      return "dataSchema/dotDensityMapDataSchema.json";
+    case "donutChart":
+      return "dataSchema/donutChartDataSchema.json";
+    case "slopeChart":
+      return "dataSchema/slopeChartDataSchema.json";
+    case "scatterPlot":
+      return "dataSchema/scatterPlotDataSchema.json";
+    case "dumbbellChart":
+      return "dataSchema/dumbbellChartDataSchema.json";
+    case "treeMap":
+      return "dataSchema/treeMapDataSchema.json";
+    case "circlePacking":
+      return "dataSchema/circlePackingDataSchema.json";
+    case "heatMap":
+      return "dataSchema/heatMapDataSchema.json";
+    case "stripChart":
+      return "dataSchema/stripChartDataSchema.json";
+    case "beeSwarmChart":
+      return "dataSchema/beeSwarmChartDataSchema.json";
+    case "butterflyChart":
+      return "dataSchema/butterflyChartDataSchema.json";
+    case "histogram":
+      return "dataSchema/histogramDataSchema.json";
+    case "sparkLine":
+      return "dataSchema/lineChartDataSchema.json";
+    case "paretoChart":
+      return "dataSchema/paretoChartDataSchema.json";
+    case "statCard":
+      return "dataSchema/statCardDataSchema.json";
+    case "unitChart":
+      return "dataSchema/unitChartDataSchema.json";
+    case "sankeyChart":
+      return "dataSchema/sankeyChartDataSchema.json";
+    case "lineChartWithConfidenceInterval":
+      return "dataSchema/lineChartWithConfidenceIntervalDataSchema.json";
+    case "radarChart":
+      return "dataSchema/radarChartDataSchema.json";
+    default:
+      return console.error("Unknown chart type:", e), null;
+  }
+}
+function b(e) {
+  switch (e) {
+    case "barChart":
+      return "settingsSchema/simpleBarChartSettingsSchema.json";
+    case "stackedBarChart":
+      return "settingsSchema/stackedBarChartSettingsSchema.json";
+    case "groupedBarChart":
+      return "settingsSchema/groupedBarChartSettingsSchema.json";
+    case "lineChart":
+      return "settingsSchema/lineChartSettingsSchema.json";
+    case "dualAxisLineChart":
+      return "settingsSchema/dualAxisLineChartSettingsSchema.json";
+    case "multiLineChart":
+      return "settingsSchema/multiLineChartSettingsSchema.json";
+    case "multiLineAltChart":
+      return "settingsSchema/multiLineAltChartSettingsSchema.json";
+    case "differenceLineChart":
+      return "settingsSchema/differenceLineChartSettingsSchema.json";
+    case "stackedAreaChart":
+      return "settingsSchema/stackedAreaChartSettingsSchema.json";
+    case "choroplethMap":
+      return "settingsSchema/choroplethMapSettingsSchema.json";
+    case "threeDGlobe":
+      return "settingsSchema/threeDGlobeSettingsSchema.json";
+    case "bulletChart":
+      return "settingsSchema/bulletChartSettingsSchema.json";
+    case "biVariateChoroplethMap":
+      return "settingsSchema/biVariateChoroplethMapSettingsSchema.json";
+    case "dotDensityMap":
+      return "settingsSchema/dotDensityMapSettingsSchema.json";
+    case "donutChart":
+      return "settingsSchema/donutChartSettingsSchema.json";
+    case "slopeChart":
+      return "settingsSchema/slopeChartSettingsSchema.json";
+    case "scatterPlot":
+      return "settingsSchema/scatterPlotSettingsSchema.json";
+    case "dumbbellChart":
+      return "settingsSchema/dumbbellChartSettingsSchema.json";
+    case "treeMap":
+      return "settingsSchema/treeMapSettingsSchema.json";
+    case "circlePacking":
+      return "settingsSchema/circlePackingSettingsSchema.json";
+    case "heatMap":
+      return "settingsSchema/heatMapSettingsSchema.json";
+    case "stripChart":
+      return "settingsSchema/stripChartSettingsSchema.json";
+    case "beeSwarmChart":
+      return "settingsSchema/beeSwarmChartSettingsSchema.json";
+    case "butterflyChart":
+      return "settingsSchema/butterflyChartSettingsSchema.json";
+    case "histogram":
+      return "settingsSchema/histogramSettingsSchema.json";
+    case "sparkLine":
+      return "settingsSchema/sparkLineSettingsSchema.json";
+    case "paretoChart":
+      return "settingsSchema/paretoChartSettingsSchema.json";
+    case "dataTable":
+      return "settingsSchema/dataTableSettingsSchema.json";
+    case "statCard":
+      return "settingsSchema/statCardSettingsSchema.json";
+    case "geoHubCompareMap":
+      return "settingsSchema/geoHubCompareMapSettingsSchema.json";
+    case "geoHubMap":
+      return "settingsSchema/geoHubMapSettingsSchema.json";
+    case "geoHubMapWithLayerSelection":
+      return "settingsSchema/geoHubMapWithLayerSelectionSettingsSchema.json";
+    case "unitChart":
+      return "settingsSchema/unitChartSettingsSchema.json";
+    case "sankeyChart":
+      return "settingsSchema/sankeyChartSettingsSchema.json";
+    case "lineChartWithConfidenceInterval":
+      return "settingsSchema/lineChartWithConfidenceIntervalSettingsSchema.json";
+    case "dataCards":
+      return "settingsSchema/dataCardListSettingsSchema.json";
+    case "allGraphs":
+      return "settingsSchema/SettingsSchema.json";
+    case "radarChart":
+      return "settingsSchema/radarChartSettingsSchema.json";
+    default:
+      return console.error("Unknown chart type:", e), null;
+  }
+}
+async function f(e) {
+  const t = await fetch(`${y}${S(e)}`);
+  if (!t.ok)
+    throw new Error(`Response status: ${t.status}`);
+  return await t.json();
+}
+async function p(e) {
+  const t = await fetch(`${y}${b(e)}`);
+  if (!t.ok)
+    throw new Error(`Response status: ${t.status}`);
+  return await t.json();
+}
+function C(e) {
+  switch (e) {
+    case "barChart":
+      return ["label", "size", "color", "date"];
+    case "bulletChart":
+      return ["label", "size", "target", "qualitativeRange"];
+    case "treeMap":
+      return ["label", "size", "color"];
+    case "circlePacking":
+      return ["label", "size", "color"];
+    case "butterflyChart":
+      return ["label", "leftBar", "rightBar", "date"];
+    case "groupedBarChart":
+      return ["label", "size", "date"];
+    case "stackedBarChart":
+      return ["label", "size", "date"];
+    case "dumbbellChart":
+      return ["x", "label", "date"];
+    case "donutChart":
+      return ["size", "label"];
+    case "histogram":
+      return ["value"];
+    case "choroplethMap":
+      return ["x", "id", "date"];
+    case "threeDGlobe":
+      return ["x", "id"];
+    case "biVariateChoroplethMap":
+      return ["x", "y", "id", "date"];
+    case "lineChart":
+      return ["date", "y"];
+    case "multiLineChart":
+      return ["date", "y"];
+    case "multiLineAltChart":
+      return ["date", "y", "label", "color"];
+    case "radarChart":
+      return ["values", "label", "color"];
+    case "stackedAreaChart":
+      return ["date", "y"];
+    case "scatterPlot":
+      return ["x", "y", "radius", "color", "label", "date"];
+    case "dualAxisLineChart":
+      return ["date", "y1", "y2"];
+    case "paretoChart":
+      return ["label", "bar", "line"];
+    case "dotDensityMap":
+      return ["lat", "long", "radius", "color", "label", "date"];
+    case "slopeChart":
+      return ["y1", "y2", "color", "label"];
+    case "heatMap":
+      return ["row", "column", "value"];
+    case "beeSwarmChart":
+      return ["label", "position", "radius", "color"];
+    case "stripChart":
+      return ["label", "position", "color"];
+    case "statCard":
+      return ["value"];
+    case "sankeyChart":
+      return ["source", "target", "value"];
+    case "differenceLineChart":
+      return ["date", "y1", "y2"];
+    case "unitChart":
+      return ["label", "value"];
+    case "sparkLine":
+      return ["date", "y"];
+    case "lineChartWithConfidenceInterval":
+      return ["date", "y", "yMin", "yMax"];
+    case "dashboardWideToLong":
+      return ["label", "size", "color", "value"];
+    case "dashboard":
+      return [
+        "label",
+        "radius",
+        "size",
+        "row",
+        "y1",
+        "y",
+        "rightBar",
+        "position",
+        "leftBar",
+        "x",
+        "bar",
+        "line",
+        "y2",
+        "column",
+        "date",
+        "value",
+        "color",
+        "long",
+        "lat",
+        "id",
+        "source",
+        "target",
+        "yMin",
+        "yMax"
+      ];
+    default:
+      return [
+        "label",
+        "radius",
+        "size",
+        "row",
+        "y1",
+        "y",
+        "rightBar",
+        "position",
+        "leftBar",
+        "x",
+        "bar",
+        "line",
+        "y2",
+        "column",
+        "date",
+        "value",
+        "color",
+        "long",
+        "lat",
+        "id",
+        "source",
+        "target",
+        "yMin",
+        "yMax"
+      ];
+  }
+}
+function n(e) {
+  return !e || e.length === 0 ? {} : { enum: e };
+}
+const m = (e) => ({
+  items: {
+    properties: {
+      column: {
+        type: "string",
+        ...n(e)
+      },
+      delimiter: { type: "string" }
+    },
+    type: "object",
+    required: ["column"]
+  },
+  type: "array"
+}), o = (e) => ({
+  properties: {
+    columnsToArray: m(e),
+    data: {},
+    dataURL: {
+      oneOf: [
+        { type: "string" },
+        {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              fileType: {
+                enum: ["csv", "json", "api"],
+                type: "string"
+              },
+              apiHeaders: {},
+              dataTransformation: { type: "string" },
+              idColumnName: { type: "string" },
+              dataURL: { type: "string" },
+              delimiter: { type: "string" },
+              columnsToArray: m()
+            },
+            required: ["dataURL", "idColumnName"]
+          }
+        }
+      ]
+    },
+    delimiter: { type: "string" },
+    fileType: {
+      enum: ["csv", "json", "api"],
+      type: "string"
+    },
+    apiHeaders: {},
+    dataTransformation: { type: "string" },
+    idColumnTitle: { type: "string" }
+  },
+  type: "object"
+}), c = (e) => ({
+  type: "array",
+  items: {
+    type: "object",
+    properties: {
+      value: { type: "string", ...n(e) },
+      label: { type: "string" }
+    },
+    required: ["value", "label"]
+  }
+}), l = (e) => ({
+  items: {
+    properties: {
+      clearable: { type: "boolean" },
+      allowSelectAll: { type: "boolean" },
+      width: { type: "string" },
+      excludeValues: {
+        items: { type: "string" },
+        type: "array"
+      },
+      column: {
+        type: "string",
+        ...n(e)
+      },
+      defaultValue: {
+        anyOf: [
+          {
+            items: { oneOf: [{ type: "string" }, { type: "number" }] },
+            type: "array"
+          },
+          { type: "string" },
+          { type: "number" }
+        ]
+      },
+      label: { type: "string" },
+      ui: { type: "string", enum: ["select", "radio"] },
+      singleSelect: { type: "boolean" }
+    },
+    required: ["column"],
+    type: "object"
+  },
+  type: "array"
+}), u = async (e) => {
+  const t = await p("allGraphs");
+  return {
+    type: "array",
+    items: {
+      type: "object",
+      properties: {
+        chartConfigId: { type: "string" },
+        label: { type: "string" },
+        width: { type: "string" },
+        allowedColumnIds: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              value: { type: "string", ...n(e) },
+              label: { type: "string" },
+              graphSettings: t
+            },
+            required: ["value", "label"]
+          },
+          minItems: 1
+        },
+        ui: { type: "string", enum: ["select", "radio"] }
+      },
+      required: ["chartConfigId", "allowedColumnIds"]
+    }
+  };
+}, s = (e) => ({
+  type: "array",
+  items: {
+    type: "object",
+    properties: {
+      column: { type: "string", ...n(e) },
+      includeValues: {
+        type: "array",
+        items: {
+          oneOf: [{ type: "string" }, { type: "number" }, { type: "boolean" }, { type: "null" }]
+        }
+      },
+      excludeValues: {
+        type: "array",
+        items: {
+          oneOf: [{ type: "string" }, { type: "number" }, { type: "boolean" }, { type: "null" }]
+        }
+      }
+    },
+    required: ["column"]
+  }
+}), d = (e) => ({
+  type: "object",
+  properties: {
+    keyColumn: { type: "string", ...n(e) },
+    aggregationColumnsSetting: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          column: { type: "string", ...n(e) },
+          aggregationMethod: {
+            type: "string",
+            enum: ["sum", "average", "min", "max"]
+          }
+        },
+        required: ["column"]
+      }
+    }
+  },
+  required: ["keyColumn"]
+}), h = (e, t) => ({
+  type: "array",
+  items: {
+    type: "object",
+    properties: {
+      columnId: {
+        oneOf: [
+          { type: "string", ...n(e) },
+          {
+            type: "array",
+            items: { type: "string", ...n(e) }
+          }
+        ]
+      },
+      chartConfigId: {
+        type: "string",
+        ...n(C(t))
+      }
+    },
+    required: ["columnId", "chartConfigId"]
+  }
+}), g = async (e, t) => {
+  const a = await p("allGraphs");
+  return {
+    type: "array",
+    items: {
+      type: "object",
+      properties: {
+        chartConfigId: { type: "string" },
+        label: { type: "string" },
+        width: { type: "string" },
+        options: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              dataConfiguration: h(e, t),
+              label: { type: "string" },
+              graphSettings: a
+            },
+            required: ["dataConfiguration", "label"]
+          },
+          minItems: 1
+        },
+        defaultValue: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              dataConfiguration: h(e, t),
+              label: { type: "string" },
+              graphSettings: a
+            },
+            required: ["dataConfiguration", "label"]
+          },
+          minItems: 1
+        },
+        ui: { type: "string", enum: ["select", "radio"] }
+      },
+      required: ["chartConfigId", "options"]
+    }
+  };
+}, D = async (e, t) => {
+  const a = await p(t || "allGraphs");
+  return t && i.filter((r) => r.geoHubMapPresentation).map((r) => r.graphID).indexOf(t) !== -1 ? {
+    type: "object",
+    properties: {
+      graphSettings: a,
+      graphType: {
+        type: "string",
+        enum: i.filter((r) => r.geoHubMapPresentation).map((r) => r.graphID)
+      },
+      debugMode: { type: "boolean" },
+      theme: { type: "string", enum: ["dark", "light"] },
+      uiMode: {
+        type: "string",
+        enum: ["light", "normal"]
+      },
+      classNames: { type: "object" },
+      highlightDataPointSettings: {
+        type: "object",
+        properties: {
+          column: { type: "string" },
+          label: { type: "string" },
+          defaultValues: {
+            oneOf: [
+              {
+                type: "array",
+                items: { type: "string" }
+              },
+              {
+                type: "array",
+                items: { type: "number" }
+              }
+            ]
+          },
+          excludeValues: {
+            type: "array",
+            items: { type: "string" }
+          },
+          allowSelectAll: { type: "boolean" },
+          width: { type: "string" }
+        },
+        required: ["column"]
+      },
+      styles: { type: "object" }
+    },
+    required: ["graphType"]
+  } : t === "dataTable" || t === "dataCards" ? {
+    type: "object",
+    properties: {
+      graphSettings: a,
+      dataSettings: o(e),
+      filters: l(e),
+      noOfFiltersPerRow: { type: "number" },
+      graphType: {
+        type: "string",
+        enum: ["dataTable", "dataCards"]
+      },
+      dataTransform: d(e),
+      dataFilters: s(e),
+      readableHeader: c(e),
+      dataSelectionOptions: u(e),
+      advancedDataSelectionOptions: g(e, t),
+      debugMode: { type: "boolean" },
+      theme: { type: "string", enum: ["dark", "light"] },
+      uiMode: {
+        type: "string",
+        enum: ["light", "normal"]
+      },
+      classNames: { type: "object" },
+      highlightDataPointSettings: {
+        type: "object",
+        properties: {
+          column: { type: "string" },
+          label: { type: "string" },
+          defaultValues: {
+            oneOf: [
+              {
+                type: "array",
+                items: { type: "string" }
+              },
+              {
+                type: "array",
+                items: { type: "number" }
+              }
+            ]
+          },
+          excludeValues: {
+            type: "array",
+            items: { type: "string" }
+          },
+          allowSelectAll: { type: "boolean" },
+          width: { type: "string" }
+        },
+        required: ["column"]
+      },
+      styles: { type: "object" }
+    },
+    required: ["dataSettings", "graphType"]
+  } : {
+    type: "object",
+    properties: {
+      graphSettings: a,
+      dataSettings: o(e),
+      filters: l(e),
+      classNames: { type: "object" },
+      styles: { type: "object" },
+      graphType: {
+        type: "string",
+        enum: i.map((r) => r.graphID)
+      },
+      noOfFiltersPerRow: { type: "number" },
+      dataTransform: d(e),
+      dataFilters: s(e),
+      graphDataConfiguration: h(e, t),
+      readableHeader: c(e),
+      dataSelectionOptions: u(e),
+      advancedDataSelectionOptions: g(e, t),
+      debugMode: { type: "boolean" },
+      theme: { type: "string", enum: ["dark", "light"] },
+      highlightDataPointSettings: {
+        type: "object",
+        properties: {
+          column: { type: "string" },
+          label: { type: "string" },
+          defaultValues: {
+            oneOf: [
+              {
+                type: "array",
+                items: { type: "string" }
+              },
+              {
+                type: "array",
+                items: { type: "number" }
+              }
+            ]
+          },
+          excludeValues: {
+            type: "array",
+            items: { type: "string" }
+          },
+          allowSelectAll: { type: "boolean" },
+          width: { type: "string" }
+        },
+        required: ["column"]
+      },
+      uiMode: {
+        type: "string",
+        enum: ["light", "normal"]
+      }
+    },
+    required: t ? ["dataSettings", "graphType", "graphDataConfiguration"] : ["graphType"]
+  };
+}, M = async (e, t) => {
+  const a = await p(t || "allGraphs");
+  return t === "dataTable" || t === "dataCards" ? {
+    type: "object",
+    properties: {
+      graphSettings: a,
+      dataSettings: o(e),
+      filters: l(e),
+      classNames: { type: "object" },
+      styles: { type: "object" },
+      noOfFiltersPerRow: { type: "number" },
+      graphType: {
+        type: "string",
+        enum: ["dataTable", "dataCards"]
+      },
+      uiMode: {
+        type: "string",
+        enum: ["light", "normal"]
+      },
+      dataTransform: d(e),
+      dataFilters: s(e),
+      noOfColumns: { type: "number" },
+      columnGridBy: { type: "string" },
+      showCommonColorScale: { type: "boolean" },
+      minGraphHeight: { type: "number" },
+      minGraphWidth: { type: "number" },
+      readableHeader: c(e),
+      dataSelectionOptions: u(e),
+      advancedDataSelectionOptions: g(e, t),
+      debugMode: { type: "boolean" },
+      theme: { type: "string", enum: ["dark", "light"] }
+    },
+    required: ["columnGridBy", "dataSettings", "graphType"]
+  } : {
+    type: "object",
+    properties: {
+      graphSettings: a,
+      dataSettings: o(e),
+      filters: l(e),
+      classNames: { type: "object" },
+      styles: { type: "object" },
+      noOfFiltersPerRow: { type: "number" },
+      graphType: {
+        type: "string",
+        enum: i.filter((r) => r.availableInGriddedGraph !== !1).map((r) => r.graphID)
+      },
+      uiMode: {
+        type: "string",
+        enum: ["light", "normal"]
+      },
+      dataTransform: d(e),
+      dataFilters: s(e),
+      graphDataConfiguration: h(e, t),
+      noOfColumns: { type: "number" },
+      columnGridBy: { type: "string" },
+      showCommonColorScale: { type: "boolean" },
+      minGraphHeight: { type: "number" },
+      minGraphWidth: { type: "number" },
+      readableHeader: c(e),
+      dataSelectionOptions: u(e),
+      advancedDataSelectionOptions: g(e, t),
+      debugMode: { type: "boolean" },
+      theme: { type: "string", enum: ["dark", "light"] }
+    },
+    required: t ? ["columnGridBy", "dataSettings", "graphType", "graphDataConfiguration"] : ["columnGridBy", "dataSettings", "graphType"]
+  };
+}, w = async (e) => {
+  const t = await p("allGraphs");
+  return {
+    properties: {
+      dashboardID: { type: "string" },
+      graphClassNames: { type: "object" },
+      graphStyles: { type: "object" },
+      dashboardLayout: {
+        properties: {
+          backgroundColor: { type: ["string", "boolean"] },
+          description: { type: "string" },
+          language: {
+            enum: ["ar", "en", "he"],
+            type: "string"
+          },
+          padding: { type: "string" },
+          title: { type: "string" },
+          rows: {
+            items: {
+              properties: {
+                columns: {
+                  items: {
+                    properties: {
+                      columnWidth: { type: "number" },
+                      dataFilters: s(),
+                      dataTransform: d(),
+                      graphDataConfiguration: h(
+                        void 0,
+                        "dashboard"
+                      ),
+                      graphType: {
+                        enum: i.map((a) => a.graphID),
+                        type: "string"
+                      },
+                      settings: t,
+                      dataSelectionOptions: u(),
+                      advancedDataSelectionOptions: g(),
+                      attachedFilter: {
+                        type: "string",
+                        ...n(e)
+                      }
+                    },
+                    type: "object",
+                    required: ["graphType"]
+                  },
+                  type: "array"
+                },
+                height: { type: "number" }
+              },
+              type: "object",
+              required: ["columns"]
+            },
+            type: "array"
+          }
+        },
+        type: "object",
+        required: ["rows"]
+      },
+      dataSettings: o(e),
+      filters: l(e),
+      noOfFiltersPerRow: { type: "number" },
+      uiMode: {
+        type: "string",
+        enum: ["light", "normal"]
+      },
+      filterPosition: { type: "string", enum: ["top", "side"] },
+      readableHeader: c(e),
+      dataFilters: s(e),
+      debugMode: { type: "boolean" },
+      theme: { type: "string", enum: ["dark", "light"] },
+      graphBackgroundColor: { oneOf: [{ type: "string" }, { type: "boolean" }] }
+    },
+    type: "object",
+    required: ["dashboardLayout", "dataSettings"]
+  };
+}, k = async () => {
+  const e = await p("allGraphs");
+  return {
+    properties: {
+      dashboardID: { type: "string" },
+      graphClassNames: { type: "object" },
+      graphStyles: { type: "object" },
+      dashboardLayout: {
+        properties: {
+          backgroundColor: { type: ["string", "boolean"] },
+          description: { type: "string" },
+          language: {
+            enum: ["ar", "en", "he"],
+            type: "string"
+          },
+          padding: { type: "string" },
+          dropdownLabel: { type: "string" },
+          title: { type: "string" },
+          rows: {
+            items: {
+              properties: {
+                columns: {
+                  items: {
+                    properties: {
+                      columnWidth: { type: "number" },
+                      dataFilters: s(),
+                      graphDataConfiguration: h(
+                        void 0,
+                        "dashboardWideToLong"
+                      ),
+                      graphType: {
+                        enum: i.filter((t) => t.availableInWideToLongFormat).map((t) => t.graphID),
+                        type: "string"
+                      },
+                      settings: e
+                    },
+                    type: "object",
+                    required: ["graphType"]
+                  },
+                  type: "array"
+                },
+                height: { type: "number" }
+              },
+              type: "object",
+              required: ["columns"]
+            },
+            type: "array"
+          }
+        },
+        type: "object",
+        required: ["rows"]
+      },
+      dataSettings: {
+        properties: {
+          ...o().properties,
+          keyColumn: { type: "string" }
+        },
+        required: ["keyColumn"],
+        type: "object"
+      },
+      uiMode: {
+        type: "string",
+        enum: ["light", "normal"]
+      },
+      dataFilters: s(),
+      readableHeader: c(),
+      debugMode: { type: "boolean" },
+      theme: { type: "string", enum: ["dark", "light"] },
+      graphBackgroundColor: { oneOf: [{ type: "string" }, { type: "boolean" }] }
+    },
+    type: "object",
+    required: ["dashboardLayout", "dataSettings"]
+  };
+};
+export {
+  g as getAdvancedDataSelectionSchema,
+  m as getColumnsToArraySchema,
+  w as getDashboardJSONSchema,
+  k as getDashboardWideToLongFormatJSONSchema,
+  s as getDataFiltersSchema,
+  f as getDataSchema,
+  S as getDataSchemaLink,
+  u as getDataSelectionSchema,
+  o as getDataSettingsSchema,
+  d as getDataTransformSchema,
+  l as getFiltersSchema,
+  C as getGraphConfigChartConfigIdEnum,
+  h as getGraphDataConfigurationSchema,
+  M as getGriddedGraphJSONSchema,
+  c as getReadableHeaderSchema,
+  p as getSettingsSchema,
+  b as getSettingsSchemaLink,
+  D as getSingleGraphJSONSchema
+};
+//# sourceMappingURL=getSchema.js.map