open XPlot.Plotly
open System

let z =
    let rnd = Random()
    [ for _ in 1 .. 25 ->
        [ for _ in 1 .. 25 ->
            rnd.Next(0, 400)
        ]
    ]

let layout =
    Layout(
        autosize = false,
        margin =
            Margin(
                l = 65.,
                r = 50.,
                b = 65.,
                t = 90.
            )
    )

let chart =
    Surface(z = z)
    |> Chart.Plot
    |> Chart.WithLayout layout
    |> Chart.WithWidth 700
    |> Chart.WithHeight 500

namespace XPlot

namespace XPlot.Plotly

namespace System

val z : int list list

val rnd : Random

Multiple items
type Random =
  new : unit -> unit + 1 overload
  member Next : unit -> int + 2 overloads
  member NextBytes : buffer: byte [] -> unit + 1 overload
  member NextDouble : unit -> float
  member Sample : unit -> float

--------------------
Random() : Random
Random(Seed: int) : Random

Random.Next() : int
Random.Next(maxValue: int) : int
Random.Next(minValue: int, maxValue: int) : int

val layout : Layout

Multiple items
module Layout

from XPlot.Plotly

--------------------
type Layout =
  new : unit -> Layout
  member ShouldSerializeangularaxis : unit -> bool
  member ShouldSerializeannotations : unit -> bool
  member ShouldSerializeautosize : unit -> bool
  member ShouldSerializebargap : unit -> bool
  member ShouldSerializebargroupgap : unit -> bool
  member ShouldSerializebarmode : unit -> bool
  member ShouldSerializeboxmode : unit -> bool
  member ShouldSerializedirection : unit -> bool
  member ShouldSerializedragmode : unit -> bool
  ...

--------------------
new : unit -> Layout

Multiple items
type Margin =
  new : unit -> Margin
  member ShouldSerializeautoexpand : unit -> bool
  member ShouldSerializeb : unit -> bool
  member ShouldSerializel : unit -> bool
  member ShouldSerializepad : unit -> bool
  member ShouldSerializer : unit -> bool
  member ShouldSerializet : unit -> bool
  member autoexpand : bool
  member b : float
  member l : float
  ...

--------------------
new : unit -> Margin

property Margin.l: float with get, set

property Margin.r: float with get, set

property Margin.b: float with get, set

property Margin.t: float with get, set

val chart : PlotlyChart

Multiple items
type Surface =
  inherit Trace
  new : unit -> Surface
  member ShouldSerializeautocolorscale : unit -> bool
  member ShouldSerializecolorbar : unit -> bool
  member ShouldSerializecolorscale : unit -> bool
  member ShouldSerializecontours : unit -> bool
  member ShouldSerializehidesurface : unit -> bool
  member ShouldSerializehoverinfo : unit -> bool
  member ShouldSerializelegendgroup : unit -> bool
  member ShouldSerializelighting : unit -> bool
  ...

--------------------
new : unit -> Surface

property Surface.z: obj with get, set

type Chart =
  static member Area : data:seq<#value> -> PlotlyChart + 2 overloads
  static member Bar : data:seq<#value> -> PlotlyChart + 2 overloads
  static member Bubble : data:seq<#key * #value * #value> -> PlotlyChart
  static member Candlestick : data:seq<#key * #value * #value * #value * #value> -> PlotlyChart
  static member Column : data:seq<#value> -> PlotlyChart + 2 overloads
  static member Line : data:seq<#value> -> PlotlyChart + 2 overloads
  static member Pie : data:seq<#key * #value> -> PlotlyChart
  static member Plot : data:Trace -> PlotlyChart + 3 overloads
  static member Scatter : data:seq<#value> -> PlotlyChart + 2 overloads
  static member Show : chart:PlotlyChart -> unit
  ...

static member Chart.Plot : data:seq<#Trace> -> PlotlyChart
static member Chart.Plot : data:Trace -> PlotlyChart
static member Chart.Plot : data:seq<#Trace> * layout:Layout -> PlotlyChart
static member Chart.Plot : data:Trace * layout:Layout -> PlotlyChart

static member Chart.WithLayout : layout:Layout -> chart:PlotlyChart -> PlotlyChart

static member Chart.WithWidth : width:int -> chart:PlotlyChart -> PlotlyChart

static member Chart.WithHeight : height:int -> chart:PlotlyChart -> PlotlyChart

member PlotlyChart.GetHtml : unit -> string