Encoded typed arrays

Summary: This page explains numeric encoded arrays in Plotly.NET and the selected C# chart overloads, using plotly.js 2.28.0.

What are encoded typed arrays?
Creating EncodedTypedArray values
Using encoded arrays with Scatter
Using encoded arrays with Bar and Column charts
Using encoded arrays with Heatmap
Using encoded arrays with 3D charts
Using encoded arrays with statistical charts
Using encoded arrays for error bars and trace-level styling
Using encoded arrays from C#
Nested data and precedence
Supported scope and limitations
Loading Virtual-WebGL

What are encoded typed arrays?

plotly.js 2.28.0 introduced support for passing data arrays as base64-encoded typed arrays instead of plain JSON arrays. The representation contains a base64 byte payload (bdata), a numeric type tag (dtype), and an optional matrix shape (shape). Its size and parsing cost depend on the data and dtype; this release does not provide a benchmark or guarantee that it is smaller or faster than JSON arrays.

The core Plotly.NET assembly owns EncodedTypedArray, its factories, and serialization. Both F# and C# use this same representation.

Creating EncodedTypedArray values

EncodedTypedArray can be constructed from the supported numeric arrays listed below:

open Plotly.NET

// Float64 (double) arrays — most common for continuous data
let xEncoded = EncodedTypedArray.ofFloat64Array [| 1.0; 2.0; 3.0; 4.0; 5.0 |]
let yEncoded = EncodedTypedArray.ofFloat64Array [| 2.0; 4.0; 1.0; 5.0; 3.0 |]

// Int32 arrays — for integer data like indices or counts
let sourceEncoded = EncodedTypedArray.ofInt32Array [| 0; 1; 2 |]

// Float32 arrays — smaller footprint when full precision is not needed
let valuesEncoded = EncodedTypedArray.ofFloat32Array [| 1.0f; 2.5f; 0.8f |]

Supported constructors:

Constructor	F# array type	plotly.js dtype
`EncodedTypedArray.ofFloat64Array`	`float[]`	`f8` (64-bit float)
`EncodedTypedArray.ofFloat32Array`	`float32[]`	`f4` (32-bit float)
`EncodedTypedArray.ofInt32Array`	`int[]`	`i4` (32-bit int)
`EncodedTypedArray.ofInt16Array`	`int16[]`	`i2` (16-bit int)
`EncodedTypedArray.ofInt8Array`	`sbyte[]`	`i1` (8-bit int)
`EncodedTypedArray.ofUInt32Array`	`uint32[]`	`u4` (unsigned 32-bit)
`EncodedTypedArray.ofUInt16Array`	`uint16[]`	`u2` (unsigned 16-bit)
`EncodedTypedArray.ofUInt8Array`	`byte[]`	`u1` (unsigned 8-bit)
`EncodedTypedArray.ofUInt8ClampedArray`	`byte[]`	`u1c` (clamped unsigned 8-bit)

There are no factories for strings, arbitrary objects, decimal, or signed/unsigned 64-bit integers. Choose a supported dtype explicitly when converting data, accounting for its range and precision.

Using encoded arrays with Scatter

The encoded convenience overload for Chart.Scatter takes xEncoded and yEncoded as required positional arguments instead of plain x/y sequences:

let scatterEncoded =
    Chart.Scatter(
        xEncoded = EncodedTypedArray.ofFloat64Array [| 1.0; 2.0; 3.0; 4.0; 5.0 |],
        yEncoded = EncodedTypedArray.ofFloat64Array [| 2.0; 4.0; 1.0; 5.0; 3.0 |],
        mode = StyleParam.Mode.Markers,
        Name = "encoded scatter",
        UseDefaults = false
    )

The same encoded overload is available for Chart.Point, Chart.Line, Chart.Bubble, Chart.Area, Chart.SplineArea, and Chart.StackedArea.

Using encoded arrays with Bar and Column charts

For bar and column charts, the main data array (values) is always required and encoded. The keys array is optional:

let barEncoded =
    Chart.Bar(
        valuesEncoded = EncodedTypedArray.ofFloat64Array [| 5.0; 3.0; 7.0; 2.0 |],
        KeysEncoded = EncodedTypedArray.ofInt32Array [| 0; 1; 2; 3 |],
        Name = "encoded bar",
        UseDefaults = false
    )

The same pattern applies to Chart.Column, Chart.StackedBar, and Chart.StackedColumn.

Using encoded arrays with Heatmap

For heatmaps, the z matrix is required and encoded; x and y axes are optional and encoded. When zEncoded is given as a flat encoded array, shape must also be set so plotly.js can reconstruct the matrix:

let heatmapEncoded =
    Chart.Heatmap(
        zEncoded = EncodedTypedArray.ofFloat64Array([| 1.0; 2.0; 3.0; 4.0; 5.0; 6.0 |], shape = [ 2; 3 ]),
        Name = "encoded heatmap",
        UseDefaults = false
    )

Note that for heatmaps the z data is passed as a flat 1D encoded array. plotly.js uses the shape field (rows × columns) to interpret the layout, so shape must be specified:

// Row-major 2x3 matrix: [[1; 2; 3]; [4; 5; 6]]
let z2x3 =
    EncodedTypedArray.ofFloat64Array([| 1.0 .. 6.0 |], shape = [ 2; 3 ])

Supply a matching row count and column count for matrix-valued inputs such as the z grid of Chart.Surface or Chart.Contour. The factories preserve the supplied shape; they do not validate that its dimensions match the payload length.

Chart.Histogram2D and Chart.Histogram2DContour instead consume one-dimensional x/y samples and optional z aggregation values, one per sample. Do not reshape those sample arrays into a matrix; plotly.js computes the bins.

Using encoded arrays with 3D charts

Encoded typed arrays work the same way on 3D traces. For example, Chart.Scatter3D accepts encoded x, y, and z coordinates:

let scatter3DEncoded =
    Chart.Scatter3D(
        xEncoded = EncodedTypedArray.ofFloat64Array [| 1.0; 2.0; 3.0 |],
        yEncoded = EncodedTypedArray.ofFloat64Array [| 4.0; 5.0; 6.0 |],
        zEncoded = EncodedTypedArray.ofFloat64Array [| 7.0; 8.0; 9.0 |],
        mode = StyleParam.Mode.Markers,
        Name = "encoded scatter3d",
        UseDefaults = false
    )

Chart.Surface uses a two-dimensional z grid. Chart.Volume and Chart.IsoSurface use parallel one-dimensional x/y/z/value arrays describing samples in space; their coordinates and values do not require a matrix shape simply because the chart is three-dimensional.

Using encoded arrays with statistical charts

Distribution and statistical charts support encoded sample arrays as well. Here is a histogram example:

let histogramEncoded =
    Chart.Histogram(
        dataEncoded = EncodedTypedArray.ofFloat64Array [| 1.0; 2.0; 2.0; 3.0; 3.0; 3.0; 4.0 |],
        orientation = StyleParam.Orientation.Vertical,
        Name = "encoded histogram",
        UseDefaults = false
    )

The same pattern works for Chart.BoxPlot, Chart.Violin, and finance-style traces such as Chart.OHLC and Chart.Candlestick.

Using encoded arrays for error bars and trace-level styling

Some features are available through trace-level styling rather than only through chart-root overloads. This is especially useful when you want encoded error bars, encoded metadata arrays, or other advanced options:

open Plotly.NET.TraceObjects

let scatterWithEncodedErrorBars =
    let xErrorEncoded = EncodedTypedArray.ofFloat64Array [| 0.1; 0.2; 0.3 |]
    let yErrorEncoded = EncodedTypedArray.ofFloat64Array [| 0.4; 0.5; 0.6 |]
    let yErrorMinusEncoded = EncodedTypedArray.ofFloat64Array [| 0.3; 0.2; 0.1 |]

    Trace2D.initScatter(
        Trace2DStyle.Scatter(
            Name = "encoded scatter + error bars",
            Mode = StyleParam.Mode.Lines_Markers,
            XEncoded = EncodedTypedArray.ofFloat64Array [| 1.0; 2.0; 3.0 |],
            YEncoded = EncodedTypedArray.ofFloat64Array [| 4.0; 5.0; 6.0 |],
            XError =
                Error.init(
                    Type = StyleParam.ErrorType.Data,
                    ArrayEncoded = xErrorEncoded
                ),
            YError =
                Error.init(
                    Type = StyleParam.ErrorType.Data,
                    ArrayEncoded = yErrorEncoded,
                    ArrayminusEncoded = yErrorMinusEncoded
                )
        )
    )
    |> GenericChart.ofTraceObject false
    |> Chart.withDisplayOptions(DisplayOptions.init(PlotlyJSReference = PlotlyJSReference.NoReference))

The trace-style modules (Trace2DStyle, Trace3DStyle, TraceDomainStyle, and others) also accept encoded arrays for many metadata fields such as ids, custom data, selected points, text, dimensions, and trace-specific attributes.

For more advanced usage including encoded arrays on 3D, domain, and map traces, see the trace-level style modules (Trace2DStyle, Trace3DStyle, TraceDomainStyle, etc.) which accept *Encoded optional parameters for selected data-array fields. An encoded option only changes the transport representation; the underlying plotly.js field must still accept the resulting values.

Using encoded arrays from C#

Reference both Plotly.NET and Plotly.NET.CSharp. The factories are F# methods in the shared core: C# supplies shape: default for a one-dimensional array, or an explicit FSharpOption<IEnumerable<int>> for a matrix. The remaining generic type argument on Scatter/Heatmap describes optional text; specify it even when no text is supplied.

This 1D example is compiled and checked in EncodedArrayExamplesTests:

using Plotly.NET;
using Chart = Plotly.NET.CSharp.Chart;

var x = EncodedTypedArray.ofInt32Array(new[] { 0, 1, 2 }, shape: default);
var y = EncodedTypedArray.ofFloat32Array(new[] { 1.5f, 4.5f, 2.5f }, shape: default);
var scatter = Chart.Scatter<string>(
    xEncoded: x, yEncoded: y, mode: StyleParam.Mode.Markers,
    Name: "encoded scatter", UseDefaults: false);

For a 2-by-3 heatmap, flatten the rows in order and supply three x coordinates and two y coordinates. This example is also compiled and checked in the C# tests:

using System.Collections.Generic;
using Microsoft.FSharp.Core;
using Plotly.NET;
using Chart = Plotly.NET.CSharp.Chart;

var z = EncodedTypedArray.ofFloat32Array(
    new[] { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f },
    shape: new FSharpOption<IEnumerable<int>>(new[] { 2, 3 }));
var heatmap = Chart.Heatmap<string>(
    zEncoded: z,
    xEncoded: EncodedTypedArray.ofInt32Array(new[] { 10, 20, 30 }, shape: default),
    yEncoded: EncodedTypedArray.ofInt32Array(new[] { 100, 200 }, shape: default),
    ReverseYAxis: true, ShowScale: false, UseDefaults: false);

Nested data and precedence

Use Dimension.initSplom / Dimension.initParallel with ValuesEncoded for nested dimension data. Existing F# and C# SPLOM/parallel chart wrappers accept these objects. ParallelCoord and ParallelCategories also offer label/encoded-value pair conveniences.

For Sankey, use SankeyNodes.init with XEncoded / YEncoded and SankeyLinks.init with SourceEncoded / TargetEncoded / ValueEncoded, then pass the objects to Chart.Sankey(nodes, links, ...). Labels remain plain strings. These shared object APIs also expose numeric CustomDataEncoded and ColorEncoded; numeric encoding does not turn color names or other strings into supported typed arrays, and each field retains its plotly.js value requirements.

At the trace/object layer, if one init/style call supplies both the plain and encoded parameter for the same property, the encoded value wins. For example, Value = [ 99.0 ] together with ValueEncoded = EncodedTypedArray.ofFloat64Array [| 8.0 |] serializes a single encoded value property. A later style call can replace that property again. The explicit chart overloads instead take encoded primary inputs directly.

Supported scope and limitations

The examples earlier on this page use the F# API. Direct encoded C# chart overloads currently cover:

Scatter, Bar, StackedBar, Column, StackedColumn, Heatmap, Histogram2D, and Scatter3D.
ParallelCoord / ParallelCategories label/encoded-value pairs.
Nested objects through existing wrappers, including SPLOM and Sankey.

Other direct C# wrappers, including Histogram, Surface, and map/polar/carpet families, are a later milestone. C# can also use the shared low-level core types. Existing plain overloads remain available.

Encoded primary arrays do not make every accompanying input encoded. For example, the encoded F# Bubble convenience still takes plain sizes, and labels/styles stay plain where the signature says so. Bar keys and Heatmap axes in these encoded overloads are numeric encoded arrays; there is no matching plain string-key argument on those overloads. Use existing plain chart overloads when needed, or compose the supported fields through the shared trace API.

Image pixel arrays and helpers that compute from the input values, such as Pareto, Residual, and AnnotatedHeatmap, are outside the direct encoded-overload scope. Neither a metadata option nor the existence of a numeric factory establishes support for every field or chart type.

Loading Virtual-WebGL

Virtual-WebGL is a separate plotly.js 2.28 feature for sharing WebGL contexts. It is optional and does not enable encoded arrays. To use the WebGL 1 script (src/virtual-webgl.js from Virtual-WebGL 1.0.6, the version used for this integration check), serve the files below with your page and load Virtual-WebGL before plotly.js, as described by the Virtual-WebGL project.

Existing display options can set that order without a new wrapper API:

open Giraffe.ViewEngine

let displayOptions =
    DisplayOptions.init(
        PlotlyJSReference = PlotlyJSReference.NoReference,
        AdditionalHeadTags = [
            script [ _src "/lib/virtual-webgl.js" ] []
            script [ _src "/lib/plotly-2.28.0.min.js" ] []
        ]
    )

let standaloneHtml =
    Chart.Scatter(
        xEncoded = EncodedTypedArray.ofInt32Array [| 0; 1; 2 |],
        yEncoded = EncodedTypedArray.ofFloat32Array [| 1.5f; 4.5f; 2.5f |],
        mode = StyleParam.Mode.Markers,
        UseWebGL = true,
        UseDefaults = false
    )
    |> Chart.withDisplayOptions displayOptions
    |> GenericChart.toEmbeddedHTML

NoReference prevents an earlier automatic plotly.js script tag. Replace the paths with your hosted files and use a WebGL chart, such as Scatter with UseWebGL = true, when exercising the virtualized contexts. toEmbeddedHTML emits the head tags; toChartHTML emits only a fragment and requires the host page to supply the scripts.

namespace Plotly

namespace Plotly.NET

module Defaults from Plotly.NET
<summary> Contains mutable global default values. Changing these values will apply the default values to all consecutive Chart generations. </summary>

val mutable DefaultDisplayOptions: Plotly.NET.DisplayOptions

Multiple items
type DisplayOptions = inherit DynamicObj new: unit -> DisplayOptions static member addAdditionalHeadTags: additionalHeadTags: XmlNode list -> (DisplayOptions -> DisplayOptions) static member addChartDescription: description: XmlNode list -> (DisplayOptions -> DisplayOptions) static member combine: first: DisplayOptions -> second: DisplayOptions -> DisplayOptions static member getAdditionalHeadTags: displayOpts: DisplayOptions -> XmlNode list static member getChartDescription: displayOpts: DisplayOptions -> XmlNode list static member getDocumentCharset: displayOpts: DisplayOptions -> string static member getDocumentDescription: displayOpts: DisplayOptions -> string static member getDocumentFavicon: displayOpts: DisplayOptions -> XmlNode ...

--------------------
new: unit -> Plotly.NET.DisplayOptions

static member Plotly.NET.DisplayOptions.init: ?DocumentTitle: string * ?DocumentCharset: string * ?DocumentDescription: string * ?DocumentFavicon: Giraffe.ViewEngine.HtmlElements.XmlNode * ?AdditionalHeadTags: Giraffe.ViewEngine.HtmlElements.XmlNode list * ?ChartDescription: Giraffe.ViewEngine.HtmlElements.XmlNode list * ?PlotlyJSReference: Plotly.NET.PlotlyJSReference -> Plotly.NET.DisplayOptions

type PlotlyJSReference = | CDN of string | Full | Require of string | NoReference
<summary> Sets how plotly is referenced in the head of html docs. </summary>

union case Plotly.NET.PlotlyJSReference.NoReference: Plotly.NET.PlotlyJSReference

val xEncoded: EncodedTypedArray

Multiple items
type EncodedTypedArray = inherit DynamicObj new: unit -> EncodedTypedArray static member init: bdata: string * dtype: TypedArrayDType * ?shape: int seq -> EncodedTypedArray static member ofFloat32Array: data: single array * ?shape: int seq -> EncodedTypedArray static member ofFloat64Array: data: float array * ?shape: int seq -> EncodedTypedArray static member ofInt16Array: data: int16 array * ?shape: int seq -> EncodedTypedArray static member ofInt32Array: data: int32 array * ?shape: int seq -> EncodedTypedArray static member ofInt8Array: data: sbyte array * ?shape: int seq -> EncodedTypedArray static member ofUInt16Array: data: uint16 array * ?shape: int seq -> EncodedTypedArray static member ofUInt32Array: data: uint32 array * ?shape: int seq -> EncodedTypedArray ...
<summary> Base64-encoded typed array representation accepted by plotly.js (>= 2.28.0) for trace data_array fields. Carries a base64-encoded byte payload (<c>bdata</c>), the underlying value data type (<c>dtype</c>), and an optional <c>shape</c> for multi-dimensional arrays. See the plotly.js v2.28.0 release notes. </summary>

--------------------
new: unit -> EncodedTypedArray

static member EncodedTypedArray.ofFloat64Array: data: float array * ?shape: int seq -> EncodedTypedArray

val yEncoded: EncodedTypedArray

val sourceEncoded: EncodedTypedArray

static member EncodedTypedArray.ofInt32Array: data: int32 array * ?shape: int seq -> EncodedTypedArray

val valuesEncoded: EncodedTypedArray

static member EncodedTypedArray.ofFloat32Array: data: single array * ?shape: int seq -> EncodedTypedArray

val scatterEncoded: GenericChart

type Chart = static member Bubble: x: #IConvertible seq * y: #IConvertible seq * sizes: int seq * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: float seq * ?Text: 'c * ?MultiText: 'c seq * ?TextPosition: TextPosition * ?MultiTextPosition: TextPosition seq * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol * ?MultiMarkerSymbol: MarkerSymbol seq * ?Marker: Marker * ?LineColor: Color * ?LineColorScale: Colorscale * ?LineWidth: float * ?LineDash: DrawingStyle * ?Line: Line * ?AlignmentGroup: string * ?OffsetGroup: string * ?StackGroup: string * ?Orientation: Orientation * ?GroupNorm: GroupNorm * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart (requires 'c :> IConvertible) + 2 overloads static member Line: x: #IConvertible seq * y: #IConvertible seq * ?ShowMarkers: bool * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: float seq * ?Text: 'c * ?MultiText: 'c seq * ?TextPosition: TextPosition * ?MultiTextPosition: TextPosition seq * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol * ?MultiMarkerSymbol: MarkerSymbol seq * ?Marker: Marker * ?LineColor: Color * ?LineColorScale: Colorscale * ?LineWidth: float * ?LineDash: DrawingStyle * ?Line: Line * ?AlignmentGroup: string * ?OffsetGroup: string * ?StackGroup: string * ?Orientation: Orientation * ?GroupNorm: GroupNorm * ?Fill: Fill * ?FillColor: Color * ?FillPattern: Pattern * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart (requires 'c :> IConvertible) + 2 overloads static member Point: x: #IConvertible seq * y: #IConvertible seq * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: float seq * ?Text: 'c * ?MultiText: 'c seq * ?TextPosition: TextPosition * ?MultiTextPosition: TextPosition seq * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol * ?MultiMarkerSymbol: MarkerSymbol seq * ?Marker: Marker * ?AlignmentGroup: string * ?OffsetGroup: string * ?StackGroup: string * ?Orientation: Orientation * ?GroupNorm: GroupNorm * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart (requires 'c :> IConvertible) + 2 overloads static member Range: x: #IConvertible seq * y: #IConvertible seq * upper: #IConvertible seq * lower: #IConvertible seq * mode: Mode * ?Name: string * ?GroupName: string * ?ShowMarkers: bool * ?ShowLegend: bool * ?Text: 'e * ?MultiText: 'e seq * ?TextPosition: TextPosition * ?MultiTextPosition: TextPosition seq * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol * ?MultiMarkerSymbol: MarkerSymbol seq * ?Marker: Marker * ?UpperMarker: Marker * ?LowerMarker: Marker * ?LineColor: Color * ?LineColorScale: Colorscale * ?LineWidth: float * ?LineDash: DrawingStyle * ?Line: Line * ?UpperLine: Line * ?LowerLine: Line * ?RangeColor: Color * ?RangePattern: Pattern * ?UpperText: 'f * ?MultiUpperText: 'f seq * ?LowerText: 'g * ?MultiLowerText: 'g seq * ?TextFont: Font * ?LowerName: string * ?UpperName: string * ?UseDefaults: bool -> GenericChart (requires 'e :> IConvertible and 'f :> IConvertible and 'g :> IConvertible) + 2 overloads static member Scatter: ?X: 'a seq * ?XEncoded: EncodedTypedArray * ?MultiX: 'a seq seq * ?Y: 'b seq * ?YEncoded: EncodedTypedArray * ?MultiY: 'b seq seq * ?Mode: Mode * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: float seq * ?Text: 'c * ?MultiText: 'c seq * ?TextPosition: TextPosition * ?MultiTextPosition: TextPosition seq * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol * ?MultiMarkerSymbol: MarkerSymbol seq * ?Marker: Marker * ?LineColor: Color * ?LineColorScale: Colorscale * ?LineWidth: float * ?LineDash: DrawingStyle * ?Line: Line * ?AlignmentGroup: string * ?OffsetGroup: string * ?StackGroup: string * ?Orientation: Orientation * ?GroupNorm: GroupNorm * ?Fill: Fill * ?FillColor: Color * ?FillPattern: Pattern * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart (requires 'a :> IConvertible and 'b :> IConvertible and 'c :> IConvertible) + 3 overloads static member Spline: x: #IConvertible seq * y: #IConvertible seq * ?ShowMarkers: bool * ?Smoothing: float * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: float seq * ?Text: 'c * ?MultiText: 'c seq * ?TextPosition: TextPosition * ?MultiTextPosition: TextPosition seq * ?MarkerColor: Color * ?MarkerColorScale: Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: MarkerSymbol * ?MultiMarkerSymbol: MarkerSymbol seq * ?Marker: Marker * ?LineColor: Color * ?LineColorScale: Colorscale * ?LineWidth: float * ?LineDash: DrawingStyle * ?Line: Line * ?AlignmentGroup: string * ?OffsetGroup: string * ?StackGroup: string * ?Orientation: Orientation * ?GroupNorm: GroupNorm * ?Fill: Fill * ?FillColor: Color * ?FillPattern: Pattern * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart (requires 'c :> IConvertible) + 2 overloads

static member Chart.Scatter: xy: (#System.IConvertible * #System.IConvertible) seq * mode: StyleParam.Mode * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: float seq * ?Text: 'c * ?MultiText: 'c seq * ?TextPosition: StyleParam.TextPosition * ?MultiTextPosition: StyleParam.TextPosition seq * ?MarkerColor: Color * ?MarkerColorScale: StyleParam.Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: StyleParam.MarkerSymbol * ?MultiMarkerSymbol: StyleParam.MarkerSymbol seq * ?Marker: TraceObjects.Marker * ?LineColor: Color * ?LineColorScale: StyleParam.Colorscale * ?LineWidth: float * ?LineDash: StyleParam.DrawingStyle * ?Line: Line * ?AlignmentGroup: string * ?OffsetGroup: string * ?StackGroup: string * ?Orientation: StyleParam.Orientation * ?GroupNorm: StyleParam.GroupNorm * ?Fill: StyleParam.Fill * ?FillColor: Color * ?FillPattern: TraceObjects.Pattern * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart (requires 'c :> System.IConvertible)
static member Chart.Scatter: x: #System.IConvertible seq * y: #System.IConvertible seq * mode: StyleParam.Mode * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: float seq * ?Text: 'c * ?MultiText: 'c seq * ?TextPosition: StyleParam.TextPosition * ?MultiTextPosition: StyleParam.TextPosition seq * ?MarkerColor: Color * ?MarkerColorScale: StyleParam.Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: StyleParam.MarkerSymbol * ?MultiMarkerSymbol: StyleParam.MarkerSymbol seq * ?Marker: TraceObjects.Marker * ?LineColor: Color * ?LineColorScale: StyleParam.Colorscale * ?LineWidth: float * ?LineDash: StyleParam.DrawingStyle * ?Line: Line * ?AlignmentGroup: string * ?OffsetGroup: string * ?StackGroup: string * ?Orientation: StyleParam.Orientation * ?GroupNorm: StyleParam.GroupNorm * ?Fill: StyleParam.Fill * ?FillColor: Color * ?FillPattern: TraceObjects.Pattern * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart (requires 'c :> System.IConvertible)
static member Chart.Scatter: xEncoded: EncodedTypedArray * yEncoded: EncodedTypedArray * mode: StyleParam.Mode * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: float seq * ?Text: 'a * ?MultiText: 'a seq * ?TextPosition: StyleParam.TextPosition * ?MultiTextPosition: StyleParam.TextPosition seq * ?MarkerColor: Color * ?MarkerColorScale: StyleParam.Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: StyleParam.MarkerSymbol * ?MultiMarkerSymbol: StyleParam.MarkerSymbol seq * ?Marker: TraceObjects.Marker * ?LineColor: Color * ?LineColorScale: StyleParam.Colorscale * ?LineWidth: float * ?LineDash: StyleParam.DrawingStyle * ?Line: Line * ?AlignmentGroup: string * ?OffsetGroup: string * ?StackGroup: string * ?Orientation: StyleParam.Orientation * ?GroupNorm: StyleParam.GroupNorm * ?Fill: StyleParam.Fill * ?FillColor: Color * ?FillPattern: TraceObjects.Pattern * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart (requires 'a :> System.IConvertible)
static member Chart.Scatter: ?X: 'a seq * ?XEncoded: EncodedTypedArray * ?MultiX: 'a seq seq * ?Y: 'b seq * ?YEncoded: EncodedTypedArray * ?MultiY: 'b seq seq * ?Mode: StyleParam.Mode * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: float seq * ?Text: 'c * ?MultiText: 'c seq * ?TextPosition: StyleParam.TextPosition * ?MultiTextPosition: StyleParam.TextPosition seq * ?MarkerColor: Color * ?MarkerColorScale: StyleParam.Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: StyleParam.MarkerSymbol * ?MultiMarkerSymbol: StyleParam.MarkerSymbol seq * ?Marker: TraceObjects.Marker * ?LineColor: Color * ?LineColorScale: StyleParam.Colorscale * ?LineWidth: float * ?LineDash: StyleParam.DrawingStyle * ?Line: Line * ?AlignmentGroup: string * ?OffsetGroup: string * ?StackGroup: string * ?Orientation: StyleParam.Orientation * ?GroupNorm: StyleParam.GroupNorm * ?Fill: StyleParam.Fill * ?FillColor: Color * ?FillPattern: TraceObjects.Pattern * ?UseWebGL: bool * ?UseDefaults: bool -> GenericChart (requires 'a :> System.IConvertible and 'b :> System.IConvertible and 'c :> System.IConvertible)

module StyleParam from Plotly.NET

union case StyleParam.Mode.Markers: StyleParam.Mode

type GenericChart = | Chart of data: Trace * layout: Layout * config: Config * displayOpts: DisplayOptions | MultiChart of data: Trace list * layout: Layout * config: Config * displayOpts: DisplayOptions static member addConfig: config: Config -> gChart: GenericChart -> GenericChart static member addDisplayOptions: displayOpts: DisplayOptions -> gChart: GenericChart -> GenericChart static member addLayout: layout: Layout -> gChart: GenericChart -> GenericChart static member combine: gCharts: GenericChart seq -> GenericChart static member countTrace: gChart: GenericChart -> int static member existsTrace: predicate: (Trace -> bool) -> gChart: GenericChart -> bool static member fromChartDTO: dto: ChartDTO -> GenericChart static member fromFigure: fig: Figure -> GenericChart static member getConfig: gChart: GenericChart -> Config static member getDisplayOptions: gChart: GenericChart -> DisplayOptions ...
<summary> The central type that gets created by all Chart constructors is GenericChart, which itself represents either a single chart or a multi chart (as a Discriminate Union type). A GenericChart consists of four top level objects: Trace (multiple of those in the case of a MultiChart), Layout, Config, and DisplayOptions. - `Trace` is in principle the representation of a dataset on a chart, including for example the data itself, color and shape of the visualization, etc. - `Layout` is everything of the chart that is not dataset specific - e.g. the shape and style of axes, the chart title, etc. - `Config` is an object that configures high level properties of the chart like making all chart elements editable or the tool bar on top - `DisplayOptions` is an object that contains meta information about how the html document that contains the chart. </summary>

static member GenericChart.toChartHTML: gChart: GenericChart -> string

val barEncoded: GenericChart

static member Chart.Bar: keysValues: (#System.IConvertible * #System.IConvertible) seq * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: float seq * ?Text: 'c * ?MultiText: 'c seq * ?MarkerColor: Color * ?MarkerColorScale: StyleParam.Colorscale * ?MarkerOutline: Line * ?MarkerPatternShape: StyleParam.PatternShape * ?MultiMarkerPatternShape: StyleParam.PatternShape seq * ?MarkerPattern: TraceObjects.Pattern * ?Marker: TraceObjects.Marker * ?Base: #System.IConvertible * ?Width: 'e * ?MultiWidth: 'e seq * ?TextPosition: StyleParam.TextPosition * ?MultiTextPosition: StyleParam.TextPosition seq * ?UseDefaults: bool -> GenericChart (requires 'c :> System.IConvertible and 'e :> System.IConvertible)
static member Chart.Bar: valuesEncoded: EncodedTypedArray * ?KeysEncoded: EncodedTypedArray * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: float seq * ?Text: 'a * ?MultiText: 'a seq * ?MarkerColor: Color * ?MarkerColorScale: StyleParam.Colorscale * ?MarkerOutline: Line * ?MarkerPatternShape: StyleParam.PatternShape * ?MultiMarkerPatternShape: StyleParam.PatternShape seq * ?MarkerPattern: TraceObjects.Pattern * ?Marker: TraceObjects.Marker * ?Base: #System.IConvertible * ?Width: #System.IConvertible * ?MultiWidthEncoded: EncodedTypedArray * ?TextPosition: StyleParam.TextPosition * ?MultiTextPosition: StyleParam.TextPosition seq * ?UseDefaults: bool -> GenericChart (requires 'a :> System.IConvertible)
static member Chart.Bar: values: #System.IConvertible seq * ?Keys: 'b seq * ?MultiKeys: 'b seq seq * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: float seq * ?Text: 'c * ?MultiText: 'c seq * ?MarkerColor: Color * ?MarkerColorScale: StyleParam.Colorscale * ?MarkerOutline: Line * ?MarkerPatternShape: StyleParam.PatternShape * ?MultiMarkerPatternShape: StyleParam.PatternShape seq * ?MarkerPattern: TraceObjects.Pattern * ?Marker: TraceObjects.Marker * ?Base: #System.IConvertible * ?Width: 'e * ?MultiWidth: 'e seq * ?TextPosition: StyleParam.TextPosition * ?MultiTextPosition: StyleParam.TextPosition seq * ?UseDefaults: bool -> GenericChart (requires 'b :> System.IConvertible and 'c :> System.IConvertible and 'e :> System.IConvertible)

val heatmapEncoded: GenericChart

static member Chart.Heatmap: zData: #seq<'b> seq * colNames: string seq * rowNames: string seq * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?XGap: int * ?YGap: int * ?Text: 'c * ?MultiText: 'c seq * ?ColorBar: ColorBar * ?ColorScale: StyleParam.Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?ZSmooth: StyleParam.SmoothAlg * ?Transpose: bool * ?UseWebGL: bool * ?ReverseYAxis: bool * ?UseDefaults: bool -> GenericChart (requires 'b :> System.IConvertible and 'c :> System.IConvertible)
static member Chart.Heatmap: zEncoded: EncodedTypedArray * ?xEncoded: EncodedTypedArray * ?yEncoded: EncodedTypedArray * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?XGap: int * ?YGap: int * ?Text: 'a * ?MultiText: 'a seq * ?ColorBar: ColorBar * ?ColorScale: StyleParam.Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?ZSmooth: StyleParam.SmoothAlg * ?Transpose: bool * ?UseWebGL: bool * ?ReverseYAxis: bool * ?UseDefaults: bool -> GenericChart (requires 'a :> System.IConvertible)
static member Chart.Heatmap: zData: #seq<'b> seq * ?X: 'c seq * ?MultiX: 'c seq seq * ?Y: 'd seq * ?MultiY: 'd seq seq * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?XGap: int * ?YGap: int * ?Text: 'e * ?MultiText: 'e seq * ?ColorBar: ColorBar * ?ColorScale: StyleParam.Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?ZSmooth: StyleParam.SmoothAlg * ?Transpose: bool * ?UseWebGL: bool * ?ReverseYAxis: bool * ?UseDefaults: bool -> GenericChart (requires 'b :> System.IConvertible and 'c :> System.IConvertible and 'd :> System.IConvertible and 'e :> System.IConvertible)

val z2x3: obj

val scatter3DEncoded: GenericChart

static member Chart.Scatter3D: xyz: (#System.IConvertible * #System.IConvertible * #System.IConvertible) seq * mode: StyleParam.Mode * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: float seq * ?Text: 'd * ?MultiText: 'd seq * ?TextPosition: StyleParam.TextPosition * ?MultiTextPosition: StyleParam.TextPosition seq * ?MarkerColor: Color * ?MarkerColorScale: StyleParam.Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: StyleParam.MarkerSymbol3D * ?MultiMarkerSymbol: StyleParam.MarkerSymbol3D seq * ?Marker: TraceObjects.Marker * ?LineColor: Color * ?LineColorScale: StyleParam.Colorscale * ?LineWidth: float * ?LineDash: StyleParam.DrawingStyle * ?Line: Line * ?CameraProjectionType: StyleParam.CameraProjectionType * ?Camera: LayoutObjects.Camera * ?Projection: TraceObjects.Projection * ?UseDefaults: bool -> GenericChart (requires 'd :> System.IConvertible)
static member Chart.Scatter3D: xEncoded: EncodedTypedArray * yEncoded: EncodedTypedArray * zEncoded: EncodedTypedArray * mode: StyleParam.Mode * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: float seq * ?Text: 'a * ?MultiText: 'a seq * ?TextPosition: StyleParam.TextPosition * ?MultiTextPosition: StyleParam.TextPosition seq * ?MarkerColor: Color * ?MarkerColorScale: StyleParam.Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: StyleParam.MarkerSymbol3D * ?MultiMarkerSymbol: StyleParam.MarkerSymbol3D seq * ?Marker: TraceObjects.Marker * ?LineColor: Color * ?LineColorScale: StyleParam.Colorscale * ?LineWidth: float * ?LineDash: StyleParam.DrawingStyle * ?Line: Line * ?CameraProjectionType: StyleParam.CameraProjectionType * ?Camera: LayoutObjects.Camera * ?Projection: TraceObjects.Projection * ?UseDefaults: bool -> GenericChart (requires 'a :> System.IConvertible)
static member Chart.Scatter3D: x: #System.IConvertible seq * y: #System.IConvertible seq * z: #System.IConvertible seq * mode: StyleParam.Mode * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?MultiOpacity: float seq * ?Text: 'd * ?MultiText: 'd seq * ?TextPosition: StyleParam.TextPosition * ?MultiTextPosition: StyleParam.TextPosition seq * ?MarkerColor: Color * ?MarkerColorScale: StyleParam.Colorscale * ?MarkerOutline: Line * ?MarkerSymbol: StyleParam.MarkerSymbol3D * ?MultiMarkerSymbol: StyleParam.MarkerSymbol3D seq * ?Marker: TraceObjects.Marker * ?LineColor: Color * ?LineColorScale: StyleParam.Colorscale * ?LineWidth: float * ?LineDash: StyleParam.DrawingStyle * ?Line: Line * ?CameraProjectionType: StyleParam.CameraProjectionType * ?Camera: LayoutObjects.Camera * ?Projection: TraceObjects.Projection * ?UseDefaults: bool -> GenericChart (requires 'd :> System.IConvertible)

val histogramEncoded: GenericChart

static member Chart.Histogram: dataEncoded: EncodedTypedArray * orientation: StyleParam.Orientation * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?Text: 'a * ?MultiText: 'a seq * ?HistFunc: StyleParam.HistFunc * ?HistNorm: StyleParam.HistNorm * ?AlignmentGroup: string * ?OffsetGroup: string * ?NBinsX: int * ?NBinsY: int * ?BinGroup: string * ?XBins: TraceObjects.Bins * ?YBins: TraceObjects.Bins * ?MarkerColor: Color * ?Marker: TraceObjects.Marker * ?Line: Line * ?XError: TraceObjects.Error * ?YError: TraceObjects.Error * ?Cumulative: TraceObjects.Cumulative * ?HoverLabel: LayoutObjects.Hoverlabel * ?UseDefaults: bool -> GenericChart (requires 'a :> System.IConvertible)
static member Chart.Histogram: data: #System.IConvertible seq * orientation: StyleParam.Orientation * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?Text: 'b * ?MultiText: 'b seq * ?HistFunc: StyleParam.HistFunc * ?HistNorm: StyleParam.HistNorm * ?AlignmentGroup: string * ?OffsetGroup: string * ?NBinsX: int * ?NBinsY: int * ?BinGroup: string * ?XBins: TraceObjects.Bins * ?YBins: TraceObjects.Bins * ?MarkerColor: Color * ?Marker: TraceObjects.Marker * ?Line: Line * ?XError: TraceObjects.Error * ?YError: TraceObjects.Error * ?Cumulative: TraceObjects.Cumulative * ?HoverLabel: LayoutObjects.Hoverlabel * ?UseDefaults: bool -> GenericChart (requires 'b :> System.IConvertible)
static member Chart.Histogram: ?X: 'a seq * ?MultiX: 'a seq seq * ?Y: 'b seq * ?MultiY: 'b seq seq * ?Orientation: StyleParam.Orientation * ?Name: string * ?ShowLegend: bool * ?Opacity: float * ?Text: 'c * ?MultiText: 'c seq * ?TextPosition: StyleParam.TextPosition * ?HistFunc: StyleParam.HistFunc * ?HistNorm: StyleParam.HistNorm * ?AlignmentGroup: string * ?OffsetGroup: string * ?NBinsX: int * ?NBinsY: int * ?BinGroup: string * ?XBins: TraceObjects.Bins * ?YBins: TraceObjects.Bins * ?MarkerColor: Color * ?MarkerColorScale: StyleParam.Colorscale * ?MarkerOutline: Line * ?MarkerPatternShape: StyleParam.PatternShape * ?MultiMarkerPatternShape: StyleParam.PatternShape seq * ?MarkerPattern: TraceObjects.Pattern * ?Marker: TraceObjects.Marker * ?Line: Line * ?XError: TraceObjects.Error * ?YError: TraceObjects.Error * ?Cumulative: TraceObjects.Cumulative * ?HoverLabel: LayoutObjects.Hoverlabel * ?UseDefaults: bool -> GenericChart (requires 'a :> System.IConvertible and 'b :> System.IConvertible and 'c :> System.IConvertible)

type Orientation = | Horizontal | Vertical member Convert: unit -> objnull override ToString: unit -> string static member convert: (Orientation -> objnull) static member toString: (Orientation -> string)

union case StyleParam.Orientation.Vertical: StyleParam.Orientation

namespace Plotly.NET.TraceObjects

val scatterWithEncodedErrorBars: GenericChart

val xErrorEncoded: EncodedTypedArray

val yErrorEncoded: EncodedTypedArray

val yErrorMinusEncoded: EncodedTypedArray

Multiple items
type Trace2D = inherit Trace new: traceTypeName: string -> Trace2D static member initBar: applyStyle: (Trace2D -> Trace2D) -> Trace2D static member initBoxPlot: applyStyle: (Trace2D -> Trace2D) -> Trace2D static member initCandlestick: applyStyle: (Trace2D -> Trace2D) -> Trace2D static member initContour: applyStyle: (Trace2D -> Trace2D) -> Trace2D static member initFunnel: applyStyle: (Trace2D -> Trace2D) -> Trace2D static member initHeatmap: applyStyle: (Trace2D -> Trace2D) -> Trace2D static member initHeatmapGL: applyStyle: (Trace2D -> Trace2D) -> Trace2D static member initHistogram: applyStyle: (Trace2D -> Trace2D) -> Trace2D ...
<summary> The most commonly-used kind of subplot is a two-dimensional Cartesian subplot. Traces compatible with these subplots support xaxis and yaxis attributes whose values must refer to corresponding objects in the layout portion of the figure. For example, if xaxis="x", and yaxis="y" (which is the default) then this trace is drawn on the subplot at the intersection of the axes configured under layout.xaxis and layout.yaxis, but if xaxis="x2" and yaxis="y3" then the trace is drawn at the intersection of the axes configured under layout.xaxis2 and layout.yaxis3. Note that attributes such as layout.xaxis and layout.xaxis2 etc do not have to be explicitly defined, in which case default values will be inferred. Multiple traces of different types can be drawn on the same subplot. X- and Y-axes support the type attribute, which enables them to represent continuous values (type="linear", type="log"), temporal values (type="date") or categorical values (type="category", type="multicategory). Axes can also be overlaid on top of one another to create dual-axis or multiple-axis charts. 2-d cartesian subplots lend themselves very well to creating "small multiples" figures, also known as facet or trellis plots. The following trace types are compatible with 2D-cartesian subplots via the xaxis and yaxis attributes: - scatter-like trace types: scatter and scattergl can be used to draw scatter plots, line plots and curves, time-series plots, bubble charts, dot plots and filled areas and also support error bars - bar, funnel, waterfall: bar-like trace types which can also be used to draw timelines and Gantt charts - histogram: an aggregating bar-like trace type - box and violin: 1-dimensional distribution-like trace types - histogram2D and histogram2Dcontour: 2-dimensional distribution-like density trace types - image, heatmap and contour: matrix trace types - ohlc and candlestick: stock-like trace types - splom: multi-dimensional scatter plots which implicitly refer to many 2-d cartesian subplots at once. </summary>

--------------------
new: traceTypeName: string -> Trace2D

static member Trace2D.initScatter: applyStyle: (Trace2D -> Trace2D) -> Trace2D

Multiple items
type Trace2DStyle = new: unit -> Trace2DStyle static member Bar: ?Name: string * ?Visible: Visible * ?ShowLegend: bool * ?Legend: SubPlotId * ?LegendRank: int * ?LegendGroup: string * ?LegendGroupTitle: Title * ?Opacity: float * ?Ids: #IConvertible seq * ?IdsEncoded: EncodedTypedArray * ?X: 'b seq * ?MultiX: 'b seq seq * ?XEncoded: EncodedTypedArray * ?X0: #IConvertible * ?DX: #IConvertible * ?Y: 'e seq * ?MultiY: 'e seq seq * ?YEncoded: EncodedTypedArray * ?Y0: #IConvertible * ?DY: #IConvertible * ?Base: #IConvertible * ?Width: 'i * ?MultiWidth: 'i seq * ?MultiWidthEncoded: EncodedTypedArray * ?Offset: 'j * ?MultiOffset: 'j seq * ?MultiOffsetEncoded: EncodedTypedArray * ?Text: 'k * ?MultiText: 'k seq * ?MultiTextEncoded: EncodedTypedArray * ?TextPosition: TextPosition * ?MultiTextPosition: TextPosition seq * ?TextTemplate: string * ?MultiTextTemplate: string seq * ?HoverText: string * ?MultiHoverText: string seq * ?HoverInfo: HoverInfo * ?HoverTemplate: string * ?MultiHoverTemplate: string seq * ?XHoverFormat: string * ?YHoverFormat: string * ?Meta: string * ?CustomData: #IConvertible seq * ?CustomDataEncoded: EncodedTypedArray * ?XAxis: LinearAxisId * ?YAxis: LinearAxisId * ?Orientation: Orientation * ?AlignmentGroup: string * ?OffsetGroup: string * ?XPeriod: #IConvertible * ?XPeriodAlignment: PeriodAlignment * ?XPeriod0: #IConvertible * ?YPeriod: #IConvertible * ?YPeriodAlignment: PeriodAlignment * ?YPeriod0: #IConvertible * ?Marker: Marker * ?TextAngle: float * ?TextFont: Font * ?XError: Error * ?YError: Error * ?SelectedPoints: #IConvertible seq * ?SelectedPointsEncoded: EncodedTypedArray * ?Selected: TraceSelection * ?Unselected: TraceSelection * ?ClipOnAxis: bool * ?Constraintext: ConstrainText * ?HoverLabel: Hoverlabel * ?InsideTextAnchor: InsideTextAnchor * ?InsideTextFont: Font * ?OutsideTextFont: Font * ?XCalendar: Calendar * ?YCalendar: Calendar * ?UIRevision: string -> ('T -> 'T) (requires 'b :> IConvertible and 'e :> IConvertible and 'i :> IConvertible and 'j :> IConvertible and 'k :> IConvertible and 'T :> Trace) static member BoxPlot: ?Name: string * ?Visible: Visible * ?ShowLegend: bool * ?Legend: SubPlotId * ?LegendRank: int * ?LegendGroup: string * ?LegendGroupTitle: Title * ?LegendWidth: float * ?Opacity: float * ?Ids: #IConvertible seq * ?IdsEncoded: EncodedTypedArray * ?X: 'b seq * ?MultiX: 'b seq seq * ?XEncoded: EncodedTypedArray * ?X0: #IConvertible * ?DX: #IConvertible * ?Y: 'e seq * ?MultiY: 'e seq seq * ?YEncoded: EncodedTypedArray * ?Y0: #IConvertible * ?DY: #IConvertible * ?Width: float * ?Text: 'h * ?MultiText: 'h seq * ?MultiTextEncoded: EncodedTypedArray * ?HoverText: string * ?MultiHoverText: string seq * ?HoverInfo: HoverInfo * ?HoverTemplate: string * ?MultiHoverTemplate: string seq * ?XHoverFormat: string * ?YHoverFormat: string * ?Meta: string * ?CustomData: #IConvertible seq * ?CustomDataEncoded: EncodedTypedArray * ?XAxis: LinearAxisId * ?YAxis: LinearAxisId * ?Orientation: Orientation * ?AlignmentGroup: string * ?OffsetGroup: string * ?XPeriod: #IConvertible * ?XPeriodAlignment: PeriodAlignment * ?XPeriod0: #IConvertible * ?YPeriod: #IConvertible * ?YPeriodAlignment: PeriodAlignment * ?YPeriod0: #IConvertible * ?Marker: Marker * ?Line: Line * ?BoxMean: BoxMean * ?BoxPoints: BoxPoints * ?Notched: bool * ?NotchWidth: float * ?ShowWhiskers: bool * ?WhiskerWidth: float * ?Q1: IConvertible seq * ?Q1Encoded: EncodedTypedArray * ?Median: IConvertible seq * ?MedianEncoded: EncodedTypedArray * ?Q3: IConvertible seq * ?Q3Encoded: EncodedTypedArray * ?LowerFence: IConvertible seq * ?LowerFenceEncoded: EncodedTypedArray * ?UpperFence: IConvertible seq * ?UpperFenceEncoded: EncodedTypedArray * ?NotchSpan: IConvertible seq * ?NotchSpanEncoded: EncodedTypedArray * ?Mean: IConvertible seq * ?MeanEncoded: EncodedTypedArray * ?SD: IConvertible seq * ?SDEncoded: EncodedTypedArray * ?SDMultiple: float * ?QuartileMethod: QuartileMethod * ?SelectedPoints: #IConvertible seq * ?SelectedPointsEncoded: EncodedTypedArray * ?Selected: TraceSelection * ?Unselected: TraceSelection * ?FillColor: Color * ?HoverLabel: Hoverlabel * ?HoverOn: HoverOn * ?PointPos: float * ?Jitter: float * ?SizeMode: BoxSizeMode * ?XCalendar: Calendar * ?YCalendar: Calendar * ?UIRevision: string -> ('T -> 'T) (requires 'b :> IConvertible and 'e :> IConvertible and 'h :> IConvertible and 'T :> Trace) static member Candlestick: ?Name: string * ?Visible: Visible * ?ShowLegend: bool * ?Legend: SubPlotId * ?LegendRank: int * ?LegendGroup: string * ?LegendGroupTitle: Title * ?Opacity: float * ?Ids: #IConvertible seq * ?IdsEncoded: EncodedTypedArray * ?X: 'b seq * ?MultiX: 'b seq seq * ?XEncoded: EncodedTypedArray * ?Close: #IConvertible seq * ?CloseEncoded: EncodedTypedArray * ?Open: #IConvertible seq * ?OpenEncoded: EncodedTypedArray * ?High: #IConvertible seq * ?HighEncoded: EncodedTypedArray * ?Low: #IConvertible seq * ?LowEncoded: EncodedTypedArray * ?Text: 'g * ?MultiText: 'g seq * ?MultiTextEncoded: EncodedTypedArray * ?HoverText: string * ?MultiHoverText: string seq * ?HoverInfo: HoverInfo * ?XHoverFormat: string * ?YHoverFormat: string * ?Meta: string * ?CustomData: #IConvertible seq * ?CustomDataEncoded: EncodedTypedArray * ?XAxis: LinearAxisId * ?YAxis: LinearAxisId * ?XPeriod: #IConvertible * ?XPeriodAlignment: PeriodAlignment * ?XPeriod0: #IConvertible * ?YPeriod: #IConvertible * ?YPeriodAlignment: PeriodAlignment * ?YPeriod0: #IConvertible * ?Line: Line * ?WhiskerWidth: float * ?SelectedPoints: #IConvertible seq * ?SelectedPointsEncoded: EncodedTypedArray * ?Increasing: FinanceMarker * ?Decreasing: FinanceMarker * ?HoverLabel: Hoverlabel * ?XCalendar: Calendar * ?UIRevision: string -> ('T -> 'T) (requires 'b :> IConvertible and 'g :> IConvertible and 'T :> Trace) static member Contour: ?Name: string * ?Visible: Visible * ?ShowLegend: bool * ?Legend: SubPlotId * ?LegendRank: int * ?LegendGroup: string * ?LegendGroupTitle: Title * ?Opacity: float * ?Ids: #IConvertible seq * ?IdsEncoded: EncodedTypedArray * ?X: 'b seq * ?MultiX: 'b seq seq * ?XEncoded: EncodedTypedArray * ?X0: #IConvertible * ?DX: #IConvertible * ?XType: CoordinateType * ?Y: 'e seq * ?MultiY: 'e seq seq * ?YEncoded: EncodedTypedArray * ?Y0: #IConvertible * ?DY: #IConvertible * ?YType: CoordinateType * ?Z: #seq<'i> seq * ?ZEncoded: EncodedTypedArray * ?Text: 'j * ?MultiText: 'j seq * ?MultiTextEncoded: EncodedTypedArray * ?TextTemplate: string * ?HoverText: string * ?MultiHoverText: string seq * ?HoverInfo: HoverInfo * ?HoverTemplate: string * ?MultiHoverTemplate: string seq * ?XHoverFormat: string * ?YHoverFormat: string * ?Meta: string * ?CustomData: #IConvertible seq * ?CustomDataEncoded: EncodedTypedArray * ?XAxis: LinearAxisId * ?YAxis: LinearAxisId * ?ColorAxis: SubPlotId * ?XPeriod: #IConvertible * ?XPeriodAlignment: PeriodAlignment * ?XPeriod0: #IConvertible * ?YPeriod: #IConvertible * ?YPeriodAlignment: PeriodAlignment * ?YPeriod0: #IConvertible * ?Line: Line * ?TextFont: Font * ?ColorBar: ColorBar * ?AutoColorScale: bool * ?ColorScale: Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?ZAuto: bool * ?ZHoverFormat: string * ?ZMax: #IConvertible * ?ZMid: #IConvertible * ?ZMin: #IConvertible * ?AutoContour: bool * ?ConnectGaps: bool * ?Contours: Contours * ?FillColor: Color * ?HoverLabel: Hoverlabel * ?HoverOnGaps: bool * ?NContours: int * ?Transpose: bool * ?XCalendar: Calendar * ?YCalendar: Calendar * ?UIRevision: string -> ('T -> 'T) (requires 'b :> IConvertible and 'e :> IConvertible and 'i :> IConvertible and 'j :> IConvertible and 'T :> Trace) static member Funnel: ?Name: string * ?Visible: Visible * ?ShowLegend: bool * ?Legend: SubPlotId * ?LegendRank: int * ?LegendGroup: string * ?LegendGroupTitle: Title * ?Opacity: float * ?Ids: #IConvertible seq * ?IdsEncoded: EncodedTypedArray * ?X: 'b seq * ?MultiX: 'b seq seq * ?XEncoded: EncodedTypedArray * ?X0: #IConvertible * ?DX: #IConvertible * ?Y: 'e seq * ?MultiY: 'e seq seq * ?YEncoded: EncodedTypedArray * ?Y0: #IConvertible * ?DY: #IConvertible * ?Width: float * ?Offset: float * ?Text: 'h * ?MultiText: 'h seq * ?MultiTextEncoded: EncodedTypedArray * ?TextPosition: TextPosition * ?MultiTextPosition: TextPosition seq * ?TextTemplate: string * ?MultiTextTemplate: string seq * ?HoverText: string * ?MultiHoverText: string seq * ?HoverInfo: HoverInfo * ?HoverTemplate: string * ?MultiHoverTemplate: string seq * ?XHoverFormat: string * ?YHoverFormat: string * ?Meta: string * ?CustomData: #IConvertible seq * ?CustomDataEncoded: EncodedTypedArray * ?XAxis: LinearAxisId * ?YAxis: LinearAxisId * ?Orientation: Orientation * ?AlignmentGroup: string * ?OffsetGroup: string * ?XPeriod: #IConvertible * ?XPeriodAlignment: PeriodAlignment * ?XPeriod0: #IConvertible * ?YPeriod: #IConvertible * ?YPeriodAlignment: PeriodAlignment * ?YPeriod0: #IConvertible * ?Marker: Marker * ?TextAngle: float * ?TextFont: Font * ?TextInfo: TextInfo * ?SelectedPoints: #IConvertible seq * ?SelectedPointsEncoded: EncodedTypedArray * ?ClipOnAxis: bool * ?Connector: FunnelConnector * ?Constraintext: ConstrainText * ?HoverLabel: Hoverlabel * ?InsideTextAnchor: InsideTextAnchor * ?InsideTextFont: Font * ?OutsideTextFont: Font * ?UIRevision: string -> ('o -> 'o) (requires 'b :> IConvertible and 'e :> IConvertible and 'h :> IConvertible and 'o :> Trace) static member Heatmap: ?Name: string * ?Visible: Visible * ?ShowLegend: bool * ?Legend: SubPlotId * ?LegendRank: int * ?LegendGroup: string * ?LegendGroupTitle: Title * ?Opacity: float * ?Ids: #IConvertible seq * ?IdsEncoded: EncodedTypedArray * ?X: 'b seq * ?MultiX: 'b seq seq * ?XEncoded: EncodedTypedArray * ?X0: #IConvertible * ?DX: #IConvertible * ?XType: CoordinateType * ?XGap: int * ?Y: 'e seq * ?MultiY: 'e seq seq * ?YEncoded: EncodedTypedArray * ?Y0: #IConvertible * ?DY: #IConvertible * ?YType: CoordinateType * ?YGap: int * ?Z: #seq<'i> seq * ?ZEncoded: EncodedTypedArray * ?Text: 'j * ?MultiText: 'j seq * ?MultiTextEncoded: EncodedTypedArray * ?TextTemplate: string * ?HoverText: string * ?MultiHoverText: string seq * ?HoverInfo: HoverInfo * ?HoverTemplate: string * ?MultiHoverTemplate: string seq * ?XHoverFormat: string * ?YHoverFormat: string * ?Meta: string * ?CustomData: #IConvertible seq * ?CustomDataEncoded: EncodedTypedArray * ?XAxis: LinearAxisId * ?YAxis: LinearAxisId * ?ColorAxis: SubPlotId * ?XPeriod: #IConvertible * ?XPeriodAlignment: PeriodAlignment * ?XPeriod0: #IConvertible * ?YPeriod: #IConvertible * ?YPeriodAlignment: PeriodAlignment * ?YPeriod0: #IConvertible * ?TextFont: Font * ?ColorBar: ColorBar * ?AutoColorScale: bool * ?ColorScale: Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?ZAuto: bool * ?ZHoverFormat: string * ?ZMax: #IConvertible * ?ZMid: #IConvertible * ?ZMin: #IConvertible * ?ZSmooth: SmoothAlg * ?ConnectGaps: bool * ?HoverLabel: Hoverlabel * ?HoverOnGaps: bool * ?Transpose: bool * ?XCalendar: Calendar * ?YCalendar: Calendar * ?UIRevision: string -> ('T -> 'T) (requires 'b :> IConvertible and 'e :> IConvertible and 'i :> IConvertible and 'j :> IConvertible and 'T :> Trace) static member Histogram: ?Name: string * ?Visible: Visible * ?ShowLegend: bool * ?Legend: SubPlotId * ?LegendRank: int * ?LegendGroup: string * ?LegendGroupTitle: Title * ?Opacity: float * ?Ids: #IConvertible seq * ?IdsEncoded: EncodedTypedArray * ?X: 'b seq * ?MultiX: 'b seq seq * ?XEncoded: EncodedTypedArray * ?Y: 'c seq * ?MultiY: 'c seq seq * ?YEncoded: EncodedTypedArray * ?Text: 'd * ?MultiText: 'd seq * ?MultiTextEncoded: EncodedTypedArray * ?TextPosition: TextPosition * ?TextTemplate: string * ?MultiTextTemplate: string seq * ?HoverText: string * ?MultiHoverText: string seq * ?HoverInfo: HoverInfo * ?HoverTemplate: string * ?MultiHoverTemplate: string seq * ?XHoverFormat: string * ?YHoverFormat: string * ?Meta: string * ?CustomData: #IConvertible seq * ?CustomDataEncoded: EncodedTypedArray * ?XAxis: LinearAxisId * ?YAxis: LinearAxisId * ?Orientation: Orientation * ?HistFunc: HistFunc * ?HistNorm: HistNorm * ?AlignmentGroup: string * ?OffsetGroup: string * ?NBinsX: int * ?NBinsY: int * ?AutoBinX: bool * ?AutoBinY: bool * ?BinGroup: string * ?XBins: Bins * ?YBins: Bins * ?Marker: Marker * ?TextAngle: float * ?TextFont: Font * ?Line: Line * ?XError: Error * ?YError: Error * ?SelectedPoints: #IConvertible seq * ?SelectedPointsEncoded: EncodedTypedArray * ?Selected: TraceSelection * ?Unselected: TraceSelection * ?ClipOnAxis: bool * ?Constraintext: ConstrainText * ?Cumulative: Cumulative * ?HoverLabel: Hoverlabel * ?InsideTextAnchor: InsideTextAnchor * ?InsideTextFont: Font * ?OutsideTextFont: Font * ?XCalendar: Calendar * ?YCalendar: Calendar * ?UIRevision: string -> ('T -> 'T) (requires 'b :> IConvertible and 'c :> IConvertible and 'd :> IConvertible and 'T :> Trace) static member Histogram2D: ?Name: string * ?Visible: Visible * ?ShowLegend: bool * ?Legend: SubPlotId * ?LegendRank: int * ?LegendGroup: string * ?LegendGroupTitle: Title * ?Opacity: float * ?Ids: #IConvertible seq * ?IdsEncoded: EncodedTypedArray * ?X: 'b seq * ?MultiX: 'b seq seq * ?XEncoded: EncodedTypedArray * ?XGap: int * ?Y: 'c seq * ?MultiY: 'c seq seq * ?YEncoded: EncodedTypedArray * ?YGap: int * ?Z: #seq<'e> seq * ?ZEncoded: EncodedTypedArray * ?TextTemplate: string * ?HoverInfo: HoverInfo * ?HoverTemplate: string * ?MultiHoverTemplate: string seq * ?XHoverFormat: string * ?YHoverFormat: string * ?Meta: string * ?CustomData: #IConvertible seq * ?CustomDataEncoded: EncodedTypedArray * ?XAxis: LinearAxisId * ?YAxis: LinearAxisId * ?ColorAxis: SubPlotId * ?HistFunc: HistFunc * ?HistNorm: HistNorm * ?NBinsX: int * ?NBinsY: int * ?AutoBinX: bool * ?AutoBinY: bool * ?BinGroup: string * ?XBinGroup: string * ?XBins: Bins * ?YBinGroup: string * ?YBins: Bins * ?Marker: Marker * ?TextFont: Font * ?ColorBar: ColorBar * ?AutoColorScale: bool * ?ColorScale: Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?ZAuto: bool * ?ZHoverFormat: string * ?ZMin: float * ?ZMid: float * ?ZMax: float * ?ZSmooth: SmoothAlg * ?HoverLabel: Hoverlabel * ?XCalendar: Calendar * ?YCalendar: Calendar * ?UIRevision: string -> ('T -> 'T) (requires 'b :> IConvertible and 'c :> IConvertible and 'e :> IConvertible and 'T :> Trace) static member Histogram2DContour: ?Name: string * ?Visible: Visible * ?ShowLegend: bool * ?Legend: SubPlotId * ?LegendRank: int * ?LegendGroup: string * ?LegendGroupTitle: Title * ?Opacity: float * ?Ids: #IConvertible seq * ?IdsEncoded: EncodedTypedArray * ?X: 'b seq * ?MultiX: 'b seq seq * ?XEncoded: EncodedTypedArray * ?Y: 'c seq * ?MultiY: 'c seq seq * ?YEncoded: EncodedTypedArray * ?Z: #seq<'e> seq * ?ZEncoded: EncodedTypedArray * ?TextTemplate: string * ?HoverInfo: HoverInfo * ?HoverTemplate: string * ?MultiHoverTemplate: string seq * ?XHoverFormat: string * ?YHoverFormat: string * ?Meta: string * ?CustomData: #IConvertible seq * ?CustomDataEncoded: EncodedTypedArray * ?XAxis: LinearAxisId * ?YAxis: LinearAxisId * ?ColorAxis: SubPlotId * ?HistFunc: HistFunc * ?HistNorm: HistNorm * ?NBinsX: int * ?NBinsY: int * ?AutoBinX: bool * ?AutoBinY: bool * ?BinGroup: string * ?XBinGroup: string * ?XBins: Bins * ?YBinGroup: string * ?YBins: Bins * ?Marker: Marker * ?Line: Line * ?TextFont: Font * ?ColorBar: ColorBar * ?AutoColorScale: bool * ?ColorScale: Colorscale * ?ShowScale: bool * ?ReverseScale: bool * ?ZAuto: bool * ?ZHoverFormat: string * ?Zmin: float * ?Zmid: float * ?Zmax: float * ?AutoContour: bool * ?Contours: Contours * ?HoverLabel: Hoverlabel * ?NContours: int * ?XCalendar: Calendar * ?YCalendar: Calendar * ?UIRevision: string -> ('T -> 'T) (requires 'b :> IConvertible and 'c :> IConvertible and 'e :> IConvertible and 'T :> Trace) ...
<summary> Create various functions for applying 2D chart styles to traces </summary>

--------------------
new: unit -> Trace2DStyle

static member Trace2DStyle.Scatter: ?Name: string * ?Visible: StyleParam.Visible * ?ShowLegend: bool * ?Legend: StyleParam.SubPlotId * ?LegendRank: int * ?LegendGroup: string * ?LegendGroupTitle: Title * ?Opacity: float * ?Mode: StyleParam.Mode * ?Ids: #System.IConvertible seq * ?IdsEncoded: EncodedTypedArray * ?X: 'b seq * ?MultiX: 'b seq seq * ?X0: #System.IConvertible * ?DX: #System.IConvertible * ?Y: 'e seq * ?MultiY: 'e seq seq * ?Y0: #System.IConvertible * ?DY: #System.IConvertible * ?Text: 'h * ?MultiText: 'h seq * ?MultiTextEncoded: EncodedTypedArray * ?TextPosition: StyleParam.TextPosition * ?MultiTextPosition: StyleParam.TextPosition seq * ?TextTemplate: string * ?MultiTextTemplate: string seq * ?HoverText: string * ?MultiHoverText: string seq * ?HoverInfo: StyleParam.HoverInfo * ?HoverTemplate: string * ?MultiHoverTemplate: string seq * ?XHoverFormat: string * ?YHoverFormat: string * ?Meta: string * ?CustomData: #System.IConvertible seq * ?CustomDataEncoded: EncodedTypedArray * ?XAxis: StyleParam.LinearAxisId * ?YAxis: StyleParam.LinearAxisId * ?Orientation: StyleParam.Orientation * ?GroupNorm: StyleParam.GroupNorm * ?AlignmentGroup: string * ?OffsetGroup: string * ?StackGroup: string * ?XPeriod: #System.IConvertible * ?XPeriodAlignment: StyleParam.PeriodAlignment * ?XPeriod0: #System.IConvertible * ?YPeriod: #System.IConvertible * ?YPeriodAlignment: StyleParam.PeriodAlignment * ?YPeriod0: #System.IConvertible * ?Marker: Marker * ?Line: Line * ?TextFont: Font * ?XError: Error * ?YError: Error * ?SelectedPoints: #System.IConvertible seq * ?SelectedPointsEncoded: EncodedTypedArray * ?Selected: TraceSelection * ?Unselected: TraceSelection * ?ClipOnAxis: bool * ?ConnectGaps: bool * ?Fill: StyleParam.Fill * ?FillColor: Color * ?FillPattern: Pattern * ?HoverLabel: LayoutObjects.Hoverlabel * ?HoverOn: StyleParam.HoverOn * ?StackGaps: StyleParam.StackGaps * ?XCalendar: StyleParam.Calendar * ?YCalendar: StyleParam.Calendar * ?UIRevision: string * ?XEncoded: EncodedTypedArray * ?YEncoded: EncodedTypedArray -> ('T -> 'T) (requires 'b :> System.IConvertible and 'e :> System.IConvertible and 'h :> System.IConvertible and 'T :> Trace)

union case StyleParam.Mode.Lines_Markers: StyleParam.Mode

Multiple items
type Error = inherit DynamicObj new: unit -> Error static member init: ?Visible: bool * ?Type: ErrorType * ?Symmetric: bool * ?Array: #IConvertible seq * ?Arrayminus: #IConvertible seq * ?ArrayEncoded: EncodedTypedArray * ?ArrayminusEncoded: EncodedTypedArray * ?Value: float * ?Valueminus: float * ?Traceref: int * ?Tracerefminus: int * ?Copy_ystyle: bool * ?Color: Color * ?Thickness: float * ?Width: float -> Error static member style: ?Visible: bool * ?Type: ErrorType * ?Symmetric: bool * ?Array: #IConvertible seq * ?Arrayminus: #IConvertible seq * ?ArrayEncoded: EncodedTypedArray * ?ArrayminusEncoded: EncodedTypedArray * ?Value: float * ?Valueminus: float * ?Traceref: int * ?Tracerefminus: int * ?Copy_ystyle: bool * ?Color: Color * ?Thickness: float * ?Width: float -> (Error -> Error)
<summary> Error type inherits from dynamic object </summary>

--------------------
new: unit -> Error

static member Error.init: ?Visible: bool * ?Type: StyleParam.ErrorType * ?Symmetric: bool * ?Array: #System.IConvertible seq * ?Arrayminus: #System.IConvertible seq * ?ArrayEncoded: EncodedTypedArray * ?ArrayminusEncoded: EncodedTypedArray * ?Value: float * ?Valueminus: float * ?Traceref: int * ?Tracerefminus: int * ?Copy_ystyle: bool * ?Color: Color * ?Thickness: float * ?Width: float -> Error

type ErrorType = | Percent | Constant | Sqrt | Data member Convert: unit -> objnull override ToString: unit -> string static member convert: (ErrorType -> objnull) static member toString: (ErrorType -> string)

union case StyleParam.ErrorType.Data: StyleParam.ErrorType

static member GenericChart.ofTraceObject: useDefaults: bool -> trace: Trace -> GenericChart

static member Chart.withDisplayOptions: displayOpts: DisplayOptions -> (GenericChart -> GenericChart)

static member DisplayOptions.init: ?DocumentTitle: string * ?DocumentCharset: string * ?DocumentDescription: string * ?DocumentFavicon: Giraffe.ViewEngine.HtmlElements.XmlNode * ?AdditionalHeadTags: Giraffe.ViewEngine.HtmlElements.XmlNode list * ?ChartDescription: Giraffe.ViewEngine.HtmlElements.XmlNode list * ?PlotlyJSReference: PlotlyJSReference -> DisplayOptions

union case PlotlyJSReference.NoReference: PlotlyJSReference

val displayOptions: obj

val standaloneHtml: obj