Module

ECharts.Commands

Package: purescript-echarts
Repository: slamdata/purescript-echarts

#series Source

series :: forall m i. Monad m => (CommandsT SeriesI m) ~> (CommandsT (series :: I | i) m)

#tooltip Source

tooltip :: forall m i. Monad m => (CommandsT TooltipI m) ~> (CommandsT (tooltip :: I | i) m)

#grids Source

grids :: forall m i. Monad m => (CommandsT GridsI m) ~> (CommandsT (grid :: I | i) m)

#grid Source

grid :: forall m i. Monad m => (CommandsT GridI m) ~> (CommandsT (grid :: I | i) m)

#polar Source

polar :: forall m i. Monad m => (CommandsT PolarI m) ~> (CommandsT (polar :: I | i) m)

#legend Source

legend :: forall m i. Monad m => (CommandsT LegendI m) ~> (CommandsT (legend :: I | i) m)

#xAxis Source

xAxis :: forall m i. Monad m => (CommandsT XAxisI m) ~> (CommandsT (xAxis :: I | i) m)

#yAxis Source

yAxis :: forall m i. Monad m => (CommandsT YAxisI m) ~> (CommandsT (yAxis :: I | i) m)

#radiusAxis Source

radiusAxis :: forall m i. Monad m => (CommandsT RadiusAxisI m) ~> (CommandsT (radiusAxis :: I | i) m)

#angleAxis Source

angleAxis :: forall m i. Monad m => (CommandsT AngleAxisI m) ~> (CommandsT (angleAxis :: I | i) m)

#color Source

color :: forall m i. Monad m => Color -> DSL (color :: I | i) m

#colors Source

colors :: forall m f i. Monad m => Foldable f => f Color -> DSL (color :: I | i) m

#rgbaColors Source

rgbaColors :: forall m f i. Monad m => Foldable f => f Color -> DSL (color :: I | i) m

#rgbaColor Source

rgbaColor :: forall m i. Monad m => Color -> DSL (color :: I | i) m

#backgroundColor Source

backgroundColor :: forall m i. Monad m => Color -> DSL (backgroundColor :: I | i) m

#visible Source

visible :: forall m i. Monad m => Boolean -> DSL (show :: I | i) m

#shown Source

shown :: forall m i. Monad m => DSL (show :: I | i) m

#hidden Source

hidden :: forall m i. Monad m => DSL (show :: I | i) m

#showTitle Source

showTitle :: forall m i. Monad m => Boolean -> DSL (showTitle :: I | i) m

#textStyle Source

textStyle :: forall m i. Monad m => (CommandsT TextStyleI m) ~> (CommandsT (textStyle :: I | i) m)

#subtextStyle Source

subtextStyle :: forall m i. Monad m => (CommandsT TextStyleI m) ~> (CommandsT (subtextStyle :: I | i) m)

#left Source

left :: forall m i. Monad m => PixelOrPercent -> DSL (left :: I | i) m

#right Source

right :: forall m i. Monad m => PixelOrPercent -> DSL (right :: I | i) m

#top Source

top :: forall m i. Monad m => PixelOrPercent -> DSL (top :: I | i) m

#topTop Source

topTop :: forall m i. Monad m => DSL (top :: I | i) m

#topMiddle Source

topMiddle :: forall m i. Monad m => DSL (top :: I | i) m

#topBottom Source

topBottom :: forall m i. Monad m => DSL (top :: I | i) m

#bottom Source

bottom :: forall m i. Monad m => PixelOrPercent -> DSL (bottom :: I | i) m

#bottomPx Source

bottomPx :: forall m i. Monad m => Int -> DSL (bottom :: I | i) m

#orient Source

orient :: forall m i. Monad m => Orient -> DSL (orient :: I | i) m

#items Source

items :: forall m f i. Monad m => Foldable f => f Item -> DSL (items :: I | i) m

#itemsDSL Source

itemsDSL :: forall a m f i. Monad m => Traversable f => f (CommandsT ItemI m a) -> CommandsT (items :: I | i) m (f a)

#addItem Source

addItem :: forall m i. Monad m => (CommandsT ItemI m) ~> (CommandsT (item :: I | i) m)

#buildItems Source

buildItems :: forall m i. Monad m => (CommandsT ItemsI m) ~> (CommandsT (items :: I | i) m)

#buildMarkItems Source

buildMarkItems :: forall m i. Monad m => (CommandsT ItemsI m) ~> (CommandsT (markItems :: I | i) m)

#calendarIndex Source

calendarIndex :: forall m i. Monad m => Int -> DSL (calendarIndex :: I | i) m

#visibleContent Source

visibleContent :: forall m i. Monad m => Boolean -> DSL (showContent :: I | i) m

#showContent Source

showContent :: forall m i. Monad m => DSL (showContent :: I | i) m

#hideContent Source

hideContent :: forall m i. Monad m => DSL (showContent :: I | i) m

#alwaysShowContent Source

alwaysShowContent :: forall m i. Monad m => Boolean -> DSL (alwaysShowContent :: I | i) m

#trigger Source

trigger :: forall m i. Monad m => TooltipTrigger -> DSL (trigger :: I | i) m

#triggerOnMouseMove Source

triggerOnMouseMove :: forall m i. Monad m => DSL (triggerOn :: I | i) m

#triggerOnClick Source

triggerOnClick :: forall m i. Monad m => DSL (triggerOn :: I | i) m

#triggerAxis Source

triggerAxis :: forall m i. Monad m => DSL (trigger :: I | i) m

#triggerItem Source

triggerItem :: forall m i. Monad m => DSL (trigger :: I | i) m

#triggerEvent Source

triggerEvent :: forall m i. Monad m => Boolean -> DSL (trigger :: I | i) m

#pie Source

pie :: forall m i. Monad m => (CommandsT PieSeriesI m) ~> (CommandsT (pie :: I | i) m)

#line Source

line :: forall m i. Monad m => (CommandsT LineSeriesI m) ~> (CommandsT (line :: I | i) m)

#bar Source

bar :: forall m i. Monad m => (CommandsT BarSeriesI m) ~> (CommandsT (bar :: I | i) m)

#scatter Source

scatter :: forall m i. Monad m => (CommandsT ScatterI m) ~> (CommandsT (scatter :: I | i) m)

#effectScatter Source

effectScatter :: forall m i. Monad m => (CommandsT EffectScatterI m) ~> (CommandsT (effectScatter :: I | i) m)

#treeMap Source

treeMap :: forall m i. Monad m => (CommandsT TreeMapI m) ~> (CommandsT (treeMap :: I | i) m)

#boxPlot Source

boxPlot :: forall m i. Monad m => (CommandsT BoxPlotI m) ~> (CommandsT (boxPlot :: I | i) m)

#candlestick Source

candlestick :: forall m i. Monad m => (CommandsT CandlestickI m) ~> (CommandsT (candlestick :: I | i) m)

#heatMap Source

heatMap :: forall m i. Monad m => (CommandsT HeatMapI m) ~> (CommandsT (heatMap :: I | i) m)

#calendarSpec Source

calendarSpec :: forall m i. Monad m => (CommandsT CalendarSpecI m) ~> (CommandsT (calendarSpec :: I | i) m)

#map_ Source

map_ :: forall m i. Monad m => (CommandsT MapI m) ~> (CommandsT (map :: I | i) m)

#parallels Source

parallels :: forall m i. Monad m => (CommandsT ParallelsI m) ~> (CommandsT (parallel :: I | i) m)

#parallel Source

parallel :: forall m i. Monad m => (CommandsT ParallelI m) ~> (CommandsT (parallel :: I | i) m)

#lines Source

lines :: forall m i. Monad m => (CommandsT LinesI m) ~> (CommandsT (lines :: I | i) m)

#graph Source

graph :: forall m i. Monad m => (CommandsT GraphI m) ~> (CommandsT (graph :: I | i) m)

#sankey Source

sankey :: forall m i. Monad m => (CommandsT SankeyI m) ~> (CommandsT (sankey :: I | i) m)

#funnel Source

funnel :: forall m i. Monad m => (CommandsT FunnelI m) ~> (CommandsT (funnel :: I | i) m)

#parallelSeries Source

parallelSeries :: forall m i. Monad m => (CommandsT ParallelSeriesI m) ~> (CommandsT (parallelSeries :: I | i) m)

#gauge Source

gauge :: forall m i. Monad m => (CommandsT GaugeI m) ~> (CommandsT (gauge :: I | i) m)

#radarSeries Source

radarSeries :: forall m i. Monad m => (CommandsT RadarSeriesI m) ~> (CommandsT (radarSeries :: I | i) m)

#xAxisIndex Source

xAxisIndex :: forall m i. Monad m => Int -> DSL (xAxisIndex :: I | i) m

#yAxisIndex Source

yAxisIndex :: forall m i. Monad m => Int -> DSL (yAxisIndex :: I | i) m

#xAxisAllIndices Source

xAxisAllIndices :: forall m i. Monad m => DSL (xAxisIndex :: I | i) m

#yAxisAllIndices Source

yAxisAllIndices :: forall m i. Monad m => DSL (yAxisIndex :: I | i) m

#polarIndex Source

polarIndex :: forall m i. Monad m => Int -> DSL (polarIndex :: I | i) m

#symbol Source

symbol :: forall m i. Monad m => Symbol -> DSL (symbol :: I | i) m

#symbolSize Source

symbolSize :: forall m i. Monad m => Int -> DSL (symbolSize :: I | i) m

#smooth Source

smooth :: forall m i. Monad m => Boolean -> DSL (smooth :: I | i) m

#name Source

name :: forall m i. Monad m => String -> DSL (name :: I | i) m

#stack Source

stack :: forall m i. Monad m => String -> DSL (stack :: I | i) m

#center Source

center :: forall m i. Monad m => Point -> DSL (center :: I | i) m

#radius Source

radius :: forall m i. Monad m => Radius -> DSL (radius :: I | i) m

#singleValueRadius Source

singleValueRadius :: forall m i. Monad m => SingleValueRadius -> DSL (radius :: I | i) m

#startAngle Source

startAngle :: forall m i. Monad m => Number -> DSL (startAngle :: I | i) m

#axisTick Source

axisTick :: forall m i. Monad m => (CommandsT AxisTickI m) ~> (CommandsT (axisTick :: I | i) m)

#axisLabel Source

axisLabel :: forall m i. Monad m => (CommandsT AxisLabelI m) ~> (CommandsT (axisLabel :: I | i) m)

#axisType Source

axisType :: forall m i. Monad m => AxisType -> DSL (axisType :: I | i) m

#value Source

value :: forall m i. Monad m => Number -> DSL (value :: I | i) m

#values Source

values :: forall m f i. Monad m => Foldable f => f Number -> DSL (value :: I | i) m

#buildValues Source

buildValues :: forall m i. Monad m => (CommandsT ValuesI m) ~> (CommandsT (value :: I | i) m)

#addValue Source

addValue :: forall m i. Monad m => Number -> DSL (addValue :: I | i) m

#addStringValue Source

addStringValue :: forall m i. Monad m => String -> DSL (addValue :: I | i) m

#autoValue Source

autoValue :: forall m i. Monad m => DSL (addValue :: I | i) m

#buildNames Source

buildNames :: forall m i. Monad m => (CommandsT NamesI m) ~> (CommandsT (name :: I | i) m)

#addName Source

addName :: forall m i. Monad m => String -> DSL (addName :: I | i) m

#missingValue Source

missingValue :: forall m i. Monad m => DSL (addValue :: I | i) m

#missingName Source

missingName :: forall m i. Monad m => DSL (addName :: I | i) m

#valuePair Source

valuePair :: forall m i. Monad m => String -> Number -> DSL (value :: I | i) m

#titles Source

titles :: forall m i. Monad m => (CommandsT TitlesI m) ~> (CommandsT (title :: I | i) m)

#title Source

title :: forall m i. Monad m => (CommandsT TitleI m) ~> (CommandsT (title :: I | i) m)

#text Source

text :: forall m i. Monad m => String -> DSL (text :: I | i) m

#showDelay Source

showDelay :: forall m i. Monad m => Number -> DSL (showDelay :: I | i) m

#hideDelay Source

hideDelay :: forall m i. Monad m => Number -> DSL (hideDelay :: I | i) m

#pointerType Source

pointerType :: forall m i. Monad m => PointerType -> DSL (pointerType :: I | i) m

#zlevel Source

zlevel :: forall m i. Monad m => Int -> DSL (zlevel :: I | i) m

#lineType Source

lineType :: forall m i. Monad m => LineType -> DSL (lineType :: I | i) m

#width Source

width :: forall m i. Monad m => Int -> DSL (width :: I | i) m

#widthPct Source

widthPct :: forall m i. Monad m => Number -> DSL (width :: I | i) m

#axisPointer Source

axisPointer :: forall m i. Monad m => (CommandsT AxisPointerI m) ~> (CommandsT (axisPointer :: I | i) m)

#scale Source

scale :: forall m i. Monad m => Boolean -> DSL (scale :: I | i) m

#large Source

large :: forall m i. Monad m => Boolean -> DSL (large :: I | i) m

#formatterAxis Source

formatterAxis :: forall m i. Monad m => (Array FormatterInput -> String) -> DSL (formatter :: I | i) m

#formatterAxisArrayValue Source

formatterAxisArrayValue :: forall m i. Monad m => (Array FormatterInputArrayValue -> String) -> DSL (formatter :: I | i) m

#formatterItem Source

formatterItem :: forall m i. Monad m => (FormatterInput -> String) -> DSL (formatter :: I | i) m

#formatterItemArrayValue Source

formatterItemArrayValue :: forall m i. Monad m => (FormatterInputArrayValue -> String) -> DSL (formatter :: I | i) m

#formatterString Source

formatterString :: forall m i. Monad m => String -> DSL (formatter :: I | i) m

#formatterValue Source

formatterValue :: forall m i. Monad m => (Number -> String) -> DSL (formatter :: I | i) m

#formatterLabel Source

formatterLabel :: forall m i. Monad m => (String -> String) -> DSL (formatter :: I | i) m

#animationEnabled Source

animationEnabled :: forall m i. Monad m => Boolean -> DSL (animation :: I | i) m

#splitLine Source

splitLine :: forall m i. Monad m => (CommandsT SplitLineI m) ~> (CommandsT (splitLine :: I | i) m)

#boundaryGap Source

boundaryGap :: forall m i. Monad m => Point -> DSL (boundaryGap :: I | i) m

#disabledBoundaryGap Source

disabledBoundaryGap :: forall m i. Monad m => DSL (boundaryGap :: I | i) m

#enabledBoundaryGap Source

enabledBoundaryGap :: forall m i. Monad m => DSL (boundaryGap :: I | i) m

#hoverAnimationEnabled Source

hoverAnimationEnabled :: forall m i. Monad m => Boolean -> DSL (hoverAnimation :: I | i) m

#showSymbol Source

showSymbol :: forall m i. Monad m => Boolean -> DSL (showSymbol :: I | i) m

#selectedMode Source

selectedMode :: forall m i. Monad m => SelectedMode -> DSL (selectedMode :: I | i) m

#label Source

label :: forall m i. Monad m => (CommandsT LabelI m) ~> (CommandsT (label :: I | i) m)

#normalLabel Source

normalLabel :: forall m i. Monad m => (CommandsT LabelInnerI m) ~> (CommandsT (normal :: R LabelInnerI | i) m)

#precision Source

precision :: forall m i. Monad m => Number -> DSL (precision :: I | i) m

#emphasisLabel Source

emphasisLabel :: forall m i. Monad m => (CommandsT LabelInnerI m) ~> (CommandsT (emphasis :: R LabelInnerI | i) m)

#selected Source

selected :: forall m i. Monad m => Boolean -> DSL (selected :: I | i) m

#leftPosition Source

leftPosition :: forall m i. Monad m => HorizontalPosition -> DSL (left :: I | i) m

#alignLeft Source

alignLeft :: forall m i. Monad m => DSL (align :: I | i) m

#alignRight Source

alignRight :: forall m i. Monad m => DSL (align :: I | i) m

#alignAuto Source

alignAuto :: forall m i. Monad m => DSL (align :: I | i) m

#funnelLeft Source

funnelLeft :: forall m i. Monad m => DSL (funnelAlign :: I | i) m

#funnelRight Source

funnelRight :: forall m i. Monad m => DSL (funnelAlign :: I | i) m

#funnelCenter Source

funnelCenter :: forall m i. Monad m => DSL (funnelAlign :: I | i) m

#textLeft Source

textLeft :: forall m i. Monad m => DSL (textAlign :: I | i) m

#textRight Source

textRight :: forall m i. Monad m => DSL (textAlign :: I | i) m

#textCenter Source

textCenter :: forall m i. Monad m => DSL (textAlign :: I | i) m

#textTop Source

textTop :: forall m i. Monad m => DSL (textBaseline :: I | i) m

#textBottom Source

textBottom :: forall m i. Monad m => DSL (textBaseline :: I | i) m

#textMiddle Source

textMiddle :: forall m i. Monad m => DSL (textBaseline :: I | i) m

#brush Source

brush :: forall m i. Monad m => (CommandsT BrushI m) ~> (CommandsT (brush :: I | i) m)

#brushType Source

brushType :: forall m i. Monad m => (CommandsT BrushToolboxI m) ~> (CommandsT (brushType :: I | i) m)

#brushToolbox Source

brushToolbox :: forall m i. Monad m => (CommandsT BrushToolboxI m) ~> (CommandsT (brushToolbox :: I | i) m)

#brushModeSingle Source

brushModeSingle :: forall m i. Monad m => DSL (brushMode :: I | i) m

#brushIcons Source

brushIcons :: forall m i. Monad m => (CommandsT BFFieldI m) ~> (CommandsT (bfIcon :: I | i) m)

#brushTitle Source

brushTitle :: forall m i. Monad m => (CommandsT BFFieldI m) ~> (CommandsT (bfTitle :: I | i) m)

#brushModeMultiple Source

brushModeMultiple :: forall m i. Monad m => DSL (brushMode :: I | i) m

#rect Source

rect :: forall m i. Monad m => DSL (tool :: I | i) m

#setRect Source

setRect :: forall m i. Monad m => String -> DSL (rect :: I | i) m

#polygon Source

polygon :: forall m i. Monad m => DSL (tool :: I | i) m

#setPolygon Source

setPolygon :: forall m i. Monad m => String -> DSL (polygon :: I | i) m

#lineX Source

lineX :: forall m i. Monad m => DSL (tool :: I | i) m

#setLineX Source

setLineX :: forall m i. Monad m => String -> DSL (lineX :: I | i) m

#lineY Source

lineY :: forall m i. Monad m => DSL (tool :: I | i) m

#setLineY Source

setLineY :: forall m i. Monad m => String -> DSL (lineY :: I | i) m

#keep Source

keep :: forall m i. Monad m => DSL (tool :: I | i) m

#setKeep Source

setKeep :: forall m i. Monad m => String -> DSL (keep :: I | i) m

#clear Source

clear :: forall m i. Monad m => DSL (tool :: I | i) m

#setClear Source

setClear :: forall m i. Monad m => String -> DSL (clear :: I | i) m

#dataZoom Source

dataZoom :: forall m i. Monad m => (CommandsT DataZoomI m) ~> (CommandsT (dataZoom :: I | i) m)

#insideDataZoom Source

insideDataZoom :: forall m i. Monad m => (CommandsT InsideDataZoomI m) ~> (CommandsT (insideDataZoom :: I | i) m)

#sliderDataZoom Source

sliderDataZoom :: forall m i. Monad m => (CommandsT SliderDataZoomI m) ~> (CommandsT (sliderDataZoom :: I | i) m)

#toolbox Source

toolbox :: forall m i. Monad m => (CommandsT ToolboxI m) ~> (CommandsT (toolbox :: I | i) m)

#feature Source

feature :: forall m i. Monad m => (CommandsT FeatureI m) ~> (CommandsT (feature :: I | i) m)

#brushFeature Source

brushFeature :: forall m i. Monad m => (CommandsT BrushFeatureI m) ~> (CommandsT (brush :: I | i) m)

#magicType Source

magicType :: forall m i. Monad m => (CommandsT MagicTypeI m) ~> (CommandsT (magicType :: I | i) m)

#magics Source

magics :: forall m i. Monad m => (CommandsT MagicsI m) ~> (CommandsT (magics :: I | i) m)

#magicLine Source

magicLine :: forall m i. Monad m => DSL (magic :: I | i) m

#magicBar Source

magicBar :: forall m i. Monad m => DSL (magic :: I | i) m

#magicStack Source

magicStack :: forall m i. Monad m => DSL (magic :: I | i) m

#magicTiled Source

magicTiled :: forall m i. Monad m => DSL (magic :: I | i) m

#dataView Source

dataView :: forall m i. Monad m => (CommandsT DataViewI m) ~> (CommandsT (dataView :: I | i) m)

#dataZoomFeature Source

dataZoomFeature :: forall m i. Monad m => (CommandsT DataZoomFeatureI m) ~> (CommandsT (dataZoom :: I | i) m)

#splitArea Source

splitArea :: forall m i. Monad m => (CommandsT SplitAreaI m) ~> (CommandsT (splitArea :: I | i) m)

#axisLine Source

axisLine :: forall m i. Monad m => (CommandsT AxisLineI m) ~> (CommandsT (axisLine :: I | i) m)

#silent Source

silent :: forall m i. Monad m => Boolean -> DSL (silent :: I | i) m

#onZero Source

onZero :: forall m i. Monad m => Boolean -> DSL (onZero :: I | i) m

#inverse Source

inverse :: forall m i. Monad m => Boolean -> DSL (inverse :: I | i) m

#visualMap Source

visualMap :: forall m i. Monad m => (CommandsT VisualMapI m) ~> (CommandsT (visualMap :: I | i) m)

#calendar Source

calendar :: forall m i. Monad m => (CommandsT CalendarI m) ~> (CommandsT (calendar :: I | i) m)

#continuous Source

continuous :: forall m i. Monad m => (CommandsT ContinuousVisualMapI m) ~> (CommandsT (continuousVisualMap :: I | i) m)

#dimension Source

dimension :: forall m i. Monad m => Int -> DSL (dimension :: I | i) m

#textPair Source

textPair :: forall m i. Monad m => String -> String -> DSL (textPair :: I | i) m

#itemHeight Source

itemHeight :: forall m i. Monad m => Number -> DSL (itemHeight :: I | i) m

#itemWidth Source

itemWidth :: forall m i. Monad m => Number -> DSL (itemWidth :: I | i) m

#calculable Source

calculable :: forall m i. Monad m => Boolean -> DSL (calculable :: I | i) m

#min Source

min :: forall m i. Monad m => Number -> DSL (min :: I | i) m

#max Source

max :: forall m i. Monad m => Number -> DSL (max :: I | i) m

#inRange Source

inRange :: forall m i. Monad m => (CommandsT InOutRangeI m) ~> (CommandsT (inRange :: I | i) m)

#outOfRange Source

outOfRange :: forall m i. Monad m => (CommandsT InOutRangeI m) ~> (CommandsT (outOfRange :: I | i) m)

#controller Source

controller :: forall m i. Monad m => (CommandsT ControllerI m) ~> (CommandsT (controller :: I | i) m)

#colorLightness Source

colorLightness :: forall m i. Monad m => Number -> Number -> DSL (colorLightness :: I | i) m

#itemStyle Source

itemStyle :: forall m i. Monad m => (CommandsT ItemStyleI m) ~> (CommandsT (itemStyle :: I | i) m)

#normalItemStyle Source

normalItemStyle :: forall m i. Monad m => (CommandsT IStyleI m) ~> (CommandsT (normal :: R IStyleI | i) m)

#emphasisItemStyle Source

emphasisItemStyle :: forall m i. Monad m => (CommandsT IStyleI m) ~> (CommandsT (emphasis :: R IStyleI | i) m)

#barBorderWidth Source

barBorderWidth :: forall m i. Monad m => Number -> DSL (barBorderWidth :: I | i) m

#shadowBlur Source

shadowBlur :: forall m i. Monad m => Number -> DSL (shadowBlur :: I | i) m

#shadowOffsetX Source

shadowOffsetX :: forall m i. Monad m => Number -> DSL (shadowOffsetX :: I | i) m

#shadowOffsetY Source

shadowOffsetY :: forall m i. Monad m => Number -> DSL (shadowOffsetY :: I | i) m

#shadowColor Source

shadowColor :: forall m i. Monad m => Color -> DSL (shadowColor :: I | i) m

#restore Source

restore :: forall m i. Monad m => (CommandsT RestoreI m) ~> (CommandsT (restore :: I | i) m)

#saveAsImage Source

saveAsImage :: forall m i. Monad m => (CommandsT SaveAsImageI m) ~> (CommandsT (saveAsImage :: I | i) m)

#z Source

z :: forall m i. Monad m => Int -> DSL (z :: I | i) m

#splitNumber Source

splitNumber :: forall m i. Monad m => Int -> DSL (splitNumber :: I | i) m

#gaugeRadius Source

gaugeRadius :: forall m i. Monad m => PixelOrPercent -> DSL (gaugeRadius :: I | i) m

#detail Source

detail :: forall m i. Monad m => (CommandsT DetailI m) ~> (CommandsT (detail :: I | i) m)

#endAngle Source

endAngle :: forall m i. Monad m => Number -> DSL (endAngle :: I | i) m

#gaugePointer Source

gaugePointer :: forall m i. Monad m => (CommandsT GaugePointerI m) ~> (CommandsT (gaugePointer :: I | i) m)

#length Source

length :: forall m i. Monad m => Int -> DSL (length :: I | i) m

#autoColor Source

autoColor :: forall m i. Monad m => DSL (color :: I | i) m

#bolderFontWeight Source

bolderFontWeight :: forall m i. Monad m => DSL (fontWeight :: I | i) m

#fontSize Source

fontSize :: forall m i. Monad m => Int -> DSL (fontSize :: I | i) m

#italicFontStyle Source

italicFontStyle :: forall m i. Monad m => DSL (fontStyle :: I | i) m

#offsetCenter Source

offsetCenter :: forall m i. Monad m => Point -> DSL (offsetCenter :: I | i) m

#subtext Source

subtext :: forall m i. Monad m => String -> DSL (subtext :: I | i) m

#readOnly Source

readOnly :: forall m i. Monad m => Boolean -> DSL (readOnly :: I | i) m

#positionInside Source

positionInside :: forall m i. Monad m => DSL (position :: I | i) m

#positionTop Source

positionTop :: forall m i. Monad m => DSL (position :: I | i) m

#labelLine Source

labelLine :: forall m i. Monad m => (CommandsT LabelLineI m) ~> (CommandsT (labelLine :: I | i) m)

#normalLabelLine Source

normalLabelLine :: forall m i. Monad m => (CommandsT LabelLineInnerI m) ~> (CommandsT (normal :: R LabelLineInnerI | i) m)

#emphasisLabelLine Source

emphasisLabelLine :: forall m i. Monad m => (CommandsT LabelLineInnerI m) ~> (CommandsT (emphasis :: R LabelLineInnerI | i) m)

#opacity Source

opacity :: forall m i. Monad m => Number -> DSL (opacity :: I | i) m

#maxSize Source

maxSize :: forall m i. Monad m => Int -> DSL (maxSize :: I | i) m

#maxSizePct Source

maxSizePct :: forall m i. Monad m => Number -> DSL (maxSize :: I | i) m

#borderColor Source

borderColor :: forall m i. Monad m => Color -> DSL (borderColor :: I | i) m

#borderWidth Source

borderWidth :: forall m i. Monad m => Int -> DSL (borderWidth :: I | i) m

#normalLineStyle Source

normalLineStyle :: forall m i. Monad m => (CommandsT LineStyleI m) ~> (CommandsT (normal :: R LineStyleI | i) m)

#emphasisLineStyle Source

emphasisLineStyle :: forall m i. Monad m => (CommandsT LineStyleI m) ~> (CommandsT (emphasis :: R LineStyleI | i) m)

#leftCenter Source

leftCenter :: forall m i. Monad m => DSL (left :: I | i) m

#leftLeft Source

leftLeft :: forall m i. Monad m => DSL (left :: I | i) m

#leftRight Source

leftRight :: forall m i. Monad m => DSL (left :: I | i) m

#itemGap Source

itemGap :: forall m i. Monad m => Int -> DSL (itemGap :: I | i) m

#indicators Source

indicators :: forall m i. Monad m => (CommandsT IndicatorsI m) ~> (CommandsT (indicators :: I | i) m)

#indicator Source

indicator :: forall m i. Monad m => (CommandsT IndicatorI m) ~> (CommandsT (indicator :: I | i) m)

#radarName Source

radarName :: forall m i. Monad m => (CommandsT RadarNameI m) ~> (CommandsT (radarName :: I | i) m)

#nameGap Source

nameGap :: forall m i. Monad m => Number -> DSL (nameGap :: I | i) m

#polygonShape Source

polygonShape :: forall m i. Monad m => DSL (shape :: I | i) m

#circleShape Source

circleShape :: forall m i. Monad m => DSL (shape :: I | i) m

#lineStylePair Source

lineStylePair :: forall m i. Monad m => (CommandsT LineStylePairI m) ~> (CommandsT (lineStyle :: R LineStylePairI | i) m)

#areaStylePair Source

areaStylePair :: forall m i. Monad m => (CommandsT AreaStylePairI m) ~> (CommandsT (areaStyle :: R AreaStylePairI | i) m)

#normalAreaStyle Source

normalAreaStyle :: forall m i. Monad m => (CommandsT AreaStyleI m) ~> (CommandsT (normal :: R AreaStyleI | i) m)

#emphasisAreaStyle Source

emphasisAreaStyle :: forall m i. Monad m => (CommandsT AreaStyleI m) ~> (CommandsT (emphasis :: R AreaStyleI | i) m)

#radars Source

radars :: forall m i. Monad m => (CommandsT RadarsI m) ~> (CommandsT (radar :: I | i) m)

#radar Source

radar :: forall m i. Monad m => (CommandsT RadarI m) ~> (CommandsT (radar :: I | i) m)

#ascending Source

ascending :: forall m i. Monad m => DSL (sort :: I | i) m

#descending Source

descending :: forall m i. Monad m => DSL (sort :: I | i) m

#animationDurationUpdate Source

animationDurationUpdate :: forall m i. Monad m => Int -> DSL (animationDurationUpdate :: I | i) m

#animationEasingUpdateQuinticInOut Source

animationEasingUpdateQuinticInOut :: forall m i. Monad m => DSL (animationEasingUpdate :: I | i) m

#roam Source

roam :: forall m i. Monad m => Boolean -> DSL (roam :: I | i) m

#edgeSymbols Source

edgeSymbols :: forall m i. Monad m => (CommandsT EdgeSymbolsI m) ~> (CommandsT (edgeSymbols :: I | i) m)

#circleEdgeSymbol Source

circleEdgeSymbol :: forall m i. Monad m => DSL (edgeSymbol :: I | i) m

#arrowEdgeSymbol Source

arrowEdgeSymbol :: forall m i. Monad m => DSL (edgeSymbol :: I | i) m

#edgeSymbolSize Source

edgeSymbolSize :: forall m i. Monad m => Int -> DSL (edgeSymbolSize :: I | i) m

#edgeSymbolSizes Source

edgeSymbolSizes :: forall m i. Monad m => Int -> Int -> DSL (edgeSymbolSize :: I | i) m

#buildLinks Source

buildLinks :: forall m i. Monad m => (CommandsT LinksI m) ~> (CommandsT (links :: I | i) m)

#addLink Source

addLink :: forall m i. Monad m => (CommandsT LinkI m) ~> (CommandsT (link :: I | i) m)

#links Source

links :: forall m i. Monad m => Array { source :: String, target :: String } -> DSL (links :: I | i) m

#edgeLabel Source

edgeLabel :: forall m i. Monad m => (CommandsT EdgeLabelI m) ~> (CommandsT (edgeLabel :: I | i) m)

#normalEdgeLabel Source

normalEdgeLabel :: forall m i. Monad m => (CommandsT EdgeLabelInnerI m) ~> (CommandsT (normal :: R EdgeLabelInnerI | i) m)

#emphasisEdgeLabel Source

emphasisEdgeLabel :: forall m i. Monad m => (CommandsT EdgeLabelInnerI m) ~> (CommandsT (emphasis :: R EdgeLabelInnerI | i) m)

#x Source

x :: forall m i. Monad m => Number -> DSL (x :: I | i) m

#y Source

y :: forall m i. Monad m => Number -> DSL (y :: I | i) m

#curveness Source

curveness :: forall m i. Monad m => Number -> DSL (curveness :: I | i) m

#symbolSizes Source

symbolSizes :: forall m i. Monad m => Int -> Int -> DSL (symbolSize :: I | i) m

#symbolSizeArrFunc Source

symbolSizeArrFunc :: forall m i. Monad m => (Array Number -> Number) -> DSL (symbolSize :: I | i) m

#sourceIx Source

sourceIx :: forall m i. Monad m => Int -> DSL (source :: I | i) m

#targetIx Source

targetIx :: forall m i. Monad m => Int -> DSL (target :: I | i) m

#sourceName Source

sourceName :: forall m i. Monad m => String -> DSL (source :: I | i) m

#targetName Source

targetName :: forall m i. Monad m => String -> DSL (target :: I | i) m

#subtargetName Source

subtargetName :: forall m i. Monad m => String -> DSL (subtarget :: I | i) m

#layoutNone Source

layoutNone :: forall m i. Monad m => DSL (layout :: I | i) m

#layoutCircular Source

layoutCircular :: forall m i. Monad m => DSL (layout :: I | i) m

#layoutForce Source

layoutForce :: forall m i. Monad m => DSL (layout :: I | i) m

#missingSeries Source

missingSeries :: forall m i. Monad m => DSL (missing :: I | i) m

#missingItem Source

missingItem :: forall m i. Monad m => DSL (item :: I | i) m

#rotate Source

rotate :: forall m i. Monad m => Number -> DSL (rotate :: I | i) m

#fontFamily Source

fontFamily :: forall m i. Monad m => String -> DSL (fontFamily :: I | i) m

#addParallelAxis Source

addParallelAxis :: forall m i. Monad m => (CommandsT ParallelAxisI m) ~> (CommandsT (addParallelAxis :: I | i) m)

#parallelAxes Source

parallelAxes :: forall m i. Monad m => (CommandsT ParallelAxesI m) ~> (CommandsT (parallelAxis :: I | i) m)

#parallelAxisDefault Source

parallelAxisDefault :: forall m i. Monad m => (CommandsT ParallelAxisI m) ~> (CommandsT (parallelAxisDefault :: I | i) m)

#yAxes Source

yAxes :: forall m i. Monad m => (CommandsT YAxesI m) ~> (CommandsT (yAxis :: I | i) m)

#xAxes Source

xAxes :: forall m i. Monad m => (CommandsT XAxesI m) ~> (CommandsT (xAxis :: I | i) m)

#addYAxis Source

addYAxis :: forall m i. Monad m => (CommandsT YAxisI m) ~> (CommandsT (addYAxis :: I | i) m)

#addXAxis Source

addXAxis :: forall m i. Monad m => (CommandsT XAxisI m) ~> (CommandsT (addXAxis :: I | i) m)

#interval Source

interval :: forall m i. Monad m => Int -> DSL (interval :: I | i) m

#lineAxisPointer Source

lineAxisPointer :: forall m i. Monad m => DSL (axisPointerType :: I | i) m

#crossAxisPointer Source

crossAxisPointer :: forall m i. Monad m => DSL (axisPointerType :: I | i) m

#solidLine Source

solidLine :: forall m i. Monad m => DSL (lineType :: I | i) m

#dashedLine Source

dashedLine :: forall m i. Monad m => DSL (lineType :: I | i) m

#dottedLine Source

dottedLine :: forall m i. Monad m => DSL (lineType :: I | i) m

#widthNum Source

widthNum :: forall m i. Monad m => Number -> DSL (width :: I | i) m

#crossStyle Source

crossStyle :: forall m i. Monad m => (CommandsT CrossStyleI m) ~> (CommandsT (crossStyle :: I | i) m)

#normal Source

normal :: forall m i p. Monad m => (CommandsT p m) ~> (CommandsT (normal :: R p | i) m)

#lineStyle Source

lineStyle :: forall m i ρ. Monad m => (CommandsT ρ m) ~> (CommandsT (lineStyle :: R ρ | i) m)

#areaStyle Source

areaStyle :: forall m i ρ. Monad m => (CommandsT ρ m) ~> (CommandsT (areaStyle :: R ρ | i) m)

#emphasis Source

emphasis :: forall m i ρ. Monad m => (CommandsT ρ m) ~> (CommandsT (emphasis :: R ρ | i) m)

#heightPixelOrPercent Source

heightPixelOrPercent :: forall m i. Monad m => PixelOrPercent -> DSL (height :: I | i) m

#heightPct Source

heightPct :: forall m i. Monad m => Number -> DSL (width :: I | i) m

#widthPixelOrPercent Source

widthPixelOrPercent :: forall m i. Monad m => PixelOrPercent -> DSL (width :: I | i) m

#padding Source

padding :: forall m i. Monad m => Number -> DSL (padding :: I | i) m

#enterable Source

enterable :: forall m i. Monad m => Boolean -> DSL (enterable :: I | i) m

#transitionDuration Source

transitionDuration :: forall m i. Monad m => Number -> DSL (transitionDuration :: I | i) m

#extraCssText Source

extraCssText :: forall m i. Monad m => String -> DSL (extraCssText :: I | i) m

#gridIndex Source

gridIndex :: forall m i. Monad m => Int -> DSL (gridIndex :: I | i) m

#radarIndex Source

radarIndex :: forall m i. Monad m => Number -> DSL (radarIndex :: I | i) m

#parallelIndex Source

parallelIndex :: forall m i. Monad m => Int -> DSL (parallelIndex :: I | i) m

#treeMapNodeId Source

treeMapNodeId :: forall m i. Monad m => String -> DSL (treeMapNodeId :: I | i) m

#visualDimension Source

visualDimension :: forall m i. Monad m => Int -> DSL (visualDimension :: I | i) m

#visibleMin Source

visibleMin :: forall m i. Monad m => Number -> DSL (visibleMin :: I | i) m

#childVisibleMin Source

childVisibleMin :: forall m i. Monad m => Number -> DSL (childVisibleMin :: I | i) m

#category Source

category :: forall m i. Monad m => Int -> DSL (category :: I | i) m

#coords Source

coords :: forall m f i. Monad m => Foldable f => f Coord -> DSL (coords :: I | i) m

#valueIndex Source

valueIndex :: forall m i. Monad m => Number -> DSL (valueIndex :: I | i) m

#valueDim Source

valueDim :: forall m i. Monad m => String -> DSL (valueDim :: I | i) m

#markType Source

markType :: forall m i. Monad m => String -> DSL (markType :: I | i) m

#margin Source

margin :: forall m i. Monad m => Int -> DSL (margin :: I | i) m

#markLine Source

markLine :: forall m i. Monad m => (CommandsT MarkLineI m) ~> (CommandsT (markLine :: I | i) m)

#markPoint Source

markPoint :: forall m i. Monad m => (CommandsT MarkPointI m) ~> (CommandsT (markPoint :: I | i) m)

#markArea Source

markArea :: forall m i. Monad m => (CommandsT MarkAreaI m) ~> (CommandsT (markArea :: I | i) m)

#repulsion Source

repulsion :: forall m i. Monad m => Number -> DSL (repulsion :: I | i) m

#gravity Source

gravity :: forall m i. Monad m => Number -> DSL (gravity :: I | i) m

#edgeLength Source

edgeLength :: forall m i. Monad m => Number -> DSL (edgeLength :: I | i) m

#edgeLengths Source

edgeLengths :: forall m i. Monad m => Number -> Number -> DSL (edgeLength :: I | i) m

#layoutAnimation Source

layoutAnimation :: forall m i. Monad m => Boolean -> DSL (layoutAnimation :: I | i) m

#circular Source

circular :: forall m i. Monad m => (CommandsT CircularI m) ~> (CommandsT (circular :: I | i) m)

#rotateLabel Source

rotateLabel :: forall m i. Monad m => Boolean -> DSL (rotateLabel :: I | i) m

#force Source

force :: forall m i. Monad m => (CommandsT ForceI m) ~> (CommandsT (force :: I | i) m)

#buildCategories Source

buildCategories :: forall m i. Monad m => (CommandsT CategoriesI m) ~> (CommandsT (categories :: I | i) m)

#addCategory Source

addCategory :: forall m i. Monad m => (CommandsT CategoryI m) ~> (CommandsT (category :: I | i) m)

#colorSource Source

colorSource :: forall m i. Monad m => DSL (color :: I | i) m

#colorTarget Source

colorTarget :: forall m i. Monad m => DSL (color :: I | i) m

#buildCoord Source

buildCoord :: forall m i. Monad m => (CommandsT PointI m) ~> (CommandsT (coord :: I | i) m)

#buildCenter Source

buildCenter :: forall m i. Monad m => (CommandsT PointI m) ~> (CommandsT (center :: I | i) m)

#buildRadius Source

buildRadius :: forall m i. Monad m => (CommandsT RadiusI m) ~> (CommandsT (radius :: I | i) m)

#setStart Source

setStart :: forall m i. Monad m => (CommandsT DimensionI m) ~> (CommandsT (start :: I | i) m)

#setEnd Source

setEnd :: forall m i. Monad m => (CommandsT DimensionI m) ~> (CommandsT (end :: I | i) m)

#setBarWidth Source

setBarWidth :: forall m i. Monad m => (CommandsT DimensionI m) ~> (CommandsT (barWidth :: I | i) m)

#setX Source

setX :: forall m i. Monad m => (CommandsT DimensionI m) ~> (CommandsT (x :: I | i) m)

#setY Source

setY :: forall m i. Monad m => (CommandsT DimensionI m) ~> (CommandsT (y :: I | i) m)

#setZ Source

setZ :: forall m i. Monad m => (CommandsT DimensionI m) ~> (CommandsT (z :: I | i) m)

#coordXIx Source

coordXIx :: forall m i. Monad m => Int -> DSL (x :: I | i) m

#coordXValue Source

coordXValue :: forall m i. Monad m => String -> DSL (x :: I | i) m

#coordY Source

coordY :: forall m i. Monad m => String -> DSL (y :: I | i) m

#pixels Source

pixels :: forall m i. Monad m => Int -> DSL (pixels :: I | i) m

#percents Source

percents :: forall m i. Monad m => Number -> DSL (percents :: I | i) m

#setWidth Source

setWidth :: forall m i. Monad m => (CommandsT DimensionI m) ~> (CommandsT (width :: I | i) m)

#buildGaugeRadius Source

buildGaugeRadius :: forall m i. Monad m => (CommandsT DimensionI m) ~> (CommandsT (gaugeRadius :: I | i) m)

#buildOffsetCenter Source

buildOffsetCenter :: forall m i. Monad m => (CommandsT PointI m) ~> (CommandsT (offsetCenter :: I | i) m)

#containLabel Source

containLabel :: forall m i. Monad m => Boolean -> DSL (containLabel :: I | i) m

#polarCoordinateSystem Source

polarCoordinateSystem :: forall m i. Monad m => DSL (coordinateSystem :: I | i) m

#cartesianCoordinateSystem Source

cartesianCoordinateSystem :: forall m i. Monad m => DSL (coordinateSystem :: I | i) m

#geoCoordinateSystem Source

geoCoordinateSystem :: forall m i. Monad m => DSL (coordinateSystem :: I | i) m

#calendarCoordinateSystem Source

calendarCoordinateSystem :: forall m i. Monad m => DSL (coordinateSystem :: I | i) m

#dim Source

dim :: forall m i. Monad m => Int -> DSL (dim :: I | i) m

#nameLocationStart Source

nameLocationStart :: forall m i. Monad m => DSL (nameLocation :: I | i) m

#nameLocationEnd Source

nameLocationEnd :: forall m i. Monad m => DSL (nameLocation :: I | i) m

#nameLocationMiddle Source

nameLocationMiddle :: forall m i. Monad m => DSL (nameLocation :: I | i) m

#nameTextStyle Source

nameTextStyle :: forall m i. Monad m => (CommandsT TextStyleI m) ~> (CommandsT (nameTextStyle :: I | i) m)

#nameRotate Source

nameRotate :: forall m i. Monad m => Number -> DSL (nameRotate :: I | i) m

#buildCellSize Source

buildCellSize :: forall m i. Monad m => (CommandsT ValuesI m) ~> (CommandsT (cellSize :: I | i) m)

#buildRange Source

buildRange :: forall m i. Monad m => (CommandsT ValuesI m) ~> (CommandsT (range :: I | i) m)

#addDateValue Source

addDateValue :: forall m i. Monad m => Date -> DSL (addValue :: I | i) m

#useUTC Source

useUTC :: forall m i. Monad m => Boolean -> DSL (useUTC :: I | i) m

Modules: ECharts; ECharts.Chart; ECharts.Commands; ECharts.Event; ECharts.Internal; ECharts.Monad; ECharts.Theme; ECharts.Types; ECharts.Types.Phantom