@undp/data-viz 2.2.0 → 2.2.1

package/dist/getSchema.js

@@ -1,1137 +0,0 @@
-import { g as i } from "./getGraphList-Bpd3PVmF.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 "hybridMap":
-      return "dataSchema/hybridMapDataSchema.json";
-    case "radarChart":
-      return "dataSchema/radarChartDataSchema.json";
-    case "waterfallChart":
-      return "dataSchema/waterfallChartDataSchema.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";
-    case "hybridMap":
-      return "settingsSchema/hybridMapSettingsSchema.json";
-    case "waterfallChart":
-      return "settingsSchema/waterfallChartSettingsSchema.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 l(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 "waterfallChart":
-      return ["label", "size", "color"];
-    case "hybridMap":
-      return ["lat", "long", "x", "id", "radius", "label", "date"];
-    case "bulletChart":
-      return ["label", "size", "target", "qualitativeRange", "date"];
-    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"]
-  }
-}), p = (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"
-}), d = async (e) => {
-  const t = await l("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"]
-  }
-}), u = (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 l("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 l(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: p(e),
-      noOfFiltersPerRow: {
-        type: "number"
-      },
-      graphType: {
-        type: "string",
-        enum: ["dataTable", "dataCards"]
-      },
-      dataTransform: u(e),
-      dataFilters: s(e),
-      readableHeader: c(e),
-      dataSelectionOptions: d(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: p(e),
-      classNames: {
-        type: "object"
-      },
-      styles: {
-        type: "object"
-      },
-      graphType: {
-        type: "string",
-        enum: i.map((r) => r.graphID)
-      },
-      noOfFiltersPerRow: {
-        type: "number"
-      },
-      dataTransform: u(e),
-      dataFilters: s(e),
-      graphDataConfiguration: h(e, t),
-      readableHeader: c(e),
-      dataSelectionOptions: d(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 l(t || "allGraphs");
-  return t === "dataTable" || t === "dataCards" ? {
-    type: "object",
-    properties: {
-      graphSettings: a,
-      dataSettings: o(e),
-      filters: p(e),
-      classNames: {
-        type: "object"
-      },
-      styles: {
-        type: "object"
-      },
-      noOfFiltersPerRow: {
-        type: "number"
-      },
-      graphType: {
-        type: "string",
-        enum: ["dataTable", "dataCards"]
-      },
-      uiMode: {
-        type: "string",
-        enum: ["light", "normal"]
-      },
-      dataTransform: u(e),
-      dataFilters: s(e),
-      noOfColumns: {
-        type: "number"
-      },
-      columnGridBy: {
-        type: "string"
-      },
-      showCommonColorScale: {
-        type: "boolean"
-      },
-      minGraphHeight: {
-        type: "number"
-      },
-      minGraphWidth: {
-        type: "number"
-      },
-      readableHeader: c(e),
-      dataSelectionOptions: d(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: p(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: u(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: d(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 l("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: u(),
-                      graphDataConfiguration: h(void 0, "dashboard"),
-                      graphType: {
-                        enum: i.map((a) => a.graphID),
-                        type: "string"
-                      },
-                      settings: t,
-                      dataSelectionOptions: d(),
-                      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: p(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 l("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,
-  d as getDataSelectionSchema,
-  o as getDataSettingsSchema,
-  u as getDataTransformSchema,
-  p as getFiltersSchema,
-  C as getGraphConfigChartConfigIdEnum,
-  h as getGraphDataConfigurationSchema,
-  M as getGriddedGraphJSONSchema,
-  c as getReadableHeaderSchema,
-  l as getSettingsSchema,
-  b as getSettingsSchemaLink,
-  D as getSingleGraphJSONSchema
-};
-//# sourceMappingURL=getSchema.js.map