import type { FieldJson } from "./FieldJson.js";
import type { ColorJson, PolygonSymbol3DJson, SimpleFillSymbolJson, Symbol2DJson, Symbol3DJson, SymbolJson } from "./SymbolJson.js";
/**
 * A renderer.
 *
 * Part of the ArcGIS REST API (see
 * http://resources.arcgis.com/en/help/rest/apiref/renderer.html).
 */
export type RendererJson = ClassBreaksRendererJson | HeatmapRendererJson | PointCloudRendererJson | PredominanceRendererJson | SimpleRendererJson | TemporalRendererJson | UniqueValueFromStyleRendererJson | UniqueValueRendererJson | VectorFieldRendererJson;
/**
 * The classification method for ClassBreaksRenderer.
 */
export type ClassificationMethodJsonType = "esriClassifyNaturalBreaks" | "esriClassifyEqualInterval" | "esriClassifyQuantile" | "esriClassifyStandardDeviation" | "esriClassifyGeometricalInterval" | "esriClassifyManual";
/**
 * A class breaks renderer symbolizes based on the value of some numeric
 * attribute. The classBreakInfo define the values at which the symbology
 * changes.
 *
 * If the Normalization Type property is defined than the class breaks contain a
 * normalized min/max value instead of the actual value. The data value,
 * obtained from the field property, is normalized using one of the following
 * functions before it is compared with the class breaks.
 *
 * 1. Field - Divide the data value using the attribute value of the field
 *    specified by the normalizationField property.
 * 2. Log - Compute the base 10 logarithm of the data value. This can be a useful
 *    approach for some data distributions because it reduced the influence of
 *    very large data values.
 * 3. Percent-of-total - Divide the data value by the sum of all data values then
 *    multiply by 100. Use the normalizationTotal property to determine the
 *    total value.
 *
 * See
 * {@link https://developers.arcgis.com/web-map-specification/objects/classBreaks_renderer/}
 * {@link https://developers.arcgis.com/web-scene-specification/objects/classBreaksRenderer/}.
 */
export interface ClassBreaksRendererJson extends RendererJsonBase {
    /**
     * Supported only for polygon features. It is a SimpleFillSymbol.
     */
    backgroundFillSymbol?: SimpleFillSymbolJson | PolygonSymbol3DJson | null;
    /**
     * Array of objects with value, label, and description.
     */
    classBreakInfos: ClassBreakInfoJson[];
    /**
     * Determines the classification method that was used to generate class
     * breaks.
     */
    classificationMethod: ClassificationMethodJsonType;
    /**
     * Default string for the default symbol used to draw unspecified values.
     */
    defaultLabel?: string | null;
    /**
     * Symbol used when a value cannot be classified.
     */
    defaultSymbol?: SymbolJson | null;
    /**
     * String value specifying the numeric field used in generating the class
     * breaks.
     */
    field: string;
    /**
     * The minimum numeric data value needed to begin class breaks.
     */
    minValue?: number | null;
    /**
     * Used when normalizationType is NormalizationType.BY_FIELD.
     */
    normalizationField?: string | null;
    /**
     * Used when normalizationType is NormalizationType.BY_FIELD.
     */
    normalizationTotal?: number | null;
    /**
     * One of the NormalizationType constants.
     */
    normalizationType?: "esriNormalizeByField" | "esriNormalizeByLog" | "esriNormalizeByPercentOfTotal" | null;
    /**
     * @inheritDoc
     */
    type: "classBreaks";
}
/**
 * The classBreaksInfo object provides information about the class breaks
 * associated with the renderer.
 *
 * See
 * {@link https://developers.arcgis.com/web-map-specification/objects/classBreakInfo/}
 * {@link https://developers.arcgis.com/web-scene-specification/objects/classBreakInfo/}.
 */
export interface ClassBreakInfoJson {
    /**
     * A numeric value used to specify the maximum value for a break.
     */
    classMaxValue: number;
    /**
     * A numeric value used to specify discontinuous class breaks. If this value
     * is null or is missing, the map server will calculate the minimum value
     * based on the preceding class' maximum value.
     */
    classMinValue?: number | null;
    /**
     * String value used to describe the drawn symbol.
     */
    description?: string | null;
    /**
     * String value used to label the drawn symbol.
     */
    label?: string | null;
    /**
     * An object used to display the value.
     */
    symbol: SymbolJson;
}
/**
 * The HeatmapRenderer renders point data into a raster visualization that
 * emphasizes areas of higher density or weighted values.
 *
 * See
 * {@link https://developers.arcgis.com/web-map-specification/objects/heatmapRenderer/}.
 */
export interface HeatmapRendererJson extends RendererJsonBase {
    /**
     * The radius (in pixels) of the circle over which the majority of each
     * points value is spread over.
     */
    blurRadius?: number | null;
    /**
     * Value specifying the field used in generating the heat map.
     */
    field?: string | null;
    /**
     * The pixel intensity value which is assigned the final color in the color
     * ramp.
     */
    maxPixelIntensity?: number | null;
    /**
     * The pixel intensity value which is assigned the initial color in the
     * color ramp.
     */
    minPixelIntensity?: number | null;
    /**
     * An array of colorStop objects describing the renderer's color ramp with
     * more specificity than just colors.
     */
    colorStops?: ColorStopJson[] | null;
    /**
     * @inheritDoc
     */
    type: "heatmap";
}
/**
 * Defines how features are rendered on the map.
 */
export type PointCloudRendererJson = PointCloudClassBreaksRendererJson | PointCloudRGBRendererJson | PointCloudStretchRendererJson | PointCloudUniqueValueRendererJson;
/**
 * The renderer assigned to the layer. The renderer defines how to visualize
 * each point in the layer.
 *
 * See
 * {@link https://developers.arcgis.com/web-scene-specification/objects/pointCloudRenderer/}.
 */
export interface PointCloudRendererJsonBase extends RendererJsonBase {
    /**
     * Indicates whether modulation should be used to render the point.
     *
     * See
     * {@link https://developers.arcgis.com/web-scene-specification/objects/colorModulationInfo/}.
     */
    colorModulation?: {
        /**
         * The attribute to use as a source for the modulation amplitude.
         */
        field?: string | null;
        /**
         * Maximum value to compute modulation linear mapping.
         */
        maxValue?: number | null;
        /**
         * Minimum value to compute modulation linear mapping.
         */
        minValue?: number | null;
    } | null;
    /**
     * The name of the field that is used for the renderer.
     */
    field?: string | null;
    /**
     * A transform that is applied to the field value before evaluating the
     * renderer.
     */
    fieldTransformType?: "none" | "lowFourBit" | "highFourBit" | "absoluteValue" | "moduloTen" | null;
    /**
     * Size algorithms for point cloud performance.
     */
    pointSizeAlgorithm?: PointCloudSplatAlgorithmJson | PointCloudFixedSizeAlgorithmJson | null;
    /**
     * Number of point to draw per display inch.
     */
    pointsPerInch?: number | null;
}
/**
 * PointCloudClassBreaksRenderer defines the color of each point in a
 * PointCloudLayer based on the value of a numeric attribute. Colors are
 * assigned based on classes or ranges of data. Each point is assigned a symbol
 * based on the class break in which the value of the attribute falls.
 *
 * See
 * {@link https://developers.arcgis.com/web-scene-specification/objects/pointCloudClassBreaksRenderer/}.
 */
export interface PointCloudClassBreaksRendererJson extends PointCloudRendererJsonBase {
    /**
     * Each element in the array is an object that provides information about a
     * class break associated with the renderer.
     */
    colorClassBreakInfos?: ColorClassBreakInfoJson[] | null;
    /**
     * @inheritDoc
     */
    type: "pointCloudClassBreaksRenderer";
}
/**
 * PointCloudRGBRenderer defines the color of each point in a PointCloudLayer
 * based on the value of a color attribute.
 *
 * See
 * {@link https://developers.arcgis.com/web-scene-specification/objects/pointCloudRGBRenderer/}.
 */
export interface PointCloudRGBRendererJson extends PointCloudRendererJsonBase {
    /**
     * @inheritDoc
     */
    type: "pointCloudRGBRenderer";
}
/**
 * PointCloudStretchRenderer defines the color of each point in a
 * PointCloudLayer based on the value of a numeric attribute. They allow you to
 * easily map continuous color ramps to minimum and maximum data values of one
 * of the layer's numeric attribute fields.
 *
 * See
 * {@link https://developers.arcgis.com/web-scene-specification/objects/pointCloudStretchRenderer/}.
 */
export interface PointCloudStretchRendererJson extends PointCloudRendererJsonBase {
    /**
     * @inheritDoc
     */
    type: "pointCloudStretchRenderer";
}
/**
 * PointCloudUniqueValueRenderer allows you to colorize points in a
 * PointCloudLayer based on an attribute. This is done by using unique colors to
 * represent points with equal attribute values.
 *
 * See
 * {@link https://developers.arcgis.com/web-scene-specification/objects/pointCloudUniqueValueRenderer/}.
 */
export interface PointCloudUniqueValueRendererJson extends PointCloudRendererJsonBase {
    /**
     * Unique value infos.
     */
    colorUniqueValueInfos?: ColorUniqueValueInfosJson[] | null;
    /**
     * @inheritDoc
     */
    type: "pointCloudUniqueValueRenderer";
}
/**
 * Render points using sizes depending on point density.
 *
 * See
 * {@link https://developers.arcgis.com/web-scene-specification/objects/pointCloudSplatAlgorithm/}.
 */
export interface PointCloudSplatAlgorithmJson {
    /**
     * Minimum display space point size in points.
     */
    minSize?: number | null;
    /**
     * Scale factor to applied to the computed point size (in real world).
     */
    scaleFactor?: number | null;
    /**
     * Type:String Value of this property must be pointCloudSplatAlgorithm.
     */
    type: "pointCloudSplatAlgorithm";
}
/**
 * Render points with fixed real world or screen space size.
 *
 * See
 * {@link https://developers.arcgis.com/web-scene-specification/objects/pointCloudFixedSizeAlgorithm/}.
 */
export interface PointCloudFixedSizeAlgorithmJson {
    /**
     * Symbol size in real world units or display unit.
     */
    size?: number | null;
    /**
     * Type:String Value of this property must be pointCloudFixedSizeAlgorithm.
     */
    type: "pointCloudFixedSizeAlgorithm";
    /**
     * If true symbol size is in meters, display unit (pt) otherwise.
     */
    useRealWorldSymbolSizes?: boolean | null;
}
/**
 * The classBreaksInfo object provides information about the class breaks
 * associated with the renderer.
 *
 * See
 * {@link https://developers.arcgis.com/web-scene-specification/objects/colorClassBreakInfo/}.
 */
export interface ColorClassBreakInfoJson {
    /**
     * A numeric value used to specify the maximum value for a break.
     */
    classMaxValue?: number | null;
    /**
     * A numeric value used to specify discontinuous class breaks. If this value
     * is null or is missing, the map server will calculate the minimum value
     * based on the preceding class' maximum value.
     */
    classMinValue?: number | null;
    /**
     * Color is represented as a three or four-element array.
     */
    color?: ColorJson | null;
    /**
     * String value used to describe the class.
     */
    description?: string | null;
    /**
     * String value used to label the class.
     */
    label?: string | null;
}
/**
 * The classBreaksInfo object provides information about the class breaks
 * associated with the renderer.
 *
 * See
 * {@link https://developers.arcgis.com/web-scene-specification/objects/colorUniqueValueInfo/}.
 */
export interface ColorUniqueValueInfosJson {
    /**
     * Color is represented as a three or four-element array.
     */
    color?: ColorJson | null;
    /**
     * String value used to describe the class.
     */
    description?: string | null;
    /**
     * String value used to label the class.
     */
    label?: string | null;
    /**
     * List of string values used to classify points.
     */
    values?: string[] | null;
}
/**
 * This renderer is a type of UniqueValue renderer which is based off the
 * valueExpression property rather than field. Optionally, size and/or
 * transparency visual variables may be included with valueExpression. Note that
 * this renderer is supported for ArcGIS Online hosted feature services and
 * feature collections.
 *
 * See
 * {@link https://developers.arcgis.com/web-map-specification/objects/predominance_renderer/}.
 */
export interface PredominanceRendererJson extends RendererJsonBase {
    /**
     * A simple fill symbol that is only for polygon features.
     */
    backgroundFillSymbol: SimpleFillSymbolJson;
    /**
     * Default string for the default symbol used to draw unspecified values.
     */
    defaultLabel?: string | null;
    /**
     * Symbol used when a value cannot be classified.
     */
    defaultSymbol?: Symbol2DJson | null;
    /**
     * Array of objects with value, label, description and symbol.
     */
    uniqueValueInfos: UniqueValueInfoJson[];
    /**
     * @inheritDoc
     */
    type: "predominance";
}
/**
 * A simple renderer is a renderer that uses one symbol only.
 *
 * See
 * {@link https://developers.arcgis.com/web-map-specification/objects/simple_renderer/}
 * {@link https://developers.arcgis.com/web-scene-specification/objects/simpleRenderer/}.
 */
export interface SimpleRendererJson extends RendererJsonBase {
    /**
     * The text string that does not appear in the table of contents but may
     * appear in the legend.
     */
    description?: string | null;
    /**
     * The text string that is displayed in the table of contents.
     */
    label?: string | null;
    /**
     * An object that represents how all features will be drawn.
     */
    symbol: SymbolJson;
    /**
     * @inheritDoc
     */
    type: "simple";
}
/**
 * A temporal renderer is used to perform time-based rendering of features in a
 * feature layer.
 *
 * See
 * {@link https://developers.arcgis.com/web-map-specification/objects/temporalRenderer/}.
 */
export interface TemporalRendererJson extends RendererJsonBase {
    /**
     * Simple renderer used to symbolize point geometries for the most current
     * observations.
     */
    latestObservationRenderer?: SimpleRendererJson | null;
    /**
     * Simple renderer used to symbolize regular/historic observations.
     */
    observationalRenderer?: SimpleRendererJson | null;
    /**
     * Simple renderer used to symbolize the tracks.
     */
    trackRenderer?: SimpleRendererJson | null;
    /**
     * @inheritDoc
     */
    type: "temporal";
}
/**
 * This is a special version of UniqueValue Renderer, which loads uniqueValue
 * infos from a portal style.
 *
 * See
 * {@link https://developers.arcgis.com/web-scene-specification/objects/uniqueValueFromStyleRenderer/}.
 */
export interface UniqueValueFromStyleRendererJson extends RendererJsonBase {
    /**
     * Default string for the default symbol used to draw unspecified values.
     */
    defaultLabel?: string | null;
    /**
     * The defaultSymbol on the renderer that get assigned to features with no
     * value or features that do not fall within the configured data.
     */
    defaultSymbol?: Symbol3DJson | null;
    /**
     * String value specifying the first field used to render matching values.
     */
    field1: string;
    /**
     * A registered web style name. Can not be used in conjunction with
     * styleName.
     */
    styleName?: string | null;
    /**
     * URL that points to the web style definition. Can not be used in
     * conjunction with styleUrl.
     */
    styleUrl?: string | null;
    /**
     * @inheritDoc
     */
    type: "uniqueValue";
}
/**
 * A unique value renderer symbolizes groups of features that have matching
 * field values.
 *
 * See
 * {@link https://developers.arcgis.com/web-map-specification/objects/uniqueValue_renderer/}
 * {@link https://developers.arcgis.com/web-scene-specification/objects/uniqueValueRenderer/}.
 */
export interface UniqueValueRendererJson extends RendererJsonBase {
    /**
     * A SimpleFillSymbol used for polygon features. It can only be used for
     * bivariate types and size rendering.
     */
    backgroundFillSymbol?: PolygonSymbol3DJson | null;
    /**
     * Default string for the default symbol used to draw unspecified values.
     */
    defaultLabel?: string | null;
    /**
     * Symbol used when a value cannot be matched.
     */
    defaultSymbol?: SymbolJson | null;
    /**
     * String value specifying the first field used to render matching values.
     */
    field1: string;
    /**
     * String value specifying the second field used to render matching values.
     */
    field2?: string | null;
    /**
     * String value specifying the third field used to render matching values.
     */
    field3?: string | null;
    /**
     * String value inserted between values if multiple attribute fields are
     * specified.
     */
    fieldDelimiter?: string | null;
    /**
     * An array of uniqueValueInfo objects. If uniqueValueGroups is present,
     * then this property should be ignored during webmap reading. In the
     * future, this property will be deprecated and eventually removed.
     */
    uniqueValueInfos?: UniqueValueInfoJson[] | null;
    /**
     * An array of uniqueValueGroup objects. If present, then uniqueValueGroups
     * should be used in favor of uniqueValueInfos.
     */
    uniqueValueGroups?: UniqueValueGroupJson[] | null;
    /**
     * @inheritDoc
     */
    type: "uniqueValue";
}
/**
 * The following is a list of properties found on the uniqueValueInfo object,
 * which is one of the properties on the renderer object. The uniqueValueInfo
 * object contains the symbology for each uniquely drawn value in the renderer.
 *
 * See
 * {@link https://developers.arcgis.com/web-map-specification/objects/uniqueValueInfo/}
 * {@link https://developers.arcgis.com/web-scene-specification/objects/uniqueValueInfo/}.
 */
export interface UniqueValueInfoJson {
    /**
     * String value used to describe the drawn symbol.
     */
    description?: string | null;
    /**
     * String value used to label the drawn symbol.
     */
    label?: string | null;
    /**
     * An object used to display the value.
     */
    symbol: SymbolJson;
    /**
     * String value indicating the unique value.
     */
    value: string;
}
/**
 * Represents a group of unique value classes (i.e. symbols). This is used to
 * group symbols under a common heading and/or when representing multiple unique
 * values with a single symbol.
 *
 * See
 * {@link https://developers.arcgis.com/web-map-specification/objects/uniqueValueGroup/}
 * {@link https://developers.arcgis.com/web-scene-specification/objects/uniqueValueGroup/}.
 */
export interface UniqueValueGroupJson {
    /**
     * Specifies the classes (i.e. symbols) to group under a common heading.
     * Classes may be included here without a heading when representing multiple
     * values with a single symbol.
     */
    classes?: UniqueValueClassJson[] | null;
    /**
     * The heading to be displayed for the collection of classes defined in this
     * group.
     */
    heading?: string | null;
}
/**
 * The uniqueValueClass object contains the symbology for grouped unique values
 * in the renderer.
 *
 * See
 * {@link https://developers.arcgis.com/web-map-specification/objects/uniqueValueClass/}
 * {@link https://developers.arcgis.com/web-scene-specification/objects/uniqueValueClass/}.
 */
export interface UniqueValueClassJson {
    /**
     * String value used to describe the drawn symbol.
     */
    description?: string | null;
    /**
     * String value used to label the drawn symbol.
     */
    label?: string | null;
    /**
     * An object used to display the value.
     */
    symbol: SymbolJson;
    /**
     * A list of unique values that should be rendered with the same symbol.
     * Each item in the list represents a set of value combinations represented
     * by the given symbol. The inner array must contain only one value if only
     * field1 is specified, two values if field1 and field2 are specified, or
     * three values if field1, field2, and field3 are specified. The inner
     * arrays must not contain more than three values.
     */
    values: string[][];
}
/**
 * A vector field renderer is a renderer that uses symbolizes a U-V or
 * Magnitude-Direction data.
 */
export interface VectorFieldRendererJson extends RendererJsonBase {
    /**
     * Name of the feature attribute field that contains the data value.
     */
    attributeField: "Magnitude";
    /**
     * Sets the flow direction of the data.
     */
    flowRepresentation: "flow_from" | "flow_to";
    /**
     * Input unit for Magnitude.
     */
    inputUnit?: MagnitudeUnitJsonType | null;
    /**
     * Output unit for Magnitude.
     */
    outputUnit?: MagnitudeUnitJsonType | null;
    /**
     * A predefined style.
     */
    style: "beaufort_ft" | "beaufort_km" | "beaufort_kn" | "beaufort_m" | "beaufort_mi" | "classified_arrow" | "ocean_current_kn" | "ocean_current_m" | "simple_scalar" | "single_arrow" | "wind_speed";
    /**
     * Determines the density of the symbols. Larger tile size, fewer symbols
     * appear in the display. The VectorFieldRenderer draws one symbol within a
     * defined tile size (in pixels). The default is 50 pixels.
     */
    symbolTileSize?: number | null;
    /**
     * @inheritDoc
     */
    type: "vectorField";
}
/**
 * Units of magnitude.
 */
export type MagnitudeUnitJsonType = "esriFeetPerSecond" | "esriKilometersPerHour" | "esriKnots" | "esriMetersPerSecond" | "esriMilesPerHour";
/**
 * Defines how features are rendered on the map.
 *
 * See
 * {@link https://developers.arcgis.com/web-map-specification/objects/renderer/}
 * {@link https://developers.arcgis.com/web-scene-specification/objects/renderer/}.
 */
export interface RendererJsonBase {
    /**
     * An object containing metadata about the authoring process for creating a
     * renderer object. This allows the authoring clients to save specific
     * overridable settings so that next time it is accessed via the UI, their
     * selections are remembered. Non-authoring clients should ignore it.
     */
    authoringInfo?: AuthoringInfoJson | null;
    /**
     * The type of renderer. See {@link RendererJsonType}.
     */
    type: RendererJsonType;
    /**
     * A constant value or an expression that derives the angle of rotation
     * based on a feature attribute value. When an attribute name is specified,
     * it's enclosed in square brackets.
     */
    rotationExpression?: string | null;
    /**
     * String value (either geographic or arithmetic) which controls the origin
     * and direction of rotation on point features. If the rotationType is
     * defined as 'arithmetic', the symbol is rotated from East in a
     * counter-clockwise direction where East is the 0� axis. If the
     * rotationType is defined as 'geographic', the symbol is rotated from North
     * in a clockwise direction where North is the 0� axis.
     */
    rotationType?: RotationJsonType | null;
    /**
     * An array of visualVariable objects used for continuous color or size,
     * simple, and unique values with feature opacity.
     */
    visualVariables?: VisualVariableJson[] | null;
}
/**
 * The type of rotation for RendererBase.
 */
export type RotationJsonType = "arithmetic" | "geographic";
/**
 * The authoringInfo is an object containing metadata about the authoring
 * process for creating a renderer object. This allows the authoring clients to
 * save specific overridable settings so that next time it is accessed via the
 * UI, their selections are remembered. Non-authoring clients should ignore it.
 * In order to support the slider with color/size/transparency information, the
 * selection of the various themes, classification, and additional properties
 * are saved within this object.
 *
 * Note: The authoringInfo object is not required with a renderer. It is only
 * used if rendering was generated using Map Viewer rendering tools.
 *
 * See
 * {@link https://developers.arcgis.com/web-map-specification/objects/authoringInfo/}
 * {@link https://developers.arcgis.com/web-scene-specification/objects/authoringInfo/}.
 */
export interface AuthoringInfoJson {
    /**
     * Used for classed color or size. The default value is esriClassifyManual.
     */
    classificationMethod?: ClassificationMethodJsonType | null;
    /**
     * A colorRamp object is used to specify a range of colors that are applied
     * to a group of symbols.
     */
    colorRamp?: ColorRampJson | null;
    /**
     * Contains information about an attribute field.
     */
    field?: FieldJson | null;
    /**
     * An array of string values representing field names used for creating
     * predominance renderers.
     */
    fields?: string | null;
    /**
     * Use if the classificationMethod is esriClassifyStandardDeviation.
     * Possible values: 0.25, 0.33, 0.5, 1.
     */
    standardDeviationInterval?: number | null;
    /**
     * In case of classed renderers this is set to either classedSize or
     * classedColor.
     */
    type?: AuthoringInfoJsonType | null;
    /**
     * An array of visualVariable objects used for continuous color or size,
     * simple, and unique values with feature opacity.
     */
    visualVariables?: VisualVariableJson | null;
}
/**
 * A colorRamp object is used to specify a range of colors that are applied to a
 * group of symbols. See
 * {@link https://developers.arcgis.com/web-map-specification/objects/colorRamp/}.
 */
export interface ColorRampJson {
    /**
     * Algorithm used for calculating the ramp.
     */
    algorithm?: "esriCIELabAlgorithm" | "esriHSVAlgorithm" | "esriLabLChAlgorithm" | null;
    /**
     * A multipart color ramp is defined by a list of constituent color ramps.
     */
    colorRamps?: ColorRampJson[] | null;
    /**
     * Array representing the initial color to start the ramp from.
     */
    fromColor?: [number, number, number, number] | null;
    /**
     * Array representing the final color to end the ramp with.
     */
    toColor?: [number, number, number, number] | null;
    /**
     * Value indicating the type of colorRamp.
     */
    type: "algorithmic" | "multipart";
}
/**
 * The type of the AuthoringInfo.
 */
export type AuthoringInfoJsonType = "classedColor" | "classedSize" | "predominance";
/**
 * The type of the Renderer.
 */
export type RendererJsonType = "simple" | "uniqueValue" | "classBreaks" | "temporal" | "predominance" | "heatmap" | "pointCloudRGBRenderer" | "pointCloudClassBreaksRenderer" | "pointCloudStretchRenderer" | "pointCloudUniqueValueRenderer" | "vectorField";
/**
 * Base interface for VisualVariables.
 */
export interface VisualVariableJsonBase {
    /**
     * A string value indicating the name of the feature attribute field that
     * contains the data value to render.
     */
    field: string;
    /**
     * Options available for the legend. See
     * {@link https://developers.arcgis.com/web-map-specification/objects/legendOptions/}
     * {@link https://developers.arcgis.com/web-scene-specification/objects/legendOptions/}.
     */
    legendOptions?: {
        /**
         * The title of the legend.
         */
        title?: string | null;
        /**
         * Indicates whether to show color/size ramp in the legend.
         */
        showLegend?: boolean | null;
    } | null;
    /**
     * String value indicating the name of the attribute field used to normalize
     * the data.
     */
    normalizationField?: string | null;
    /**
     * The type of the VisualVariable.
     */
    type: VisualVariableJsonType;
}
/**
 * The type of the VisualVariable.
 */
export type VisualVariableJsonType = "colorInfo" | "sizeInfo" | "transparencyInfo" | "rotationInfo";
/**
 * A visualVariable is an object containing the type of drawing property, the
 * axis the variable is applied to, and additional properties for the variable.
 * There are three types of visual variables, 'colorInfo', 'sizeInfo', and
 * 'transparencyInfo'.
 *
 * See
 * {@link https://developers.arcgis.com/web-map-specification/objects/visualVariable/}
 * {@link https://developers.arcgis.com/web-scene-specification/objects/visualVariable/}.
 */
export type VisualVariableJson = ColorInfoJson | SizeInfoJson | TransparencyInfoJson | RotationInfoJson;
/**
 * The colorInfo visual variable defines how a continuous color ramp is applied
 * to features based on the values of a numeric field attribute. The minimum and
 * maximum values of the data should be indicated along with their respective
 * color values. You must specify either colors or stops to construct the color
 * ramp.
 *
 * See
 * {@link https://developers.arcgis.com/web-map-specification/objects/colorInfo_visualVariable/}
 * {@link https://developers.arcgis.com/web-scene-specification/objects/colorInfo_visualVariable/}.
 */
export interface ColorInfoJson extends VisualVariableJsonBase {
    /**
     * An array of colors that define the color ramp. Either colors or stops
     * must be specified to construct the color ramp.
     */
    colors?: ColorJson[] | null;
    /**
     * The maximum data value.
     */
    maxDataValue?: number | null;
    /**
     * The minimum data value.
     */
    minDataValue?: number | null;
    /**
     * String value indicating the name of the attribute field used to normalize
     * the data.
     */
    normalizationField?: string | null;
    /**
     * An array of stop objects.
     */
    stops?: ColorStopJson[] | null;
    /**
     * @inheritDoc
     */
    type: "colorInfo";
}
/**
 * The rotation visual variable defines how features rendered with marker
 * symbols are rotated. The rotation value is determined by mapping the values
 * to data in a field, or by other arithmetic means with a function.
 *
 * See
 * {@link https://developers.arcgis.com/web-scene-specification/objects/rotationInfo_visualVariable/}
 * {@link https://developers.arcgis.com/web-map-specification/objects/rotationInfo_visualVariable/}.
 */
export interface RotationInfoJson extends VisualVariableJsonBase {
    /**
     * Defines the origin and direction of rotation depending on how the angle
     * of rotation was measured. Possible values are geographic which rotates
     * the symbol from the north in a clockwise direction and arithmetic which
     * rotates the symbol from the east in a counter-clockwise direction.
     *
     * Must be one of the following values: geographic, arithmetic.
     */
    rotationType?: RotationJsonType | null;
    /**
     * An Arcade expression that computes a value in lieu of a value provided by
     * an attribute field.
     */
    valueExpression?: string | null;
    /**
     * @inheritDoc
     */
    type: "rotationInfo";
}
/**
 * The sizeInfo visual variable defines how a continuous color ramp is applied
 * to features based on the values of a numeric field attribute. The minimum and
 * maximum values of the data should be indicated along with their respective
 * color values. You must specify either colors or stops to construct the color
 * ramp.
 *
 * See
 * {@link https://developers.arcgis.com/web-map-specification/objects/sizeInfo_visualVariable/}
 * {@link https://developers.arcgis.com/web-scene-specification/objects/sizeInfo_visualVariable/}.
 */
export interface SizeInfoJson extends VisualVariableJsonBase {
    /**
     * Defines the axis the size visual variable should be applied to when
     * rendering features with an ObjectSymbol3DLayer.
     */
    axis?: "width" | "height" | "depth" | "widthAndDepth" | "all" | null;
    /**
     * Specifies the largest marker size to use at any given map scale. This is
     * required if valueUnit is set to unknown. In addition to this property
     * taking an object, it also accepts a number value.
     */
    maxSize?: SizeJson | number | null;
    /**
     * The maximum data value.
     */
    maxDataValue?: number | null;
    /**
     * The minimum data value.
     */
    minDataValue?: number | null;
    /**
     * Specifies the smallest marker size to use at any given map scale. This is
     * required if valueUnit is set to 'unknown'. In addition to this property
     * taking an object, it also accepts a number value.
     */
    minSize?: number | SizeJson | null;
    /**
     * An array of objects that define the maximum size of the symbol at various
     * values of the expression.
     */
    stops?: SizeStopJson[] | null;
    /**
     * String value indicating that the sizeInfo should be applied to the
     * outline of polygons.
     */
    target?: "outline" | null;
    /**
     * @inheritDoc
     */
    type: "sizeInfo";
    /**
     * When setting a size visual variable on a renderer using an
     * ObjectSymbol3DLayer, this property indicates whether to apply the value
     * defined by the height, width, or depth properties to the corresponding
     * axis of this visual variable instead of proportionally scaling this axis'
     * value after other axes.
     */
    useSymbolValue?: boolean | null;
    /**
     * Specifies how to apply the data value when mapping real-world sizes. See
     * table below for supported values.
     */
    valueRepresentation?: "radius" | "diameter" | "area" | "width" | "distance" | null;
    /**
     * A string value indicating the required unit of measurement if the data
     * represents a real world distance quantity. If the data value represents a
     * non-distance quantity, e.g. traffic count, census data, etc., valueUnits
     * should be set to 'unknown'.
     */
    valueUnit?: "unknown" | "inches" | "feet" | "yards" | "miles" | "nautical-miles" | "millimeters" | "centimeters" | "decimeters" | "meters" | "kilometer" | "decimal-degrees" | null;
}
/**
 * TransparencyInfo is supported by opacityInfo in the JavaScript API. Except
 * type and axis, all properties follow the syntax of the JavaScript API's
 * opacityInfo property. It applies transparency to each feature based on the
 * attribute values in a field. The exception is that the webmap JSON uses
 * transparency (range 0 - 100, with 100 as completely transparent) instead of
 * opacity (range 0 - 1, with 0 as completely transparent).
 *
 * See
 * {@link https://developers.arcgis.com/web-map-specification/objects/transparencyInfo_visualVariable/}
 * {@link https://developers.arcgis.com/web-scene-specification/objects/transparencyInfo_visualVariable/}.
 */
export interface TransparencyInfoJson extends VisualVariableJsonBase {
    /**
     * Options available for the legend.
     */
    legendOptions?: {
        /**
         * The title of the legend.
         */
        title?: string | null;
        /**
         * Indicates whether to show color/size ramp in the legend.
         */
        showLegend?: boolean | null;
    } | null;
    /**
     * An array of transparencyStop objects.
     */
    stops?: TransparencyStopJson[] | null;
    /**
     * @inheritDoc
     */
    type: "transparencyInfo";
}
/**
 * Specifies the largest marker size to use at any given map scale. This is
 * required if valueUnit is set to unknown.
 *
 * See
 * {@link https://developers.arcgis.com/web-map-specification/objects/maxSize/}
 * {@link https://developers.arcgis.com/web-map-specification/objects/minSize/}
 * {@link https://developers.arcgis.com/web-scene-specification/objects/maxSize/}
 * {@link https://developers.arcgis.com/web-scene-specification/objects/minSize/}.
 */
export interface SizeJson {
    /**
     * The value which allows a size to be defined based on the map scale.
     * Currently, the only supported expression is, view.scale.
     */
    expression?: string | null;
    /**
     * An array of objects that define the maximum size of the symbol at various
     * values of the expression. Each object in the array has a numeric size
     * property and a numeric value property. If the value calculated from the
     * expression matches the value of a stop, than the size corresponding to
     * that stop is selected. For example, if expression is set to view.scale,
     * the value corresponds to the map's scale. The size represents the maximum
     * symbol size (in pixels) that corresponds to this scale. If the map scale
     * matches the scale value of a stop, the size corresponding to that stop
     * value is used as the maximum symbol size for the features. If the map
     * scale value falls between two stops, the maximum symbol size is
     * interpolated between the sizes of the two stops. The minSize and maxSize
     * stop values are usually the same, although it is possible to have
     * different values depending on how minSize is calculated versus the
     * maxSize.
     */
    stops?: SizeStopJson[] | null;
    /**
     * Value indicating that sizeInfo should be applied to the outline of
     * polygons. This value can be outline or null.
     */
    target?: string | null;
    /**
     * Value indicating the type of rendering, e.g. 'sizeInfo'.
     */
    type?: string | null;
}
/**
 * A sizeStop object describes the size of the symbol at various values of the
 * expression.
 */
export interface SizeStopJson {
    /**
     * Value if a label is needed on the legend for a stop.
     */
    label?: string | null;
    /**
     * Specifies the marker size to use for the specified value.
     */
    size?: number | null;
    /**
     * The value to be mapped to a size.
     */
    value?: number | null;
}
/**
 * A sizeStop object describes the size of the symbol at various values of the
 * expression.
 */
export interface ColorStopJson {
    /**
     * A CSS color string or an array of rbga values. The color to place at the
     * stop indicated by either a ratio or value.
     */
    color?: string | ColorJson | null;
    /**
     * Value if a label is needed on the legend for a stop.
     */
    label?: string | null;
    /**
     * The pixel intensity value. Describes the pixel intensity value that the
     * color should be associated with. Just like in colorInfo, using value will
     * ignore maxPixelIntensity and minPixelIntensity properties. It will
     * actually set those properties to maximum and minimum values you set in
     * the colorStops array. The hard values are converted to ratios to create
     * the color gradient that is used in the heatmap calculations. Setting
     * minPixelIntensity or maxPixelIntensity, after setting colorStops with
     * values, removes the hard link between the color ramp and the pixel
     * intensity values that were used to create it.
     */
    value?: number | null;
}
/**
 * The transparencyStop object defines the thematic opacity ramp in a sequence
 * of stops. At least two stops are required. The stops must be listed in
 * ascending order based on the value of the value property in each stop.
 */
export interface TransparencyStopJson {
    /**
     * A string value used to label the stop in the legend.
     */
    label: string;
    /**
     * A numeric transparency value for a stop ranging from 0-100, where 0 is
     * opaque and 100 is 100% transparent.
     */
    transparency: number;
    /**
     * The pixel intensity value. Describes the pixel intensity value that the
     * color should be associated with.
     */
    value: number;
}
