@geoscene/charts-components 5.0.19

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

@@ -0,0 +1,364 @@
+export 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 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 const WebChartDataTransformations: {
+  readonly None: "none";
+  readonly Log: "logarithmic";
+  readonly Sqrt: "squareRoot";
+};
+
+export type WebChartDataTransformations =
+  (typeof WebChartDataTransformations)[keyof typeof WebChartDataTransformations];
+
+export const WebChartColoringPatterns: {
+  readonly Single: "singleColor";
+  readonly Match: "colorMatch";
+};
+
+export type WebChartColoringPatterns =
+  (typeof WebChartColoringPatterns)[keyof typeof WebChartColoringPatterns];
+
+export const WebChartLegendPositions: {
+  readonly Left: "left";
+  readonly Right: "right";
+  readonly Top: "top";
+  readonly Bottom: "bottom";
+};
+
+export type WebChartLegendPositions =
+  (typeof WebChartLegendPositions)[keyof typeof WebChartLegendPositions];
+
+export const WebChartStackedKinds: {
+  readonly Side: "sideBySide";
+  readonly Stacked: "stacked";
+  readonly Stacked100: "stacked100";
+};
+
+export type WebChartStackedKinds =
+  (typeof WebChartStackedKinds)[keyof typeof WebChartStackedKinds];
+
+export const WebChartBoxPlotMultipleSeriesKinds: {
+  readonly Side: "sideBySide";
+  readonly MeanLines: "meanLines";
+};
+
+export type WebChartBoxPlotMultipleSeriesKinds =
+  (typeof WebChartBoxPlotMultipleSeriesKinds)[keyof typeof WebChartBoxPlotMultipleSeriesKinds];
+
+export const WebChartSortOrderKinds: {
+  readonly Ascending: "ASC";
+  readonly Descending: "DESC";
+};
+
+export type WebChartSortOrderKinds =
+  (typeof WebChartSortOrderKinds)[keyof typeof WebChartSortOrderKinds];
+
+export 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 const WebChartLineSmoothedKinds: {
+  readonly Bezier: "bezier";
+  readonly MonotoneX: "monotoneX";
+  readonly MonotoneY: "monotoneY";
+};
+
+export type WebChartLineSmoothedKinds =
+  (typeof WebChartLineSmoothedKinds)[keyof typeof WebChartLineSmoothedKinds];
+
+/** The temporal binning units */
+export 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 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 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 const WebChartHeatChartHeatRulesTypes: {
+  readonly Gradient: "gradient";
+  readonly Renderer: "renderer";
+};
+
+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 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 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 const WebChartLabelBehavior: {
+  readonly Hide: "hide";
+  readonly Rotate: "rotate";
+  readonly Stagger: "stagger";
+  readonly Wrap: "wrap";
+};
+
+export type WebChartLabelBehavior =
+  (typeof WebChartLabelBehavior)[keyof typeof WebChartLabelBehavior];
+
+export 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 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 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 const SizePolicyScaleTypes: {
+  readonly Linear: "linear";
+  readonly Logarithmic: "logarithmic";
+};
+
+export type SizePolicyScaleTypes =
+  (typeof SizePolicyScaleTypes)[keyof typeof SizePolicyScaleTypes];
+
+/** Labels orientation for radar chart axes. */
+export 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 const WebChartOrderDataByTypes: {
+  readonly YValue: "geoscene-charts-y-value";
+  readonly Mean: "geoscene-charts-mean";
+  readonly Median: "geoscene-charts-median";
+  readonly Category: "geoscene-charts-category";
+  readonly MultiAxes: "geoscene-charts-multi-axes";
+};
+
+export type WebChartOrderDataByTypes =
+  (typeof WebChartOrderDataByTypes)[keyof typeof WebChartOrderDataByTypes];
+
+/**
+ * A data order option that allows the items to be ordered on both the x- and y-axes;
+ *
+ * For each axis, the order can be either a direction (ascending or descending) for all axis types;
+ * or a predefined list of labels when the axis is categorical.
+ *
+ * @remarks This order option is currently only used in heat charts.
+ */
+export interface WebChartMultiAxesDataOrder {
+  /** The type of order, which is two dimensional. */
+  orderType: "geoscene-charts-multi-axes";
+  /** The direction of the order for the x axis. If the axis is categorical, this can also be a predefined list of labels. */
+  orderByX?: string[] | WebChartSortOrderKinds;
+  /** The direction of the order for the y axis. If the axis is categorical, this can also be a predefined list of labels. */
+  orderByY?: string[] | WebChartSortOrderKinds;
+}
+
+/**
+ * A data order option that allows the items to be ordered either ascending or descending.
+ * This option can be used for the following types of order: by category, by mean, by median, and by y value.
+ *
+ * @remarks This order option is currently not available for Heat charts.
+ */
+export interface WebChartDirectionalDataOrder {
+  /** The type of order, eg by category, by mean, by median, or by y value. */
+  orderType:
+    | "geoscene-charts-category"
+    | "geoscene-charts-mean"
+    | "geoscene-charts-median"
+    | "geoscene-charts-y-value";
+  /** 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 that allows 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: "geoscene-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;
+}
+
+/** Represents the different types of views that can be applied to a heat chart. */
+export const WebChartHeatChartViewTypes: {
+  readonly singleCalendarView: "SingleCalendarView";
+  readonly sequentialCalendarViews: "SequentialCalendarViews";
+};
+
+export type WebChartHeatChartViewTypes =
+  (typeof WebChartHeatChartViewTypes)[keyof typeof WebChartHeatChartViewTypes];
+
+/** Class break types for data classification in charts. */
+export const WebChartClassBreakTypes: {
+  readonly equalInterval: "equal-interval";
+  readonly quantile: "quantile";
+  readonly naturalBreaks: "natural-breaks";
+  readonly manual: "manual";
+};
+
+/** Class break types for data classification in charts. */
+export type WebChartClassBreakTypes =
+  (typeof WebChartClassBreakTypes)[keyof typeof WebChartClassBreakTypes];

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

@@ -0,0 +1,11 @@
+/** @internal */
+export const defaultPieFromFieldsName: "geoscene_charts_pie_from_fields_name";
+
+/** @internal */
+export const defaultPieFromFieldsValue: "geoscene_charts_pie_from_fields_value";
+
+/** @internal */
+export const defaultBarLineFromFieldsName: "geoscene_charts_bar_line_from_fields_name";
+
+/** @internal */
+export const defaultBarLineFromFieldsValue: "geoscene_charts_bar_line_from_fields_value";

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

@@ -0,0 +1,104 @@
+import type { WebChartTemporalBinningUnits } from "./chart-object-literals.js";
+import type { Color, IExtent, ISimpleLineSymbol, ISymbol, SimpleFillSymbolStyle, SimpleLineSymbolStyle, SimpleMarkerSymbolStyle } from "./rest-js-types.js";
+
+/** JSON representation of the color object. */
+export interface RGBObject {
+  /** Red component of the color, in the range [0, 255]. */
+  r: number;
+  /** Green component of the color, in the range [0, 255]. */
+  g: number;
+  /** Blue component of the color, in the range [0, 255]. */
+  b: number;
+  /**
+   * Alpha component of the color.
+   *
+   * @default 1.0
+   */
+  a?: number;
+}
+
+export type IRendererSymbol = ISymbol
+  & {
+  style?: SimpleFillSymbolStyle | SimpleLineSymbolStyle | SimpleMarkerSymbolStyle;
+  color: Color;
+  outline?: ISimpleLineSymbol;
+  label?: string;
+  uniqueValue?: string;
+};
+
+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 scatterplot trend line. */
+export interface ScatterplotTrendLineData {
+  r2?: number;
+  trendLinePoints?: [WebChartDataItem, WebChartDataItem];
+}
+
+/** JSON representation of the processed data for a scatterplot. */
+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 chart, line chart, combo bar line chart, gauge, heat chart, pie chart and radar chart. */
+export interface WebChartGenericDataItem {
+  dataItems: WebChartDataItem[];
+  /**
+   * Time interval information.
+   *
+   * Only applicable to bar chart, line chart.
+   */
+  timeIntervalInfo?: TimeIntervalInfo;
+  /** Indicates whether the server limit has been reached when fetching data. */
+  serverLimitReached?: boolean;
+}
+
+/** JSON representation of a histogram bin. */
+export interface WebChartBin {
+  count: number;
+  /** Minimum value in the bin. */
+  minValue: number;
+  /** Maximum 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 type RGBArray = [number, number, number];

package/dist/spec/events.d.ts

@@ -0,0 +1,34 @@
+import type { WebChartDataItem } from "./data-source.js";
+import type { WebChartAxis } from "./web-chart.js";
+
+export 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. */
+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. */
+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,8 @@
+export * from "./web-chart";
+export type * from "./data-source";
+export * from "./chart-object-literals";
+export * from "./rest-js-object-literals";
+export * from "./config-defaults";
+export * from "./events";
+export type * from "./rest-js-types";
+

package/dist/spec/rest-js-object-literals.d.ts

@@ -0,0 +1,132 @@
+export const RESTFieldType: {
+    readonly Blob: "esriFieldTypeBlob";
+    readonly Date: "esriFieldTypeDate";
+    readonly DateOnly: "esriFieldTypeDateOnly";
+    readonly TimestampOffset: "esriFieldTypeTimestampOffset";
+    readonly Double: "esriFieldTypeDouble";
+    readonly Geometry: "esriFieldTypeGeometry";
+    readonly GlobalID: "esriFieldTypeGlobalID";
+    readonly GUID: "esriFieldTypeGUID";
+    readonly Integer: "esriFieldTypeInteger";
+    readonly SmallInteger: "esriFieldTypeSmallInteger";
+    readonly BigInteger: "esriFieldTypeBigInteger";
+    readonly OID: "esriFieldTypeOID";
+    readonly Raster: "esriFieldTypeRaster";
+    readonly Single: "esriFieldTypeSingle";
+    readonly String: "esriFieldTypeString";
+    readonly XML: "esriFieldTypeXML";
+};
+
+export type RESTFieldType = (typeof RESTFieldType)[keyof typeof RESTFieldType];
+
+export const RESTSimpleLineSymbolStyle: {
+    readonly Dash: "esriSLSDash";
+    readonly DashDot: "esriSLSDashDot";
+    readonly DashDotDot: "esriSLSDashDotDot";
+    readonly Dot: "esriSLSDot";
+    readonly Null: "esriSLSNull";
+    readonly Solid: "esriSLSSolid";
+};
+
+export type RESTSimpleLineSymbolStyle = (typeof RESTSimpleLineSymbolStyle)[keyof typeof RESTSimpleLineSymbolStyle];
+
+export const RESTSimpleMarkerSymbolStyle: {
+    readonly Circle: "esriSMSCircle";
+    readonly Cross: "esriSMSCross";
+    readonly Diamond: "esriSMSDiamond";
+    readonly Square: "esriSMSSquare";
+    readonly X: "esriSMSX";
+    readonly Triangle: "esriSMSTriangle";
+};
+
+export type RESTSimpleMarkerSymbolStyle = (typeof RESTSimpleMarkerSymbolStyle)[keyof typeof RESTSimpleMarkerSymbolStyle];
+
+export const RESTSimpleFillSymbolStyle: {
+    readonly BackwardDiagonal: "esriSFSBackwardDiagonal";
+    readonly Cross: "esriSFSCross";
+    readonly DiagonalCross: "esriSFSDiagonalCross";
+    readonly ForwardDiagonal: "esriSFSForwardDiagonal";
+    readonly Horizontal: "esriSFSHorizontal";
+    readonly Null: "esriSFSNull";
+    readonly Solid: "esriSFSSolid";
+    readonly Vertical: "esriSFSVertical";
+};
+
+export type RESTSimpleFillSymbolStyle = (typeof RESTSimpleFillSymbolStyle)[keyof typeof RESTSimpleFillSymbolStyle];
+
+export const RESTHorizontalAlignment: {
+    readonly Left: "left";
+    readonly Right: "right";
+    readonly Center: "center";
+    readonly Justify: "justify";
+};
+
+export type RESTHorizontalAlignment = (typeof RESTHorizontalAlignment)[keyof typeof RESTHorizontalAlignment];
+
+export const RESTVerticalAlignment: {
+    readonly Baseline: "baseline";
+    readonly Top: "top";
+    readonly Middle: "middle";
+    readonly Bottom: "bottom";
+};
+
+export type RESTVerticalAlignment = (typeof RESTVerticalAlignment)[keyof typeof RESTVerticalAlignment];
+
+export const RESTSymbolType: {
+    readonly SLS: "esriSLS";
+    readonly SMS: "esriSMS";
+    readonly SFS: "esriSFS";
+    readonly PMS: "esriPMS";
+    readonly PFS: "esriPFS";
+    readonly TS: "esriTS";
+};
+
+export type RESTSymbolType = (typeof RESTSymbolType)[keyof typeof RESTSymbolType];
+
+export const RESTFontStyle: {
+    readonly Italic: "italic";
+    readonly Normal: "normal";
+    readonly Oblique: "oblique";
+};
+
+export type RESTFontStyle = (typeof RESTFontStyle)[keyof typeof RESTFontStyle];
+
+export const RESTFontWeight: {
+    readonly Bold: "bold";
+    readonly Bolder: "bolder";
+    readonly Lighter: "lighter";
+    readonly Normal: "normal";
+};
+
+export type RESTFontWeight = (typeof RESTFontWeight)[keyof typeof RESTFontWeight];
+
+export const RESTFontDecoration: {
+    readonly LineThrough: "line-through";
+    readonly Underline: "underline";
+    readonly None: "none";
+};
+
+export type RESTFontDecoration = (typeof RESTFontDecoration)[keyof typeof RESTFontDecoration];
+
+export const RESTRendererType: {
+    readonly UniqueValue: "unique-value";
+    readonly Simple: "simple";
+    readonly ClassBreaks: "class-breaks";
+    readonly Heatmap: "heatmap";
+    readonly DotDensity: "dot-density";
+    readonly Dictionary: "dictionary";
+    readonly PieChart: "pie-chart";
+};
+
+export type RESTRendererType = (typeof RESTRendererType)[keyof typeof RESTRendererType];
+
+export const RESTUnits: {
+    readonly Feet: "feet";
+    readonly Miles: "miles";
+    readonly NauticalMiles: "nautical-miles";
+    readonly USNauticalMiles: "us-nautical-miles";
+    readonly Meters: "meters";
+    readonly Kilometers: "kilometers";
+};
+
+export type RESTUnits = (typeof RESTUnits)[keyof typeof RESTUnits];