@arcgis/charts-components 4.34.0-next.99 → 4.34.0

package/dist/model.js

@@ -1,38 +1,113 @@
-import { B as i, C as e, F as o, G as t, L as r, M as l, a as d, P as M, b as h, S as n, T as C } from "./chunks/common.js";
-import { a as p, e as W, i as x, g as S, b as g, r as y, h as K, l as P, m as c, p as B, k as D, q as f, n as F, j as G, o as L, d as T, f as u, c as b } from "./chunks/type-guards.js";
-import { c as A } from "./chunks/setup-utils.js";
+import { M as i } from "./chunks/common.js";
+import { B as m, C as y, F as g, G as w, L as C, a as f, P as u, b, S as p, T as L, c as T } from "./chunks/common.js";
+import { s as r, t as s, u as n } from "./chunks/type-guards.js";
+import { a as B, e as P, i as S, g as x, b as W, r as v, h as G, l as K, m as D, p as F, j as H, k as O, q as R, n as A, o as E, d as X, f as Y, c as $ } from "./chunks/type-guards.js";
 /*! All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/4.34/esri/copyright.txt for details.
-v4.34.0-next.99 */
+v4.34.0 */
+async function c(t) {
+  const o = "config" in t ? r(t.config) : t.chartType;
+  let a;
+  if (!("layer" in t) && !("iLayer" in t) && "config" in t && t.config.iLayer === void 0)
+    throw new Error(
+      "The source is missing. You can provide it to createModel through either `iLayer`, `layer`, or by setting the `config.iLayer` property."
+    );
+  switch (o) {
+    case i.LineChart: {
+      const { LineChartModel: e } = await import("./chunks/line-chart-model.js");
+      a = new e();
+      break;
+    }
+    case i.ComboBarLineChart: {
+      const { ComboBarLineChartModel: e } = await import("./chunks/combo-bar-line-chart-model.js");
+      a = new e();
+      break;
+    }
+    case i.PieChart: {
+      const { PieChartModel: e } = await import("./chunks/pie-chart-model.js");
+      a = new e();
+      break;
+    }
+    case i.Histogram: {
+      const { HistogramModel: e } = await import("./chunks/histogram-model.js");
+      a = new e();
+      break;
+    }
+    case i.Scatterplot: {
+      const { ScatterplotModel: e } = await import("./chunks/scatterplot-model.js");
+      a = new e();
+      break;
+    }
+    case i.BoxPlot: {
+      const { BoxPlotModel: e } = await import("./chunks/box-plot-model.js");
+      a = new e();
+      break;
+    }
+    case i.Gauge: {
+      const { GaugeModel: e } = await import("./chunks/gauge-model.js");
+      a = new e();
+      break;
+    }
+    case i.RadarChart: {
+      const { RadarChartModel: e } = await import("./chunks/radar-chart-model.js");
+      a = new e();
+      break;
+    }
+    case i.HeatChart: {
+      const { HeatChartModel: e } = await import("./chunks/heat-chart-model.js");
+      a = new e();
+      break;
+    }
+    case i.BarChart:
+    default: {
+      const { BarChartModel: e } = await import("./chunks/bar-chart-model.js");
+      a = new e();
+      break;
+    }
+  }
+  if (await a?.setup({
+    layer: "layer" in t ? t.layer : void 0,
+    iLayer: "iLayer" in t ? t.iLayer : void 0,
+    config: "config" in t ? t.config : void 0
+  }), o !== void 0 && s(a, o))
+    return a;
+  {
+    const e = n(a.chartType);
+    throw new Error(
+      `Please check the arguments provided to \`createModel\`. The generated model's type (\`${e}\`) does not match the type specified by either the \`chartType\` or the \`config\` argument (\`${o}\`).`
+    );
+  }
+}
 export {
-  i as BoxPlotDataSortingKinds,
-  e as ColorFormatKeys,
-  o as FormatKeys,
-  t as GuideOrientation,
-  r as LineFormatKeys,
-  l as ModelTypes,
-  d as PieChartDataModes,
-  M as PieChartDataSortingKinds,
-  h as PieChartSlicesDisplay,
-  n as SerialChartDataSortingKinds,
-  C as TextFormatKeys,
-  A as createModel,
-  p as isBarChartModel,
-  W as isBoxPlotModel,
-  x as isChartModel,
-  S as isHistogramModel,
-  g as isLineChartModel,
-  y as isModelOfType,
-  K as isModelWithBasicXAxis,
-  P as isModelWithDataLabels,
-  c as isModelWithGuides,
-  B as isModelWithLegend,
-  D as isModelWithRotation,
-  f as isModelWithTemporalBinning,
-  F as isModelWithXGuides,
-  G as isModelWithXYAxes,
-  L as isModelWithYGuides,
-  T as isPieChartModel,
-  u as isScatterplotModel,
-  b as isSerialChartModel
+  m as BoxPlotDataSortingKinds,
+  y as ColorFormatKeys,
+  g as FormatKeys,
+  w as GuideOrientation,
+  C as LineFormatKeys,
+  i as ModelTypes,
+  f as PieChartDataModes,
+  u as PieChartDataSortingKinds,
+  b as PieChartSlicesDisplay,
+  p as SerialChartDataSortingKinds,
+  L as TextFormatKeys,
+  c as createModel,
+  T as customSortString,
+  B as isBarChartModel,
+  P as isBoxPlotModel,
+  S as isChartModel,
+  x as isHistogramModel,
+  W as isLineChartModel,
+  v as isModelOfType,
+  G as isModelWithBasicXAxis,
+  K as isModelWithDataLabels,
+  D as isModelWithGuides,
+  F as isModelWithLegend,
+  H as isModelWithMultiAxes,
+  O as isModelWithRotation,
+  R as isModelWithTemporalBinning,
+  A as isModelWithXGuides,
+  E as isModelWithYGuides,
+  X as isPieChartModel,
+  Y as isScatterplotModel,
+  $ as isSerialChartModel
 };

package/dist/spec/chart-object-literals.d.ts

@@ -0,0 +1,288 @@
+export declare const WebChartTypes: {
+    readonly Chart: "chart";
+    readonly Text: "chartText";
+    readonly Overlay: "chartOverlay";
+    readonly Overlays: "chartOverlays";
+    readonly Legend: "chartLegend";
+    readonly CursorCrosshair: "cursorCrosshair";
+    readonly Axis: "chartAxis";
+    readonly GaugeAxisTick: "gaugeAxisTick";
+    readonly GaugeNeedle: "gaugeNeedle";
+    readonly CategoryAxisFormat: "category";
+    readonly NumberAxisFormat: "number";
+    readonly DateAxisFormat: "date";
+    readonly Guide: "chartGuide";
+    readonly ScatterSeries: "scatterSeries";
+    readonly PieSeries: "pieSeries";
+    readonly PieTick: "pieTick";
+    readonly GaugeSeries: "gaugeSeries";
+    readonly LineSeries: "lineSeries";
+    readonly BarSeries: "barSeries";
+    readonly HistogramSeries: "histogramSeries";
+    readonly BoxPlotSeries: "boxPlotSeries";
+    readonly RadarSeries: "radarSeries";
+    readonly ComboLineAndBarSeries: "comboLineAndBarSeries";
+    readonly HeatSeries: "heatSeries";
+    readonly Buffer: "buffer";
+    readonly SizePolicy: "sizeScale";
+    readonly CalendarDateParts: "calendarDateParts";
+};
+export type WebChartTypes = (typeof WebChartTypes)[keyof typeof WebChartTypes];
+export declare const WebChartStatisticType: {
+    readonly Count: "count";
+    readonly Sum: "sum";
+    readonly Minimum: "min";
+    readonly Maximum: "max";
+    readonly Average: "avg";
+    readonly StandardDeviation: "stddev";
+    readonly Variance: "var";
+    readonly ContinuousPercentile: "percentile-continuous";
+    readonly DiscretePercentile: "percentile-discrete";
+    readonly EnvelopeAggregate: "envelope-aggregate";
+    readonly CentroidAggregate: "centroid-aggregate";
+    readonly ConvexHullAggregate: "convex-hull-aggregate";
+    readonly NoAggregation: "no_aggregation";
+};
+export type WebChartStatisticType = (typeof WebChartStatisticType)[keyof typeof WebChartStatisticType];
+export declare const WebChartDataTransformations: {
+    readonly None: "none";
+    readonly Log: "logarithmic";
+    readonly Sqrt: "squareRoot";
+};
+export type WebChartDataTransformations = (typeof WebChartDataTransformations)[keyof typeof WebChartDataTransformations];
+export declare const WebChartColoringPatterns: {
+    readonly Single: "singleColor";
+    readonly Match: "colorMatch";
+};
+export type WebChartColoringPatterns = (typeof WebChartColoringPatterns)[keyof typeof WebChartColoringPatterns];
+export declare const WebChartLegendPositions: {
+    readonly Left: "left";
+    readonly Right: "right";
+    readonly Top: "top";
+    readonly Bottom: "bottom";
+};
+export type WebChartLegendPositions = (typeof WebChartLegendPositions)[keyof typeof WebChartLegendPositions];
+export declare const WebChartStackedKinds: {
+    readonly Side: "sideBySide";
+    readonly Stacked: "stacked";
+    readonly Stacked100: "stacked100";
+};
+export type WebChartStackedKinds = (typeof WebChartStackedKinds)[keyof typeof WebChartStackedKinds];
+export declare const WebChartBoxPlotMultipleSeriesKinds: {
+    readonly Side: "sideBySide";
+    readonly MeanLines: "meanLines";
+};
+export type WebChartBoxPlotMultipleSeriesKinds = (typeof WebChartBoxPlotMultipleSeriesKinds)[keyof typeof WebChartBoxPlotMultipleSeriesKinds];
+export declare const WebChartSortOrderKinds: {
+    readonly Ascending: "ASC";
+    readonly Descending: "DESC";
+};
+export type WebChartSortOrderKinds = (typeof WebChartSortOrderKinds)[keyof typeof WebChartSortOrderKinds];
+export declare const StatisticsDefaults: {
+    readonly statisticType: "count";
+    readonly sortingOrder: "ASC";
+};
+/**
+ * Represents the different types of smoothing that can be applied to a line chart when the `lineSmoothed` property is set to `true`.
+ */
+export declare const WebChartLineSmoothedKinds: {
+    readonly Bezier: "bezier";
+    readonly MonotoneX: "monotoneX";
+    readonly MonotoneY: "monotoneY";
+};
+export type WebChartLineSmoothedKinds = (typeof WebChartLineSmoothedKinds)[keyof typeof WebChartLineSmoothedKinds];
+/**
+ * The temporal binning units
+ */
+export declare const WebChartTemporalBinningUnits: {
+    readonly Second: "seconds";
+    readonly Minute: "minutes";
+    readonly Hour: "hours";
+    readonly Day: "days";
+    readonly Week: "weeks";
+    readonly Month: "months";
+    readonly Quarter: "quarters";
+    readonly Year: "years";
+};
+export type WebChartTemporalBinningUnits = (typeof WebChartTemporalBinningUnits)[keyof typeof WebChartTemporalBinningUnits];
+/**
+ * Represents the units that can be used for calendar-based date parts binning.
+ */
+export declare const WebChartCalendarDatePartsUnits: {
+    readonly DayOfMonth: "dayOfMonth";
+    readonly DayOfWeek: "dayOfWeek";
+    readonly DayOfYear: "dayOfYear";
+    readonly HourOfDay: "hourOfDay";
+    readonly MonthOfYear: "monthOfYear";
+    readonly MinuteOfDay: "minuteOfDay";
+    readonly WeekOfYear: "weekOfYear";
+    readonly QuarterOfYear: "quarterOfYear";
+};
+export type WebChartCalendarDatePartsUnits = (typeof WebChartCalendarDatePartsUnits)[keyof typeof WebChartCalendarDatePartsUnits];
+/**
+ * The temporal binning units for the calendar based binning offset
+ */
+export declare const WebChartCalendarBinningOffsetUnits: {
+    readonly Second: "seconds";
+    readonly Minute: "minutes";
+    readonly Hour: "hours";
+    readonly Day: "days";
+};
+export type WebChartCalendarBinningOffsetUnits = (typeof WebChartCalendarBinningOffsetUnits)[keyof typeof WebChartCalendarBinningOffsetUnits];
+/**
+ * Represents the different types of heat rule that can be applied to a heat chart.
+ */
+export declare const WebChartHeatChartHeatRulesTypes: {
+    readonly Gradient: "gradient";
+};
+export type WebChartHeatChartHeatRulesTypes = (typeof WebChartHeatChartHeatRulesTypes)[keyof typeof WebChartHeatChartHeatRulesTypes];
+/**
+ * Represents the different types of null policy that can be applied to a chart using the time binning feature.
+ */
+export declare const WebChartNullPolicyTypes: {
+    readonly Null: "null";
+    readonly Zero: "zero";
+    readonly Interpolate: "interpolate";
+};
+export type WebChartNullPolicyTypes = (typeof WebChartNullPolicyTypes)[keyof typeof WebChartNullPolicyTypes];
+/**
+ * Represents the different types of time aggregation that can be applied to a chart using the time binning feature.
+ */
+export declare const WebChartTimeAggregationTypes: {
+    readonly Start: "equalIntervalsFromStartTime";
+    readonly End: "equalIntervalsFromEndTime";
+};
+export type WebChartTimeAggregationTypes = (typeof WebChartTimeAggregationTypes)[keyof typeof WebChartTimeAggregationTypes];
+/**
+ * Represents the different types of behaviors that can applied to a chart axis.
+ */
+export declare const WebChartLabelBehavior: {
+    readonly Hide: "hide";
+    readonly Rotate: "rotate";
+    readonly Stagger: "stagger";
+    readonly Wrap: "wrap";
+};
+export type WebChartLabelBehavior = (typeof WebChartLabelBehavior)[keyof typeof WebChartLabelBehavior];
+export declare const WebChartVersionStatus: {
+    readonly Same: "same";
+    readonly Newer: "newer";
+    readonly Older: "older";
+    readonly Unrecognized: "unrecognized";
+};
+export type WebChartVersionStatus = (typeof WebChartVersionStatus)[keyof typeof WebChartVersionStatus];
+/**
+ * Represents the different types of axes that can be used in a chart.
+ */
+export declare const WebChartAxisTypes: {
+    readonly Value: "value";
+    readonly Date: "date";
+    readonly Category: "category";
+};
+export type WebChartAxisTypes = (typeof WebChartAxisTypes)[keyof typeof WebChartAxisTypes];
+/**
+ * Represents the different types of gauge charts.
+ */
+export declare const GaugeChartSubTypes: {
+    readonly FeatureGauge: "featureGauge";
+    readonly StatisticGauge: "statisticGauge";
+};
+export type GaugeChartSubTypes = (typeof GaugeChartSubTypes)[keyof typeof GaugeChartSubTypes];
+/**
+ * Represents the types of scales that can be applied to the size policy. Use by bubble charts (scatterplot).
+ */
+export declare const SizePolicyScaleTypes: {
+    readonly Linear: "linear";
+    readonly Logarithmic: "logarithmic";
+};
+export type SizePolicyScaleTypes = (typeof SizePolicyScaleTypes)[keyof typeof SizePolicyScaleTypes];
+/**
+ * Labels orientation for radar chart axes.
+ */
+export declare const WebChartRadarChartAxisLabelsOrientation: {
+    readonly Radial: "radial";
+    readonly Circular: "circular";
+    readonly Horizontal: "horizontal";
+};
+export type WebChartRadarChartAxisLabelsOrientation = (typeof WebChartRadarChartAxisLabelsOrientation)[keyof typeof WebChartRadarChartAxisLabelsOrientation];
+/**
+ * The types of order assocated with chart data.
+ */
+export declare const WebChartOrderDataByTypes: {
+    readonly YValue: "arcgis-charts-y-value";
+    readonly Mean: "arcgis-charts-mean";
+    readonly Median: "arcgis-charts-median";
+    readonly Category: "arcgis-charts-category";
+};
+export type WebChartOrderDataByTypes = (typeof WebChartOrderDataByTypes)[keyof typeof WebChartOrderDataByTypes];
+/**
+ * A data order option that the items are to be ordered either ascending or descending.
+ * It can be used for any type of order, like by category, by mean, by median, etc.
+ */
+export interface WebChartDirectionalDataOrder {
+    /**
+     * The type of order, eg by category, by mean, by median, or by y value.
+     */
+    orderType: WebChartOrderDataByTypes;
+    /**
+     * The direction of the order, either ascending or descending.
+     */
+    orderBy: WebChartSortOrderKinds;
+    /**
+     * Indicates whether to order data by the label or the value.
+     *
+     * For example, when a field has domain coded values or supbtypes, setting this property to `false` will order the data by the field value.
+     * Otherwise the domain description, subtypes description, or the alias of the field will be used to sort the data.
+     *
+     * @default true
+     */
+    preferLabel?: boolean;
+}
+/**
+ * A data order option for the items to be ordered by `category` based on a predefined list of labels.
+ */
+export interface WebChartPredefinedLabelsDataOrder {
+    /**
+     * The type of order, which is by category.
+     */
+    orderType: "arcgis-charts-category";
+    /**
+     * The predefined list of labels to order the data by.
+     *
+     * When the value of the `preferLabel` property is set to `false`, the `orderBy` list should be a list of
+     * coded domain values or field names; otherwise, it should be a list of domain descriptions, subtypes descriptions, or field aliases.
+     *
+     */
+    orderBy: string[];
+    /**
+     * Indicates whether to order data by the label or the value.
+     *
+     * For example, when a field has domain coded values or supbtypes, setting this property to `false` will order the data by the field value.
+     * Otherwise the domain description, subtypes description, or the alias of the field will be used to sort the data.
+     *
+     * When the value is set to `true` or undefined, the `orderBy` property should contain a list of labels like domain descriptions, subtypes descriptions, or field aliases.
+     * When the value is set to `false`, the `orderBy` property should contain a list of coded domain values or field names, in order for the data to be sorted correctly.
+     *
+     *
+     * @default true
+     */
+    preferLabel?: boolean;
+}
+/**
+ * Order options for split-by series.
+ */
+export interface WebChartOrderSeriesBy {
+    /**
+     * When the value is set to true, we want to order the split-by series based on the series' names (alias, custom label, or description).
+     *
+     * When the value is set to false, we want to order the split-by series based on the series' split-by values.
+     *
+     * @default true
+     */
+    preferLabel?: boolean;
+    /**
+     * The direction of the order.
+     *
+     * @default WebChartSortOrderKinds.Ascending
+     */
+    orderBy?: WebChartSortOrderKinds;
+}

package/dist/spec/config-defaults.d.ts

@@ -0,0 +1,4 @@
+export declare const defaultPieFromFieldsName = "arcgis_charts_pie_from_fields_name";
+export declare const defaultPieFromFieldsValue = "arcgis_charts_pie_from_fields_value";
+export declare const defaultBarLineFromFieldsName = "arcgis_charts_bar_line_from_fields_name";
+export declare const defaultBarLineFromFieldsValue = "arcgis_charts_bar_line_from_fields_value";

package/dist/spec/data-source.d.ts

@@ -0,0 +1,128 @@
+/// <reference types="@arcgis/core/interfaces.d.ts" />
+import { default as FeatureLayer } from '@arcgis/core/layers/FeatureLayer';
+import { default as SubtypeSublayer } from '@arcgis/core/layers/support/SubtypeSublayer';
+import { WebChartTemporalBinningUnits } from './chart-object-literals';
+import { Color, IExtent, ISimpleLineSymbol, ISymbol, SimpleFillSymbolStyle, SimpleLineSymbolStyle, SimpleMarkerSymbolStyle } from './rest-js-types';
+/**
+ * Supported layer type for ArcGIS charts.
+ */
+export type SupportedLayer = FeatureLayer | SubtypeSublayer;
+/**
+ * Esri Layer type
+ * @see {@link https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-Layer.html
+ */
+export type Layer = __esri.Layer;
+/**
+ * JSON representation of the color object
+ */
+export interface RGBObject {
+    r: number;
+    g: number;
+    b: number;
+    /**
+     * @default 1.0
+     */
+    a?: number;
+}
+export type IRendererSymbol = ISymbol & {
+    style?: SimpleFillSymbolStyle | SimpleLineSymbolStyle | SimpleMarkerSymbolStyle;
+    color: Color;
+    outline?: ISimpleLineSymbol;
+    label?: string;
+    uniqueValue?: string;
+};
+type RGBArray = [number, number, number];
+export type WebChartDataItemColor = Color | RGBArray | RGBObject | string;
+export type WebChartDataItemValue = Date | IExtent | IRendererSymbol | number[] | string[] | WebChartDataItem[] | WebChartDataItemColor | boolean | number | string | null | undefined;
+/**
+ * JSON representation of a typical data item
+ */
+export type WebChartDataItem = Record<string, WebChartDataItemValue>;
+/**
+ * JSON representation of the processed data for a Box Plot
+ */
+export interface WebChartBoxPlotDataItem {
+    dataItems: WebChartDataItem[];
+    outliers?: WebChartDataItem[];
+    meanLines?: WebChartDataItem[];
+}
+/**
+ * JSON representation of the processed data for a Scatter plot trend line
+ */
+export interface ScatterplotTrendLineData {
+    r2?: number;
+    trendLinePoints?: [WebChartDataItem, WebChartDataItem];
+}
+/**
+ * JSON representation of the processed data for a Scatter plot
+ */
+export interface WebChartScatterplotDataItem extends ScatterplotTrendLineData {
+    dataItems: WebChartDataItem[];
+    aggregated?: boolean;
+}
+export interface TimeIntervalInfo {
+    unit?: WebChartTemporalBinningUnits;
+    size?: number;
+}
+/**
+ * JSON representation of the generic data structure for bar, line bar-line, gauge and pie chart
+ */
+export interface WebChartGenericDataItem {
+    dataItems: WebChartDataItem[];
+    /**
+     * Time interval information, only for line charts
+     */
+    timeIntervalInfo?: TimeIntervalInfo;
+    /**
+     * Indicates whether the server limit has been reached when fetching data.
+     * Currently applies only to the queries leveraging the /queryBins operation.
+     */
+    serverLimitReached?: boolean;
+}
+/**
+ * JSON representation of a Histogram bin
+ */
+export interface WebChartBin {
+    count: number;
+    /**
+     * Min value in the bin
+     */
+    minValue: number;
+    /**
+     * Max value in the bin
+     */
+    maxValue: number;
+    /**
+     * Symbol associated with the bin.
+     */
+    symbol?: WebChartDataItem;
+    /**
+     * Whether this is the last bin.
+     */
+    isLastBin?: boolean;
+}
+/**
+ * JSON representation of the processed data for a Histogram
+ */
+export interface WebChartHistogramDataItem {
+    mean: number;
+    median: number;
+    stddev: number;
+    max: number;
+    min: number;
+    /**
+     * Sum of the values of all the points
+     */
+    sum?: number;
+    /**
+     * Number of all the points/features in un-binned data (including only non-null entries)
+     */
+    count?: number;
+    /**
+     * Number of null entries in the pool of points
+     */
+    nulls?: number;
+    bins: WebChartBin[];
+}
+export type WebChartDataTypes = WebChartBoxPlotDataItem | WebChartGenericDataItem | WebChartHistogramDataItem | WebChartScatterplotDataItem;
+export {};

package/dist/spec/events.d.ts

@@ -0,0 +1,36 @@
+import { WebChartDataItem } from './data-source';
+import { WebChartAxis } from './web-chart';
+export declare const OverlayTerms: {
+    readonly Mean: "Mean";
+    readonly Median: "Median";
+    readonly StdDev: "Standard Deviation";
+    readonly Normal: "Normal Distribution";
+    readonly Trendline: "Trendline";
+};
+export type OverlayTerms = (typeof OverlayTerms)[keyof typeof OverlayTerms];
+/**
+ * Represents a subset of the event payload carrying the chart's axes bounds.
+ * See event `arcgisChartsAxesMinMaxChange`.
+ */
+export interface CalculatedMinMaxBoundsPayload {
+    isXAxis: boolean;
+    isSecondValueAxis?: boolean;
+    minimum: WebChartAxis["minimum"];
+    maximum: WebChartAxis["maximum"];
+}
+/**
+ * Represents the payload of the event sent when a chart is removed from the chart list (component arcgis-charts-config-view-charts).
+ */
+export interface ChartDeletePayload {
+    chartId: string;
+}
+/**
+ * Represents the payload of the event sent when an item is toggled in the chart's legend (slice or series).
+ */
+export interface LegendItemVisibility {
+    visible: boolean;
+    seriesId?: string;
+    overlayType?: OverlayTerms;
+    sliceId?: string;
+    sliceData?: WebChartDataItem;
+}

package/dist/spec/index.d.ts

@@ -0,0 +1,7 @@
+export * from './web-chart.js';
+export type * from './data-source.js';
+export * from './chart-object-literals.js';
+export * from './rest-js-object-literals.js';
+export * from './config-defaults.js';
+export * from './events.js';
+export type * from './rest-js-types.js';