@arcgis/charts-components 4.34.0-next.105 → 4.34.0-next.106

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

@@ -0,0 +1,313 @@
+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 HeatChartSeries: "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];
+/**
+ * Represents the different types of temporal binning that can be applied to a chart.
+ */
+export declare const WebChartTemporalBinningTypes: {
+    readonly FixedDateBased: "fixedDateBased";
+    readonly CalendarBased: "calendarBased";
+};
+export type WebChartTemporalBinningTypes = (typeof WebChartTemporalBinningTypes)[keyof typeof WebChartTemporalBinningTypes];
+/**
+ * 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";
+};
+export type WebChartCalendarDatePartsUnits = (typeof WebChartCalendarDatePartsUnits)[keyof typeof WebChartCalendarDatePartsUnits];
+/**
+ * The temporal binning units for fixed-date based binning
+ */
+export declare const WebChartFixedDateBinningUnits: {
+    readonly Second: "seconds";
+    readonly Minute: "minutes";
+    readonly Hour: "hours";
+    readonly Day: "days";
+    readonly Week: "weeks";
+    readonly Month: "months";
+    readonly Year: "years";
+};
+export type WebChartFixedDateBinningUnits = (typeof WebChartFixedDateBinningUnits)[keyof typeof WebChartFixedDateBinningUnits];
+/**
+ * The temporal binning units for calendar based binning
+ */
+export declare const WebChartCalendarBinningUnits: {
+    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 WebChartCalendarBinningUnits = (typeof WebChartCalendarBinningUnits)[keyof typeof WebChartCalendarBinningUnits];
+/**
+ * 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 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,116 @@
+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;
+/**
+ * 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[];
+}
+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;
+}
+/**
+ * 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 * 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 * from './rest-js-types.js';

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

@@ -0,0 +1,109 @@
+export declare 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 declare 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 declare 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 declare 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 declare const RESTHorizontalAlignment: {
+    readonly Left: "left";
+    readonly Right: "right";
+    readonly Center: "center";
+    readonly Justify: "justify";
+};
+export type RESTHorizontalAlignment = (typeof RESTHorizontalAlignment)[keyof typeof RESTHorizontalAlignment];
+export declare const RESTVerticalAlignment: {
+    readonly Baseline: "baseline";
+    readonly Top: "top";
+    readonly Middle: "middle";
+    readonly Bottom: "bottom";
+};
+export type RESTVerticalAlignment = (typeof RESTVerticalAlignment)[keyof typeof RESTVerticalAlignment];
+export declare 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 declare const RESTFontStyle: {
+    readonly Italic: "italic";
+    readonly Normal: "normal";
+    readonly Oblique: "oblique";
+};
+export type RESTFontStyle = (typeof RESTFontStyle)[keyof typeof RESTFontStyle];
+export declare const RESTFontWeight: {
+    readonly Bold: "bold";
+    readonly Bolder: "bolder";
+    readonly Lighter: "lighter";
+    readonly Normal: "normal";
+};
+export type RESTFontWeight = (typeof RESTFontWeight)[keyof typeof RESTFontWeight];
+export declare const RESTFontDecoration: {
+    readonly LineThrough: "line-through";
+    readonly Underline: "underline";
+    readonly None: "none";
+};
+export type RESTFontDecoration = (typeof RESTFontDecoration)[keyof typeof RESTFontDecoration];
+export declare 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 declare 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];