...
Documentation
Documentation

# Package chart

## Overview ▹

## Overview ▾

## Index ▹

## Index ▾

### Package files

CT_Area3DChart.go CT_AreaChart.go CT_AreaSer.go CT_AxDataSource.go CT_AxDataSourceChoice.go CT_AxPos.go CT_AxisUnit.go CT_BandFmt.go CT_BandFmts.go CT_Bar3DChart.go CT_BarChart.go CT_BarDir.go CT_BarGrouping.go CT_BarSer.go CT_Boolean.go CT_BubbleChart.go CT_BubbleScale.go CT_BubbleSer.go CT_BuiltInUnit.go CT_CatAx.go CT_Chart.go CT_ChartLines.go CT_ChartSpace.go CT_CrossBetween.go CT_Crosses.go CT_CustSplit.go CT_DLbl.go CT_DLblChoice.go CT_DLblPos.go CT_DLbls.go CT_DLblsChoice.go CT_DPt.go CT_DTable.go CT_DateAx.go CT_DepthPercent.go CT_DispBlanksAs.go CT_DispUnits.go CT_DispUnitsChoice.go CT_DispUnitsLbl.go CT_Double.go CT_DoughnutChart.go CT_ErrBarType.go CT_ErrBars.go CT_ErrDir.go CT_ErrValType.go CT_Extension.go CT_ExtensionList.go CT_ExternalData.go CT_FirstSliceAng.go CT_GapAmount.go CT_Grouping.go CT_HPercent.go CT_HeaderFooter.go CT_HoleSize.go CT_Layout.go CT_LayoutMode.go CT_LayoutTarget.go CT_LblAlgn.go CT_LblOffset.go CT_Legend.go CT_LegendEntry.go CT_LegendEntryChoice.go CT_LegendPos.go CT_Line3DChart.go CT_LineChart.go CT_LineSer.go CT_LogBase.go CT_Lvl.go CT_ManualLayout.go CT_Marker.go CT_MarkerSize.go CT_MarkerStyle.go CT_MultiLvlStrData.go CT_MultiLvlStrRef.go CT_NumData.go CT_NumDataSource.go CT_NumDataSourceChoice.go CT_NumFmt.go CT_NumRef.go CT_NumVal.go CT_OfPieChart.go CT_OfPieType.go CT_Order.go CT_Orientation.go CT_Overlap.go CT_PageMargins.go CT_PageSetup.go CT_Period.go CT_Perspective.go CT_PictureFormat.go CT_PictureOptions.go CT_PictureStackUnit.go CT_Pie3DChart.go CT_PieChart.go CT_PieSer.go CT_PivotFmt.go CT_PivotFmts.go CT_PivotSource.go CT_PlotArea.go CT_PlotAreaChoice.go CT_PlotAreaChoice1.go CT_PrintSettings.go CT_Protection.go CT_RadarChart.go CT_RadarSer.go CT_RadarStyle.go CT_RelId.go CT_RotX.go CT_RotY.go CT_Scaling.go CT_ScatterChart.go CT_ScatterSer.go CT_ScatterStyle.go CT_SecondPieSize.go CT_SerAx.go CT_SerTx.go CT_SerTxChoice.go CT_Shape.go CT_SizeRepresents.go CT_Skip.go CT_SplitType.go CT_StockChart.go CT_StrData.go CT_StrRef.go CT_StrVal.go CT_Style.go CT_Surface.go CT_Surface3DChart.go CT_SurfaceChart.go CT_SurfaceSer.go CT_TextLanguageID.go CT_Thickness.go CT_TickLblPos.go CT_TickMark.go CT_TimeUnit.go CT_Title.go CT_Trendline.go CT_TrendlineLbl.go CT_TrendlineType.go CT_Tx.go CT_TxChoice.go CT_UnsignedInt.go CT_UpDownBar.go CT_UpDownBars.go CT_ValAx.go CT_View3D.go Chart.go ChartSpace.go EG_AreaChartShared.go EG_AxShared.go EG_AxSharedChoice.go EG_BarChartShared.go EG_DLblShared.go EG_LegendEntryData.go EG_LineChartShared.go EG_PieChartShared.go EG_SerShared.go EG_SurfaceChartShared.go Group_DLbl.go Group_DLbls.go ST_BubbleScale.go ST_DepthPercent.go ST_GapAmount.go ST_HPercent.go ST_HoleSize.go ST_LblOffset.go ST_Overlap.go ST_SecondPieSize.go ST_Thickness.go UserShapes.go common.go

## Constants

    const ST_BubbleScalePercentPattern = `0*(([0-9])|([1-9][0-9])|([1-2][0-9][0-9])|300)%`

    const ST_DepthPercentWithSymbolPattern = `0*(([2-9][0-9])|([1-9][0-9][0-9])|(1[0-9][0-9][0-9])|2000)%`

    const ST_GapAmountPercentPattern = `0*(([0-9])|([1-9][0-9])|([1-4][0-9][0-9])|500)%`

    const ST_HPercentWithSymbolPattern = `0*(([5-9])|([1-9][0-9])|([1-4][0-9][0-9])|500)%`

    const ST_HoleSizePercentPattern = `0*([1-9]|([1-8][0-9])|90)%`

    const ST_LblOffsetPercentPattern = `0*(([0-9])|([1-9][0-9])|([1-9][0-9][0-9])|1000)%`

    const ST_OverlapPercentPattern = `(-?0*(([0-9])|([1-9][0-9])|100))%`

    const ST_SecondPieSizePercentPattern = `0*(([5-9])|([1-9][0-9])|(1[0-9][0-9])|200)%`

    const ST_ThicknessPercentPattern = `([0-9]+)%`

## Variables

    var ST_BubbleScalePercentPatternRe = regexp.MustCompile(ST_BubbleScalePercentPattern)

    var ST_DepthPercentWithSymbolPatternRe = regexp.MustCompile(ST_DepthPercentWithSymbolPattern)

    var ST_GapAmountPercentPatternRe = regexp.MustCompile(ST_GapAmountPercentPattern)

    var ST_HPercentWithSymbolPatternRe = regexp.MustCompile(ST_HPercentWithSymbolPattern)

    var ST_HoleSizePercentPatternRe = regexp.MustCompile(ST_HoleSizePercentPattern)

    var ST_LblOffsetPercentPatternRe = regexp.MustCompile(ST_LblOffsetPercentPattern)

    var ST_OverlapPercentPatternRe = regexp.MustCompile(ST_OverlapPercentPattern)

    var ST_SecondPieSizePercentPatternRe = regexp.MustCompile(ST_SecondPieSizePercentPattern)

    var ST_ThicknessPercentPatternRe = regexp.MustCompile(ST_ThicknessPercentPattern)

## type Any ¶

    type Any interface {
        MarshalXML(e *xml.Encoder, start xml.StartElement) error
        UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
    }

## type CT_Area3DChart ¶

    type CT_Area3DChart struct {
        // Grouping
        Grouping   *CT_Grouping
        VaryColors *CT_Boolean
        // Area Chart Series
        Ser []*CT_AreaSer
        // Data Labels
        DLbls *CT_DLbls
        // Drop Lines
        DropLines *CT_ChartLines
        // Gap Depth
        GapDepth *CT_GapAmount
        // Axis ID
        AxId []*CT_UnsignedInt
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_Area3DChart ¶

    func NewCT_Area3DChart() *CT_Area3DChart

### func (*CT_Area3DChart) MarshalXML ¶

    func (m *CT_Area3DChart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Area3DChart) UnmarshalXML ¶

    func (m *CT_Area3DChart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Area3DChart) Validate ¶

    func (m *CT_Area3DChart) Validate() error

Validate validates the CT_Area3DChart and its children

### func (*CT_Area3DChart) ValidateWithPath ¶

    func (m *CT_Area3DChart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Area3DChart and its children, prefixing error messages with path

## type CT_AreaChart ¶

    type CT_AreaChart struct {
        // Grouping
        Grouping   *CT_Grouping
        VaryColors *CT_Boolean
        // Area Chart Series
        Ser []*CT_AreaSer
        // Data Labels
        DLbls *CT_DLbls
        // Drop Lines
        DropLines *CT_ChartLines
        // Axis ID
        AxId []*CT_UnsignedInt
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_AreaChart ¶

    func NewCT_AreaChart() *CT_AreaChart

### func (*CT_AreaChart) MarshalXML ¶

    func (m *CT_AreaChart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_AreaChart) UnmarshalXML ¶

    func (m *CT_AreaChart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_AreaChart) Validate ¶

    func (m *CT_AreaChart) Validate() error

Validate validates the CT_AreaChart and its children

### func (*CT_AreaChart) ValidateWithPath ¶

    func (m *CT_AreaChart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_AreaChart and its children, prefixing error messages with path

## type CT_AreaSer ¶

    type CT_AreaSer struct {
        // Index
        Idx *CT_UnsignedInt
        // Order
        Order *CT_UnsignedInt
        // Series Text
        Tx             *CT_SerTx
        SpPr           *dml.CT_ShapeProperties
        PictureOptions *CT_PictureOptions
        // Data Point
        DPt []*CT_DPt
        // Data Labels
        DLbls     *CT_DLbls
        Trendline []*CT_Trendline
        // Error Bars
        ErrBars []*CT_ErrBars
        // Category Axis Data
        Cat *CT_AxDataSource
        // Values
        Val *CT_NumDataSource
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_AreaSer ¶

    func NewCT_AreaSer() *CT_AreaSer

### func (*CT_AreaSer) MarshalXML ¶

    func (m *CT_AreaSer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_AreaSer) UnmarshalXML ¶

    func (m *CT_AreaSer) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_AreaSer) Validate ¶

    func (m *CT_AreaSer) Validate() error

Validate validates the CT_AreaSer and its children

### func (*CT_AreaSer) ValidateWithPath ¶

    func (m *CT_AreaSer) ValidateWithPath(path string) error

ValidateWithPath validates the CT_AreaSer and its children, prefixing error messages with path

## type CT_AxDataSource ¶

    type CT_AxDataSource struct {
        AxDataSourceChoice *CT_AxDataSourceChoice
    }

### func NewCT_AxDataSource ¶

    func NewCT_AxDataSource() *CT_AxDataSource

### func (*CT_AxDataSource) MarshalXML ¶

    func (m *CT_AxDataSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_AxDataSource) UnmarshalXML ¶

    func (m *CT_AxDataSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_AxDataSource) Validate ¶

    func (m *CT_AxDataSource) Validate() error

Validate validates the CT_AxDataSource and its children

### func (*CT_AxDataSource) ValidateWithPath ¶

    func (m *CT_AxDataSource) ValidateWithPath(path string) error

ValidateWithPath validates the CT_AxDataSource and its children, prefixing error messages with path

## type CT_AxDataSourceChoice ¶

    type CT_AxDataSourceChoice struct {
        MultiLvlStrRef *CT_MultiLvlStrRef
        NumRef         *CT_NumRef
        NumLit         *CT_NumData
        StrRef         *CT_StrRef
        StrLit         *CT_StrData
    }

### func NewCT_AxDataSourceChoice ¶

    func NewCT_AxDataSourceChoice() *CT_AxDataSourceChoice

### func (*CT_AxDataSourceChoice) MarshalXML ¶

    func (m *CT_AxDataSourceChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_AxDataSourceChoice) UnmarshalXML ¶

    func (m *CT_AxDataSourceChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_AxDataSourceChoice) Validate ¶

    func (m *CT_AxDataSourceChoice) Validate() error

Validate validates the CT_AxDataSourceChoice and its children

### func (*CT_AxDataSourceChoice) ValidateWithPath ¶

    func (m *CT_AxDataSourceChoice) ValidateWithPath(path string) error

ValidateWithPath validates the CT_AxDataSourceChoice and its children, prefixing error messages with path

## type CT_AxPos ¶

    type CT_AxPos struct {
        // Axis Position Value
        ValAttr ST_AxPos
    }

### func NewCT_AxPos ¶

    func NewCT_AxPos() *CT_AxPos

### func (*CT_AxPos) MarshalXML ¶

    func (m *CT_AxPos) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_AxPos) UnmarshalXML ¶

    func (m *CT_AxPos) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_AxPos) Validate ¶

    func (m *CT_AxPos) Validate() error

Validate validates the CT_AxPos and its children

### func (*CT_AxPos) ValidateWithPath ¶

    func (m *CT_AxPos) ValidateWithPath(path string) error

ValidateWithPath validates the CT_AxPos and its children, prefixing error messages with path

## type CT_AxisUnit ¶

    type CT_AxisUnit struct {
        // Major Unit Value
        ValAttr float64
    }

### func NewCT_AxisUnit ¶

    func NewCT_AxisUnit() *CT_AxisUnit

### func (*CT_AxisUnit) MarshalXML ¶

    func (m *CT_AxisUnit) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_AxisUnit) UnmarshalXML ¶

    func (m *CT_AxisUnit) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_AxisUnit) Validate ¶

    func (m *CT_AxisUnit) Validate() error

Validate validates the CT_AxisUnit and its children

### func (*CT_AxisUnit) ValidateWithPath ¶

    func (m *CT_AxisUnit) ValidateWithPath(path string) error

ValidateWithPath validates the CT_AxisUnit and its children, prefixing error messages with path

## type CT_BandFmt ¶

    type CT_BandFmt struct {
        Idx  *CT_UnsignedInt
        SpPr *dml.CT_ShapeProperties
    }

### func NewCT_BandFmt ¶

    func NewCT_BandFmt() *CT_BandFmt

### func (*CT_BandFmt) MarshalXML ¶

    func (m *CT_BandFmt) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_BandFmt) UnmarshalXML ¶

    func (m *CT_BandFmt) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_BandFmt) Validate ¶

    func (m *CT_BandFmt) Validate() error

Validate validates the CT_BandFmt and its children

### func (*CT_BandFmt) ValidateWithPath ¶

    func (m *CT_BandFmt) ValidateWithPath(path string) error

ValidateWithPath validates the CT_BandFmt and its children, prefixing error messages with path

## type CT_BandFmts ¶

    type CT_BandFmts struct {
        // Band Format
        BandFmt []*CT_BandFmt
    }

### func NewCT_BandFmts ¶

    func NewCT_BandFmts() *CT_BandFmts

### func (*CT_BandFmts) MarshalXML ¶

    func (m *CT_BandFmts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_BandFmts) UnmarshalXML ¶

    func (m *CT_BandFmts) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_BandFmts) Validate ¶

    func (m *CT_BandFmts) Validate() error

Validate validates the CT_BandFmts and its children

### func (*CT_BandFmts) ValidateWithPath ¶

    func (m *CT_BandFmts) ValidateWithPath(path string) error

ValidateWithPath validates the CT_BandFmts and its children, prefixing error messages with path

## type CT_Bar3DChart ¶

    type CT_Bar3DChart struct {
        // Bar Direction
        BarDir *CT_BarDir
        // Bar Grouping
        Grouping   *CT_BarGrouping
        VaryColors *CT_Boolean
        // Bar Chart Series
        Ser []*CT_BarSer
        // Data Labels
        DLbls *CT_DLbls
        // Gap Width
        GapWidth *CT_GapAmount
        // Gap Depth
        GapDepth *CT_GapAmount
        Shape    *CT_Shape
        // Axis ID
        AxId []*CT_UnsignedInt
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_Bar3DChart ¶

    func NewCT_Bar3DChart() *CT_Bar3DChart

### func (*CT_Bar3DChart) MarshalXML ¶

    func (m *CT_Bar3DChart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Bar3DChart) UnmarshalXML ¶

    func (m *CT_Bar3DChart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Bar3DChart) Validate ¶

    func (m *CT_Bar3DChart) Validate() error

Validate validates the CT_Bar3DChart and its children

### func (*CT_Bar3DChart) ValidateWithPath ¶

    func (m *CT_Bar3DChart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Bar3DChart and its children, prefixing error messages with path

## type CT_BarChart ¶

    type CT_BarChart struct {
        // Bar Direction
        BarDir *CT_BarDir
        // Bar Grouping
        Grouping   *CT_BarGrouping
        VaryColors *CT_Boolean
        // Bar Chart Series
        Ser []*CT_BarSer
        // Data Labels
        DLbls *CT_DLbls
        // Gap Width
        GapWidth *CT_GapAmount
        // Overlap
        Overlap *CT_Overlap
        // Series Lines
        SerLines []*CT_ChartLines
        // Axis ID
        AxId []*CT_UnsignedInt
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_BarChart ¶

    func NewCT_BarChart() *CT_BarChart

### func (*CT_BarChart) MarshalXML ¶

    func (m *CT_BarChart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_BarChart) UnmarshalXML ¶

    func (m *CT_BarChart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_BarChart) Validate ¶

    func (m *CT_BarChart) Validate() error

Validate validates the CT_BarChart and its children

### func (*CT_BarChart) ValidateWithPath ¶

    func (m *CT_BarChart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_BarChart and its children, prefixing error messages with path

## type CT_BarDir ¶

    type CT_BarDir struct {
        // Bar Direction Value
        ValAttr ST_BarDir
    }

### func NewCT_BarDir ¶

    func NewCT_BarDir() *CT_BarDir

### func (*CT_BarDir) MarshalXML ¶

    func (m *CT_BarDir) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_BarDir) UnmarshalXML ¶

    func (m *CT_BarDir) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_BarDir) Validate ¶

    func (m *CT_BarDir) Validate() error

Validate validates the CT_BarDir and its children

### func (*CT_BarDir) ValidateWithPath ¶

    func (m *CT_BarDir) ValidateWithPath(path string) error

ValidateWithPath validates the CT_BarDir and its children, prefixing error messages with path

## type CT_BarGrouping ¶

    type CT_BarGrouping struct {
        // Bar Grouping Value
        ValAttr ST_BarGrouping
    }

### func NewCT_BarGrouping ¶

    func NewCT_BarGrouping() *CT_BarGrouping

### func (*CT_BarGrouping) MarshalXML ¶

    func (m *CT_BarGrouping) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_BarGrouping) UnmarshalXML ¶

    func (m *CT_BarGrouping) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_BarGrouping) Validate ¶

    func (m *CT_BarGrouping) Validate() error

Validate validates the CT_BarGrouping and its children

### func (*CT_BarGrouping) ValidateWithPath ¶

    func (m *CT_BarGrouping) ValidateWithPath(path string) error

ValidateWithPath validates the CT_BarGrouping and its children, prefixing error messages with path

## type CT_BarSer ¶

    type CT_BarSer struct {
        // Index
        Idx *CT_UnsignedInt
        // Order
        Order *CT_UnsignedInt
        // Series Text
        Tx   *CT_SerTx
        SpPr *dml.CT_ShapeProperties
        // Invert if Negative
        InvertIfNegative *CT_Boolean
        PictureOptions   *CT_PictureOptions
        // Data Point
        DPt []*CT_DPt
        // Data Labels
        DLbls *CT_DLbls
        // Trendlines
        Trendline []*CT_Trendline
        // Error Bars
        ErrBars *CT_ErrBars
        // Category Axis Data
        Cat *CT_AxDataSource
        Val *CT_NumDataSource
        // Shape
        Shape *CT_Shape
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_BarSer ¶

    func NewCT_BarSer() *CT_BarSer

### func (*CT_BarSer) MarshalXML ¶

    func (m *CT_BarSer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_BarSer) UnmarshalXML ¶

    func (m *CT_BarSer) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_BarSer) Validate ¶

    func (m *CT_BarSer) Validate() error

Validate validates the CT_BarSer and its children

### func (*CT_BarSer) ValidateWithPath ¶

    func (m *CT_BarSer) ValidateWithPath(path string) error

ValidateWithPath validates the CT_BarSer and its children, prefixing error messages with path

## type CT_Boolean ¶

    type CT_Boolean struct {
        // Boolean Value
        ValAttr *bool
    }

### func NewCT_Boolean ¶

    func NewCT_Boolean() *CT_Boolean

### func (*CT_Boolean) MarshalXML ¶

    func (m *CT_Boolean) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Boolean) UnmarshalXML ¶

    func (m *CT_Boolean) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Boolean) Validate ¶

    func (m *CT_Boolean) Validate() error

Validate validates the CT_Boolean and its children

### func (*CT_Boolean) ValidateWithPath ¶

    func (m *CT_Boolean) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Boolean and its children, prefixing error messages with path

## type CT_BubbleChart ¶

    type CT_BubbleChart struct {
        VaryColors *CT_Boolean
        // Bubble Chart Series
        Ser []*CT_BubbleSer
        // Data Labels
        DLbls *CT_DLbls
        // 3D Bubble
        Bubble3D *CT_Boolean
        // Bubble Scale
        BubbleScale *CT_BubbleScale
        // Show Negative Bubbles
        ShowNegBubbles *CT_Boolean
        // Size Represents
        SizeRepresents *CT_SizeRepresents
        // Axis ID
        AxId []*CT_UnsignedInt
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_BubbleChart ¶

    func NewCT_BubbleChart() *CT_BubbleChart

### func (*CT_BubbleChart) MarshalXML ¶

    func (m *CT_BubbleChart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_BubbleChart) UnmarshalXML ¶

    func (m *CT_BubbleChart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_BubbleChart) Validate ¶

    func (m *CT_BubbleChart) Validate() error

Validate validates the CT_BubbleChart and its children

### func (*CT_BubbleChart) ValidateWithPath ¶

    func (m *CT_BubbleChart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_BubbleChart and its children, prefixing error messages with path

## type CT_BubbleScale ¶

    type CT_BubbleScale struct {
        // Bubble Scale Value
        ValAttr *ST_BubbleScale
    }

### func NewCT_BubbleScale ¶

    func NewCT_BubbleScale() *CT_BubbleScale

### func (*CT_BubbleScale) MarshalXML ¶

    func (m *CT_BubbleScale) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_BubbleScale) UnmarshalXML ¶

    func (m *CT_BubbleScale) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_BubbleScale) Validate ¶

    func (m *CT_BubbleScale) Validate() error

Validate validates the CT_BubbleScale and its children

### func (*CT_BubbleScale) ValidateWithPath ¶

    func (m *CT_BubbleScale) ValidateWithPath(path string) error

ValidateWithPath validates the CT_BubbleScale and its children, prefixing error messages with path

## type CT_BubbleSer ¶

    type CT_BubbleSer struct {
        // Index
        Idx *CT_UnsignedInt
        // Order
        Order *CT_UnsignedInt
        // Series Text
        Tx   *CT_SerTx
        SpPr *dml.CT_ShapeProperties
        // Invert if Negative
        InvertIfNegative *CT_Boolean
        // Data Point
        DPt []*CT_DPt
        // Data Labels
        DLbls     *CT_DLbls
        Trendline []*CT_Trendline
        // Error Bars
        ErrBars []*CT_ErrBars
        // X Values
        XVal *CT_AxDataSource
        // Y Values
        YVal *CT_NumDataSource
        // Bubble Size
        BubbleSize *CT_NumDataSource
        // 3D Bubble
        Bubble3D *CT_Boolean
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_BubbleSer ¶

    func NewCT_BubbleSer() *CT_BubbleSer

### func (*CT_BubbleSer) MarshalXML ¶

    func (m *CT_BubbleSer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_BubbleSer) UnmarshalXML ¶

    func (m *CT_BubbleSer) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_BubbleSer) Validate ¶

    func (m *CT_BubbleSer) Validate() error

Validate validates the CT_BubbleSer and its children

### func (*CT_BubbleSer) ValidateWithPath ¶

    func (m *CT_BubbleSer) ValidateWithPath(path string) error

ValidateWithPath validates the CT_BubbleSer and its children, prefixing error messages with path

## type CT_BuiltInUnit ¶

    type CT_BuiltInUnit struct {
        // Built In Unit Value
        ValAttr ST_BuiltInUnit
    }

### func NewCT_BuiltInUnit ¶

    func NewCT_BuiltInUnit() *CT_BuiltInUnit

### func (*CT_BuiltInUnit) MarshalXML ¶

    func (m *CT_BuiltInUnit) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_BuiltInUnit) UnmarshalXML ¶

    func (m *CT_BuiltInUnit) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_BuiltInUnit) Validate ¶

    func (m *CT_BuiltInUnit) Validate() error

Validate validates the CT_BuiltInUnit and its children

### func (*CT_BuiltInUnit) ValidateWithPath ¶

    func (m *CT_BuiltInUnit) ValidateWithPath(path string) error

ValidateWithPath validates the CT_BuiltInUnit and its children, prefixing error messages with path

## type CT_CatAx ¶

    type CT_CatAx struct {
        // Axis ID
        AxId *CT_UnsignedInt
        // Scaling
        Scaling *CT_Scaling
        // Delete
        Delete *CT_Boolean
        // Axis Position
        AxPos *CT_AxPos
        // Major Gridlines
        MajorGridlines *CT_ChartLines
        // Minor Gridlines
        MinorGridlines *CT_ChartLines
        // Title
        Title *CT_Title
        // Number Format
        NumFmt *CT_NumFmt
        // Major Tick Mark
        MajorTickMark *CT_TickMark
        // Minor Tick Mark
        MinorTickMark *CT_TickMark
        // Tick Label Position
        TickLblPos *CT_TickLblPos
        SpPr       *dml.CT_ShapeProperties
        TxPr       *dml.CT_TextBody
        // Crossing Axis ID
        CrossAx        *CT_UnsignedInt
        AxSharedChoice *EG_AxSharedChoice
        // Automatic Category Axis
        Auto *CT_Boolean
        // Label Alignment
        LblAlgn *CT_LblAlgn
        // Label Offset
        LblOffset   *CT_LblOffset
        TickLblSkip *CT_Skip
        // Tick Mark Skip
        TickMarkSkip *CT_Skip
        // No Multi-level Labels
        NoMultiLvlLbl *CT_Boolean
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_CatAx ¶

    func NewCT_CatAx() *CT_CatAx

### func (*CT_CatAx) MarshalXML ¶

    func (m *CT_CatAx) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_CatAx) UnmarshalXML ¶

    func (m *CT_CatAx) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_CatAx) Validate ¶

    func (m *CT_CatAx) Validate() error

Validate validates the CT_CatAx and its children

### func (*CT_CatAx) ValidateWithPath ¶

    func (m *CT_CatAx) ValidateWithPath(path string) error

ValidateWithPath validates the CT_CatAx and its children, prefixing error messages with path

## type CT_Chart ¶

    type CT_Chart struct {
        Title *CT_Title
        // Auto Title Is Deleted
        AutoTitleDeleted *CT_Boolean
        // Pivot Formats
        PivotFmts *CT_PivotFmts
        // View In 3D
        View3D *CT_View3D
        // Floor
        Floor *CT_Surface
        // Side Wall
        SideWall *CT_Surface
        // Back Wall
        BackWall *CT_Surface
        // Plot Area
        PlotArea *CT_PlotArea
        // Legend
        Legend *CT_Legend
        // Plot Visible Only
        PlotVisOnly *CT_Boolean
        // Display Blanks As
        DispBlanksAs *CT_DispBlanksAs
        // Show Data Labels over Maximum
        ShowDLblsOverMax *CT_Boolean
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_Chart ¶

    func NewCT_Chart() *CT_Chart

### func (*CT_Chart) MarshalXML ¶

    func (m *CT_Chart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Chart) UnmarshalXML ¶

    func (m *CT_Chart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Chart) Validate ¶

    func (m *CT_Chart) Validate() error

Validate validates the CT_Chart and its children

### func (*CT_Chart) ValidateWithPath ¶

    func (m *CT_Chart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Chart and its children, prefixing error messages with path

## type CT_ChartLines ¶

    type CT_ChartLines struct {
        SpPr *dml.CT_ShapeProperties
    }

### func NewCT_ChartLines ¶

    func NewCT_ChartLines() *CT_ChartLines

### func (*CT_ChartLines) MarshalXML ¶

    func (m *CT_ChartLines) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_ChartLines) UnmarshalXML ¶

    func (m *CT_ChartLines) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_ChartLines) Validate ¶

    func (m *CT_ChartLines) Validate() error

Validate validates the CT_ChartLines and its children

### func (*CT_ChartLines) ValidateWithPath ¶

    func (m *CT_ChartLines) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ChartLines and its children, prefixing error messages with path

## type CT_ChartSpace ¶

    type CT_ChartSpace struct {
        // 1904 Date System
        Date1904 *CT_Boolean
        // Editing Language
        Lang *CT_TextLanguageID
        // Rounded Corners
        RoundedCorners *CT_Boolean
        // Style
        Style *CT_Style
        // Color Map Override
        ClrMapOvr *dml.CT_ColorMapping
        // Pivot Source
        PivotSource *CT_PivotSource
        // Protection
        Protection *CT_Protection
        // Chart
        Chart *CT_Chart
        // Shape Properties
        SpPr *dml.CT_ShapeProperties
        TxPr *dml.CT_TextBody
        // External Data Relationship
        ExternalData *CT_ExternalData
        // Print Settings
        PrintSettings *CT_PrintSettings
        // Reference to Chart Drawing Part
        UserShapes *CT_RelId
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_ChartSpace ¶

    func NewCT_ChartSpace() *CT_ChartSpace

### func (*CT_ChartSpace) MarshalXML ¶

    func (m *CT_ChartSpace) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_ChartSpace) UnmarshalXML ¶

    func (m *CT_ChartSpace) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_ChartSpace) Validate ¶

    func (m *CT_ChartSpace) Validate() error

Validate validates the CT_ChartSpace and its children

### func (*CT_ChartSpace) ValidateWithPath ¶

    func (m *CT_ChartSpace) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ChartSpace and its children, prefixing error messages with path

## type CT_CrossBetween ¶

    type CT_CrossBetween struct {
        // Cross Between Value
        ValAttr ST_CrossBetween
    }

### func NewCT_CrossBetween ¶

    func NewCT_CrossBetween() *CT_CrossBetween

### func (*CT_CrossBetween) MarshalXML ¶

    func (m *CT_CrossBetween) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_CrossBetween) UnmarshalXML ¶

    func (m *CT_CrossBetween) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_CrossBetween) Validate ¶

    func (m *CT_CrossBetween) Validate() error

Validate validates the CT_CrossBetween and its children

### func (*CT_CrossBetween) ValidateWithPath ¶

    func (m *CT_CrossBetween) ValidateWithPath(path string) error

ValidateWithPath validates the CT_CrossBetween and its children, prefixing error messages with path

## type CT_Crosses ¶

    type CT_Crosses struct {
        // Crosses Value
        ValAttr ST_Crosses
    }

### func NewCT_Crosses ¶

    func NewCT_Crosses() *CT_Crosses

### func (*CT_Crosses) MarshalXML ¶

    func (m *CT_Crosses) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Crosses) UnmarshalXML ¶

    func (m *CT_Crosses) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Crosses) Validate ¶

    func (m *CT_Crosses) Validate() error

Validate validates the CT_Crosses and its children

### func (*CT_Crosses) ValidateWithPath ¶

    func (m *CT_Crosses) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Crosses and its children, prefixing error messages with path

## type CT_CustSplit ¶

    type CT_CustSplit struct {
        // Second Pie Point
        SecondPiePt []*CT_UnsignedInt
    }

### func NewCT_CustSplit ¶

    func NewCT_CustSplit() *CT_CustSplit

### func (*CT_CustSplit) MarshalXML ¶

    func (m *CT_CustSplit) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_CustSplit) UnmarshalXML ¶

    func (m *CT_CustSplit) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_CustSplit) Validate ¶

    func (m *CT_CustSplit) Validate() error

Validate validates the CT_CustSplit and its children

### func (*CT_CustSplit) ValidateWithPath ¶

    func (m *CT_CustSplit) ValidateWithPath(path string) error

ValidateWithPath validates the CT_CustSplit and its children, prefixing error messages with path

## type CT_DLbl ¶

    type CT_DLbl struct {
        // Index
        Idx        *CT_UnsignedInt
        DLblChoice *CT_DLblChoice
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_DLbl ¶

    func NewCT_DLbl() *CT_DLbl

### func (*CT_DLbl) MarshalXML ¶

    func (m *CT_DLbl) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_DLbl) UnmarshalXML ¶

    func (m *CT_DLbl) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_DLbl) Validate ¶

    func (m *CT_DLbl) Validate() error

Validate validates the CT_DLbl and its children

### func (*CT_DLbl) ValidateWithPath ¶

    func (m *CT_DLbl) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DLbl and its children, prefixing error messages with path

## type CT_DLblChoice ¶

    type CT_DLblChoice struct {
        Delete *CT_Boolean
        // Layout
        Layout *CT_Layout
        Tx     *CT_Tx
        // Number Format
        NumFmt *CT_NumFmt
        SpPr   *dml.CT_ShapeProperties
        TxPr   *dml.CT_TextBody
        // Data Label Position
        DLblPos *CT_DLblPos
        // Show Legend Key
        ShowLegendKey *CT_Boolean
        // Show Value
        ShowVal *CT_Boolean
        // Show Category Name
        ShowCatName *CT_Boolean
        // Show Series Name
        ShowSerName *CT_Boolean
        // Show Percent
        ShowPercent *CT_Boolean
        // Show Bubble Size
        ShowBubbleSize *CT_Boolean
        // Separator
        Separator *string
    }

### func NewCT_DLblChoice ¶

    func NewCT_DLblChoice() *CT_DLblChoice

### func (*CT_DLblChoice) MarshalXML ¶

    func (m *CT_DLblChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_DLblChoice) UnmarshalXML ¶

    func (m *CT_DLblChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_DLblChoice) Validate ¶

    func (m *CT_DLblChoice) Validate() error

Validate validates the CT_DLblChoice and its children

### func (*CT_DLblChoice) ValidateWithPath ¶

    func (m *CT_DLblChoice) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DLblChoice and its children, prefixing error messages with path

## type CT_DLblPos ¶

    type CT_DLblPos struct {
        // Data Label Position Value
        ValAttr ST_DLblPos
    }

### func NewCT_DLblPos ¶

    func NewCT_DLblPos() *CT_DLblPos

### func (*CT_DLblPos) MarshalXML ¶

    func (m *CT_DLblPos) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_DLblPos) UnmarshalXML ¶

    func (m *CT_DLblPos) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_DLblPos) Validate ¶

    func (m *CT_DLblPos) Validate() error

Validate validates the CT_DLblPos and its children

### func (*CT_DLblPos) ValidateWithPath ¶

    func (m *CT_DLblPos) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DLblPos and its children, prefixing error messages with path

## type CT_DLbls ¶

    type CT_DLbls struct {
        // Data Label
        DLbl        []*CT_DLbl
        DLblsChoice *CT_DLblsChoice
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_DLbls ¶

    func NewCT_DLbls() *CT_DLbls

### func (*CT_DLbls) MarshalXML ¶

    func (m *CT_DLbls) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_DLbls) UnmarshalXML ¶

    func (m *CT_DLbls) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_DLbls) Validate ¶

    func (m *CT_DLbls) Validate() error

Validate validates the CT_DLbls and its children

### func (*CT_DLbls) ValidateWithPath ¶

    func (m *CT_DLbls) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DLbls and its children, prefixing error messages with path

## type CT_DLblsChoice ¶

    type CT_DLblsChoice struct {
        Delete *CT_Boolean
        // Number Format
        NumFmt *CT_NumFmt
        SpPr   *dml.CT_ShapeProperties
        TxPr   *dml.CT_TextBody
        // Data Label Position
        DLblPos *CT_DLblPos
        // Show Legend Key
        ShowLegendKey *CT_Boolean
        // Show Value
        ShowVal *CT_Boolean
        // Show Category Name
        ShowCatName *CT_Boolean
        // Show Series Name
        ShowSerName *CT_Boolean
        // Show Percent
        ShowPercent *CT_Boolean
        // Show Bubble Size
        ShowBubbleSize *CT_Boolean
        // Separator
        Separator *string
        // Show Leader Lines
        ShowLeaderLines *CT_Boolean
        // Leader Lines
        LeaderLines *CT_ChartLines
    }

### func NewCT_DLblsChoice ¶

    func NewCT_DLblsChoice() *CT_DLblsChoice

### func (*CT_DLblsChoice) MarshalXML ¶

    func (m *CT_DLblsChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_DLblsChoice) UnmarshalXML ¶

    func (m *CT_DLblsChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_DLblsChoice) Validate ¶

    func (m *CT_DLblsChoice) Validate() error

Validate validates the CT_DLblsChoice and its children

### func (*CT_DLblsChoice) ValidateWithPath ¶

    func (m *CT_DLblsChoice) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DLblsChoice and its children, prefixing error messages with path

## type CT_DPt ¶

    type CT_DPt struct {
        // Index
        Idx *CT_UnsignedInt
        // Invert if Negative
        InvertIfNegative *CT_Boolean
        // Marker
        Marker *CT_Marker
        // 3D Bubble
        Bubble3D *CT_Boolean
        // Explosion
        Explosion      *CT_UnsignedInt
        SpPr           *dml.CT_ShapeProperties
        PictureOptions *CT_PictureOptions
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_DPt ¶

    func NewCT_DPt() *CT_DPt

### func (*CT_DPt) MarshalXML ¶

    func (m *CT_DPt) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_DPt) UnmarshalXML ¶

    func (m *CT_DPt) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_DPt) Validate ¶

    func (m *CT_DPt) Validate() error

Validate validates the CT_DPt and its children

### func (*CT_DPt) ValidateWithPath ¶

    func (m *CT_DPt) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DPt and its children, prefixing error messages with path

## type CT_DTable ¶

    type CT_DTable struct {
        // Show Horizontal Border
        ShowHorzBorder *CT_Boolean
        // Show Vertical Border
        ShowVertBorder *CT_Boolean
        // Show Outline Border
        ShowOutline *CT_Boolean
        // Show Legend Keys
        ShowKeys *CT_Boolean
        SpPr     *dml.CT_ShapeProperties
        // Text Properties
        TxPr *dml.CT_TextBody
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_DTable ¶

    func NewCT_DTable() *CT_DTable

### func (*CT_DTable) MarshalXML ¶

    func (m *CT_DTable) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_DTable) UnmarshalXML ¶

    func (m *CT_DTable) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_DTable) Validate ¶

    func (m *CT_DTable) Validate() error

Validate validates the CT_DTable and its children

### func (*CT_DTable) ValidateWithPath ¶

    func (m *CT_DTable) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DTable and its children, prefixing error messages with path

## type CT_DateAx ¶

    type CT_DateAx struct {
        // Axis ID
        AxId *CT_UnsignedInt
        // Scaling
        Scaling *CT_Scaling
        // Delete
        Delete *CT_Boolean
        // Axis Position
        AxPos *CT_AxPos
        // Major Gridlines
        MajorGridlines *CT_ChartLines
        // Minor Gridlines
        MinorGridlines *CT_ChartLines
        // Title
        Title *CT_Title
        // Number Format
        NumFmt *CT_NumFmt
        // Major Tick Mark
        MajorTickMark *CT_TickMark
        // Minor Tick Mark
        MinorTickMark *CT_TickMark
        // Tick Label Position
        TickLblPos *CT_TickLblPos
        SpPr       *dml.CT_ShapeProperties
        TxPr       *dml.CT_TextBody
        // Crossing Axis ID
        CrossAx        *CT_UnsignedInt
        AxSharedChoice *EG_AxSharedChoice
        // Automatic Category Axis
        Auto *CT_Boolean
        // Label Offset
        LblOffset *CT_LblOffset
        // Base Time Unit
        BaseTimeUnit *CT_TimeUnit
        // Major Unit
        MajorUnit *CT_AxisUnit
        // Major Time Unit
        MajorTimeUnit *CT_TimeUnit
        // Minor Unit
        MinorUnit *CT_AxisUnit
        // Minor Time Unit
        MinorTimeUnit *CT_TimeUnit
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_DateAx ¶

    func NewCT_DateAx() *CT_DateAx

### func (*CT_DateAx) MarshalXML ¶

    func (m *CT_DateAx) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_DateAx) UnmarshalXML ¶

    func (m *CT_DateAx) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_DateAx) Validate ¶

    func (m *CT_DateAx) Validate() error

Validate validates the CT_DateAx and its children

### func (*CT_DateAx) ValidateWithPath ¶

    func (m *CT_DateAx) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DateAx and its children, prefixing error messages with path

## type CT_DepthPercent ¶

    type CT_DepthPercent struct {
        // Depth Percent Value
        ValAttr *ST_DepthPercent
    }

### func NewCT_DepthPercent ¶

    func NewCT_DepthPercent() *CT_DepthPercent

### func (*CT_DepthPercent) MarshalXML ¶

    func (m *CT_DepthPercent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_DepthPercent) UnmarshalXML ¶

    func (m *CT_DepthPercent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_DepthPercent) Validate ¶

    func (m *CT_DepthPercent) Validate() error

Validate validates the CT_DepthPercent and its children

### func (*CT_DepthPercent) ValidateWithPath ¶

    func (m *CT_DepthPercent) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DepthPercent and its children, prefixing error messages with path

## type CT_DispBlanksAs ¶

    type CT_DispBlanksAs struct {
        // Display Blanks As Value
        ValAttr ST_DispBlanksAs
    }

### func NewCT_DispBlanksAs ¶

    func NewCT_DispBlanksAs() *CT_DispBlanksAs

### func (*CT_DispBlanksAs) MarshalXML ¶

    func (m *CT_DispBlanksAs) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_DispBlanksAs) UnmarshalXML ¶

    func (m *CT_DispBlanksAs) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_DispBlanksAs) Validate ¶

    func (m *CT_DispBlanksAs) Validate() error

Validate validates the CT_DispBlanksAs and its children

### func (*CT_DispBlanksAs) ValidateWithPath ¶

    func (m *CT_DispBlanksAs) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DispBlanksAs and its children, prefixing error messages with path

## type CT_DispUnits ¶

    type CT_DispUnits struct {
        DispUnitsChoice *CT_DispUnitsChoice
        // Display Units Label
        DispUnitsLbl *CT_DispUnitsLbl
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_DispUnits ¶

    func NewCT_DispUnits() *CT_DispUnits

### func (*CT_DispUnits) MarshalXML ¶

    func (m *CT_DispUnits) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_DispUnits) UnmarshalXML ¶

    func (m *CT_DispUnits) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_DispUnits) Validate ¶

    func (m *CT_DispUnits) Validate() error

Validate validates the CT_DispUnits and its children

### func (*CT_DispUnits) ValidateWithPath ¶

    func (m *CT_DispUnits) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DispUnits and its children, prefixing error messages with path

## type CT_DispUnitsChoice ¶

    type CT_DispUnitsChoice struct {
        CustUnit    *CT_Double
        BuiltInUnit *CT_BuiltInUnit
    }

### func NewCT_DispUnitsChoice ¶

    func NewCT_DispUnitsChoice() *CT_DispUnitsChoice

### func (*CT_DispUnitsChoice) MarshalXML ¶

    func (m *CT_DispUnitsChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_DispUnitsChoice) UnmarshalXML ¶

    func (m *CT_DispUnitsChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_DispUnitsChoice) Validate ¶

    func (m *CT_DispUnitsChoice) Validate() error

Validate validates the CT_DispUnitsChoice and its children

### func (*CT_DispUnitsChoice) ValidateWithPath ¶

    func (m *CT_DispUnitsChoice) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DispUnitsChoice and its children, prefixing error messages with path

## type CT_DispUnitsLbl ¶

    type CT_DispUnitsLbl struct {
        // Layout
        Layout *CT_Layout
        Tx     *CT_Tx
        SpPr   *dml.CT_ShapeProperties
        TxPr   *dml.CT_TextBody
    }

### func NewCT_DispUnitsLbl ¶

    func NewCT_DispUnitsLbl() *CT_DispUnitsLbl

### func (*CT_DispUnitsLbl) MarshalXML ¶

    func (m *CT_DispUnitsLbl) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_DispUnitsLbl) UnmarshalXML ¶

    func (m *CT_DispUnitsLbl) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_DispUnitsLbl) Validate ¶

    func (m *CT_DispUnitsLbl) Validate() error

Validate validates the CT_DispUnitsLbl and its children

### func (*CT_DispUnitsLbl) ValidateWithPath ¶

    func (m *CT_DispUnitsLbl) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DispUnitsLbl and its children, prefixing error messages with path

## type CT_Double ¶

    type CT_Double struct {
        // Floating Point Value
        ValAttr float64
    }

### func NewCT_Double ¶

    func NewCT_Double() *CT_Double

### func (*CT_Double) MarshalXML ¶

    func (m *CT_Double) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Double) UnmarshalXML ¶

    func (m *CT_Double) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Double) Validate ¶

    func (m *CT_Double) Validate() error

Validate validates the CT_Double and its children

### func (*CT_Double) ValidateWithPath ¶

    func (m *CT_Double) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Double and its children, prefixing error messages with path

## type CT_DoughnutChart ¶

    type CT_DoughnutChart struct {
        VaryColors *CT_Boolean
        // Pie Chart Series
        Ser []*CT_PieSer
        // Data Labels
        DLbls *CT_DLbls
        // First Slice Angle
        FirstSliceAng *CT_FirstSliceAng
        // Hole Size
        HoleSize *CT_HoleSize
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_DoughnutChart ¶

    func NewCT_DoughnutChart() *CT_DoughnutChart

### func (*CT_DoughnutChart) MarshalXML ¶

    func (m *CT_DoughnutChart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_DoughnutChart) UnmarshalXML ¶

    func (m *CT_DoughnutChart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_DoughnutChart) Validate ¶

    func (m *CT_DoughnutChart) Validate() error

Validate validates the CT_DoughnutChart and its children

### func (*CT_DoughnutChart) ValidateWithPath ¶

    func (m *CT_DoughnutChart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_DoughnutChart and its children, prefixing error messages with path

## type CT_ErrBarType ¶

    type CT_ErrBarType struct {
        // Error Bar Type Value
        ValAttr ST_ErrBarType
    }

### func NewCT_ErrBarType ¶

    func NewCT_ErrBarType() *CT_ErrBarType

### func (*CT_ErrBarType) MarshalXML ¶

    func (m *CT_ErrBarType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_ErrBarType) UnmarshalXML ¶

    func (m *CT_ErrBarType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_ErrBarType) Validate ¶

    func (m *CT_ErrBarType) Validate() error

Validate validates the CT_ErrBarType and its children

### func (*CT_ErrBarType) ValidateWithPath ¶

    func (m *CT_ErrBarType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ErrBarType and its children, prefixing error messages with path

## type CT_ErrBars ¶

    type CT_ErrBars struct {
        // Error Bar Direction
        ErrDir *CT_ErrDir
        // Error Bar Type
        ErrBarType *CT_ErrBarType
        // Error Bar Value Type
        ErrValType *CT_ErrValType
        // No End Cap
        NoEndCap *CT_Boolean
        // Plus
        Plus *CT_NumDataSource
        // Minus
        Minus *CT_NumDataSource
        // Error Bar Value
        Val  *CT_Double
        SpPr *dml.CT_ShapeProperties
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_ErrBars ¶

    func NewCT_ErrBars() *CT_ErrBars

### func (*CT_ErrBars) MarshalXML ¶

    func (m *CT_ErrBars) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_ErrBars) UnmarshalXML ¶

    func (m *CT_ErrBars) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_ErrBars) Validate ¶

    func (m *CT_ErrBars) Validate() error

Validate validates the CT_ErrBars and its children

### func (*CT_ErrBars) ValidateWithPath ¶

    func (m *CT_ErrBars) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ErrBars and its children, prefixing error messages with path

## type CT_ErrDir ¶

    type CT_ErrDir struct {
        // Error Bar Direction Value
        ValAttr ST_ErrDir
    }

### func NewCT_ErrDir ¶

    func NewCT_ErrDir() *CT_ErrDir

### func (*CT_ErrDir) MarshalXML ¶

    func (m *CT_ErrDir) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_ErrDir) UnmarshalXML ¶

    func (m *CT_ErrDir) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_ErrDir) Validate ¶

    func (m *CT_ErrDir) Validate() error

Validate validates the CT_ErrDir and its children

### func (*CT_ErrDir) ValidateWithPath ¶

    func (m *CT_ErrDir) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ErrDir and its children, prefixing error messages with path

## type CT_ErrValType ¶

    type CT_ErrValType struct {
        // Error Bar Type Value
        ValAttr ST_ErrValType
    }

### func NewCT_ErrValType ¶

    func NewCT_ErrValType() *CT_ErrValType

### func (*CT_ErrValType) MarshalXML ¶

    func (m *CT_ErrValType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_ErrValType) UnmarshalXML ¶

    func (m *CT_ErrValType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_ErrValType) Validate ¶

    func (m *CT_ErrValType) Validate() error

Validate validates the CT_ErrValType and its children

### func (*CT_ErrValType) ValidateWithPath ¶

    func (m *CT_ErrValType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ErrValType and its children, prefixing error messages with path

## type CT_Extension ¶

    type CT_Extension struct {
        // Uniform Resource Identifier
        UriAttr *string
        Any     unioffice.Any
    }

### func NewCT_Extension ¶

    func NewCT_Extension() *CT_Extension

### func (*CT_Extension) MarshalXML ¶

    func (m *CT_Extension) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Extension) UnmarshalXML ¶

    func (m *CT_Extension) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Extension) Validate ¶

    func (m *CT_Extension) Validate() error

Validate validates the CT_Extension and its children

### func (*CT_Extension) ValidateWithPath ¶

    func (m *CT_Extension) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Extension and its children, prefixing error messages with path

## type CT_ExtensionList ¶

    type CT_ExtensionList struct {
        // Extension
        Ext []*CT_Extension
    }

### func NewCT_ExtensionList ¶

    func NewCT_ExtensionList() *CT_ExtensionList

### func (*CT_ExtensionList) MarshalXML ¶

    func (m *CT_ExtensionList) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_ExtensionList) UnmarshalXML ¶

    func (m *CT_ExtensionList) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_ExtensionList) Validate ¶

    func (m *CT_ExtensionList) Validate() error

Validate validates the CT_ExtensionList and its children

### func (*CT_ExtensionList) ValidateWithPath ¶

    func (m *CT_ExtensionList) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ExtensionList and its children, prefixing error messages with path

## type CT_ExternalData ¶

    type CT_ExternalData struct {
        IdAttr string
        // Update Automatically
        AutoUpdate *CT_Boolean
    }

### func NewCT_ExternalData ¶

    func NewCT_ExternalData() *CT_ExternalData

### func (*CT_ExternalData) MarshalXML ¶

    func (m *CT_ExternalData) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_ExternalData) UnmarshalXML ¶

    func (m *CT_ExternalData) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_ExternalData) Validate ¶

    func (m *CT_ExternalData) Validate() error

Validate validates the CT_ExternalData and its children

### func (*CT_ExternalData) ValidateWithPath ¶

    func (m *CT_ExternalData) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ExternalData and its children, prefixing error messages with path

## type CT_FirstSliceAng ¶

    type CT_FirstSliceAng struct {
        // First Slice Angle Value
        ValAttr *uint16
    }

### func NewCT_FirstSliceAng ¶

    func NewCT_FirstSliceAng() *CT_FirstSliceAng

### func (*CT_FirstSliceAng) MarshalXML ¶

    func (m *CT_FirstSliceAng) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_FirstSliceAng) UnmarshalXML ¶

    func (m *CT_FirstSliceAng) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_FirstSliceAng) Validate ¶

    func (m *CT_FirstSliceAng) Validate() error

Validate validates the CT_FirstSliceAng and its children

### func (*CT_FirstSliceAng) ValidateWithPath ¶

    func (m *CT_FirstSliceAng) ValidateWithPath(path string) error

ValidateWithPath validates the CT_FirstSliceAng and its children, prefixing error messages with path

## type CT_GapAmount ¶

    type CT_GapAmount struct {
        // Gap Size Value
        ValAttr *ST_GapAmount
    }

### func NewCT_GapAmount ¶

    func NewCT_GapAmount() *CT_GapAmount

### func (*CT_GapAmount) MarshalXML ¶

    func (m *CT_GapAmount) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_GapAmount) UnmarshalXML ¶

    func (m *CT_GapAmount) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_GapAmount) Validate ¶

    func (m *CT_GapAmount) Validate() error

Validate validates the CT_GapAmount and its children

### func (*CT_GapAmount) ValidateWithPath ¶

    func (m *CT_GapAmount) ValidateWithPath(path string) error

ValidateWithPath validates the CT_GapAmount and its children, prefixing error messages with path

## type CT_Grouping ¶

    type CT_Grouping struct {
        // Grouping Value
        ValAttr ST_Grouping
    }

### func NewCT_Grouping ¶

    func NewCT_Grouping() *CT_Grouping

### func (*CT_Grouping) MarshalXML ¶

    func (m *CT_Grouping) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Grouping) UnmarshalXML ¶

    func (m *CT_Grouping) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Grouping) Validate ¶

    func (m *CT_Grouping) Validate() error

Validate validates the CT_Grouping and its children

### func (*CT_Grouping) ValidateWithPath ¶

    func (m *CT_Grouping) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Grouping and its children, prefixing error messages with path

## type CT_HPercent ¶

    type CT_HPercent struct {
        // Height Percent Value
        ValAttr *ST_HPercent
    }

### func NewCT_HPercent ¶

    func NewCT_HPercent() *CT_HPercent

### func (*CT_HPercent) MarshalXML ¶

    func (m *CT_HPercent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_HPercent) UnmarshalXML ¶

    func (m *CT_HPercent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_HPercent) Validate ¶

    func (m *CT_HPercent) Validate() error

Validate validates the CT_HPercent and its children

### func (*CT_HPercent) ValidateWithPath ¶

    func (m *CT_HPercent) ValidateWithPath(path string) error

ValidateWithPath validates the CT_HPercent and its children, prefixing error messages with path

## type CT_HeaderFooter ¶

    type CT_HeaderFooter struct {
        // Align With Margins
        AlignWithMarginsAttr *bool
        // Different Odd Even
        DifferentOddEvenAttr *bool
        // Different First
        DifferentFirstAttr *bool
        // Odd Header
        OddHeader *string
        // Odd Footer
        OddFooter *string
        // Even Header
        EvenHeader *string
        // Even Footer
        EvenFooter *string
        // First Header
        FirstHeader *string
        // First Footer
        FirstFooter *string
    }

### func NewCT_HeaderFooter ¶

    func NewCT_HeaderFooter() *CT_HeaderFooter

### func (*CT_HeaderFooter) MarshalXML ¶

    func (m *CT_HeaderFooter) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_HeaderFooter) UnmarshalXML ¶

    func (m *CT_HeaderFooter) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_HeaderFooter) Validate ¶

    func (m *CT_HeaderFooter) Validate() error

Validate validates the CT_HeaderFooter and its children

### func (*CT_HeaderFooter) ValidateWithPath ¶

    func (m *CT_HeaderFooter) ValidateWithPath(path string) error

ValidateWithPath validates the CT_HeaderFooter and its children, prefixing error messages with path

## type CT_HoleSize ¶

    type CT_HoleSize struct {
        // Hole Size Value
        ValAttr *ST_HoleSize
    }

### func NewCT_HoleSize ¶

    func NewCT_HoleSize() *CT_HoleSize

### func (*CT_HoleSize) MarshalXML ¶

    func (m *CT_HoleSize) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_HoleSize) UnmarshalXML ¶

    func (m *CT_HoleSize) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_HoleSize) Validate ¶

    func (m *CT_HoleSize) Validate() error

Validate validates the CT_HoleSize and its children

### func (*CT_HoleSize) ValidateWithPath ¶

    func (m *CT_HoleSize) ValidateWithPath(path string) error

ValidateWithPath validates the CT_HoleSize and its children, prefixing error messages with path

## type CT_Layout ¶

    type CT_Layout struct {
        // Manual Layout
        ManualLayout *CT_ManualLayout
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_Layout ¶

    func NewCT_Layout() *CT_Layout

### func (*CT_Layout) MarshalXML ¶

    func (m *CT_Layout) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Layout) UnmarshalXML ¶

    func (m *CT_Layout) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Layout) Validate ¶

    func (m *CT_Layout) Validate() error

Validate validates the CT_Layout and its children

### func (*CT_Layout) ValidateWithPath ¶

    func (m *CT_Layout) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Layout and its children, prefixing error messages with path

## type CT_LayoutMode ¶

    type CT_LayoutMode struct {
        // Layout Mode Value
        ValAttr ST_LayoutMode
    }

### func NewCT_LayoutMode ¶

    func NewCT_LayoutMode() *CT_LayoutMode

### func (*CT_LayoutMode) MarshalXML ¶

    func (m *CT_LayoutMode) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_LayoutMode) UnmarshalXML ¶

    func (m *CT_LayoutMode) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_LayoutMode) Validate ¶

    func (m *CT_LayoutMode) Validate() error

Validate validates the CT_LayoutMode and its children

### func (*CT_LayoutMode) ValidateWithPath ¶

    func (m *CT_LayoutMode) ValidateWithPath(path string) error

ValidateWithPath validates the CT_LayoutMode and its children, prefixing error messages with path

## type CT_LayoutTarget ¶

    type CT_LayoutTarget struct {
        // Layout Target Value
        ValAttr ST_LayoutTarget
    }

### func NewCT_LayoutTarget ¶

    func NewCT_LayoutTarget() *CT_LayoutTarget

### func (*CT_LayoutTarget) MarshalXML ¶

    func (m *CT_LayoutTarget) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_LayoutTarget) UnmarshalXML ¶

    func (m *CT_LayoutTarget) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_LayoutTarget) Validate ¶

    func (m *CT_LayoutTarget) Validate() error

Validate validates the CT_LayoutTarget and its children

### func (*CT_LayoutTarget) ValidateWithPath ¶

    func (m *CT_LayoutTarget) ValidateWithPath(path string) error

ValidateWithPath validates the CT_LayoutTarget and its children, prefixing error messages with path

## type CT_LblAlgn ¶

    type CT_LblAlgn struct {
        // Label Alignment Value
        ValAttr ST_LblAlgn
    }

### func NewCT_LblAlgn ¶

    func NewCT_LblAlgn() *CT_LblAlgn

### func (*CT_LblAlgn) MarshalXML ¶

    func (m *CT_LblAlgn) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_LblAlgn) UnmarshalXML ¶

    func (m *CT_LblAlgn) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_LblAlgn) Validate ¶

    func (m *CT_LblAlgn) Validate() error

Validate validates the CT_LblAlgn and its children

### func (*CT_LblAlgn) ValidateWithPath ¶

    func (m *CT_LblAlgn) ValidateWithPath(path string) error

ValidateWithPath validates the CT_LblAlgn and its children, prefixing error messages with path

## type CT_LblOffset ¶

    type CT_LblOffset struct {
        // Label Offset Value
        ValAttr *ST_LblOffset
    }

### func NewCT_LblOffset ¶

    func NewCT_LblOffset() *CT_LblOffset

### func (*CT_LblOffset) MarshalXML ¶

    func (m *CT_LblOffset) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_LblOffset) UnmarshalXML ¶

    func (m *CT_LblOffset) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_LblOffset) Validate ¶

    func (m *CT_LblOffset) Validate() error

Validate validates the CT_LblOffset and its children

### func (*CT_LblOffset) ValidateWithPath ¶

    func (m *CT_LblOffset) ValidateWithPath(path string) error

ValidateWithPath validates the CT_LblOffset and its children, prefixing error messages with path

## type CT_Legend ¶

    type CT_Legend struct {
        // Legend Position
        LegendPos *CT_LegendPos
        // Legend Entry
        LegendEntry []*CT_LegendEntry
        // Layout
        Layout *CT_Layout
        // Overlay
        Overlay *CT_Boolean
        SpPr    *dml.CT_ShapeProperties
        TxPr    *dml.CT_TextBody
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_Legend ¶

    func NewCT_Legend() *CT_Legend

### func (*CT_Legend) MarshalXML ¶

    func (m *CT_Legend) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Legend) UnmarshalXML ¶

    func (m *CT_Legend) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Legend) Validate ¶

    func (m *CT_Legend) Validate() error

Validate validates the CT_Legend and its children

### func (*CT_Legend) ValidateWithPath ¶

    func (m *CT_Legend) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Legend and its children, prefixing error messages with path

## type CT_LegendEntry ¶

    type CT_LegendEntry struct {
        // Index
        Idx               *CT_UnsignedInt
        LegendEntryChoice *CT_LegendEntryChoice
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_LegendEntry ¶

    func NewCT_LegendEntry() *CT_LegendEntry

### func (*CT_LegendEntry) MarshalXML ¶

    func (m *CT_LegendEntry) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_LegendEntry) UnmarshalXML ¶

    func (m *CT_LegendEntry) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_LegendEntry) Validate ¶

    func (m *CT_LegendEntry) Validate() error

Validate validates the CT_LegendEntry and its children

### func (*CT_LegendEntry) ValidateWithPath ¶

    func (m *CT_LegendEntry) ValidateWithPath(path string) error

ValidateWithPath validates the CT_LegendEntry and its children, prefixing error messages with path

## type CT_LegendEntryChoice ¶

    type CT_LegendEntryChoice struct {
        Delete *CT_Boolean
        TxPr   *dml.CT_TextBody
    }

### func NewCT_LegendEntryChoice ¶

    func NewCT_LegendEntryChoice() *CT_LegendEntryChoice

### func (*CT_LegendEntryChoice) MarshalXML ¶

    func (m *CT_LegendEntryChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_LegendEntryChoice) UnmarshalXML ¶

    func (m *CT_LegendEntryChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_LegendEntryChoice) Validate ¶

    func (m *CT_LegendEntryChoice) Validate() error

Validate validates the CT_LegendEntryChoice and its children

### func (*CT_LegendEntryChoice) ValidateWithPath ¶

    func (m *CT_LegendEntryChoice) ValidateWithPath(path string) error

ValidateWithPath validates the CT_LegendEntryChoice and its children, prefixing error messages with path

## type CT_LegendPos ¶

    type CT_LegendPos struct {
        // Legend Position Value
        ValAttr ST_LegendPos
    }

### func NewCT_LegendPos ¶

    func NewCT_LegendPos() *CT_LegendPos

### func (*CT_LegendPos) MarshalXML ¶

    func (m *CT_LegendPos) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_LegendPos) UnmarshalXML ¶

    func (m *CT_LegendPos) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_LegendPos) Validate ¶

    func (m *CT_LegendPos) Validate() error

Validate validates the CT_LegendPos and its children

### func (*CT_LegendPos) ValidateWithPath ¶

    func (m *CT_LegendPos) ValidateWithPath(path string) error

ValidateWithPath validates the CT_LegendPos and its children, prefixing error messages with path

## type CT_Line3DChart ¶

    type CT_Line3DChart struct {
        // Grouping
        Grouping   *CT_Grouping
        VaryColors *CT_Boolean
        Ser        []*CT_LineSer
        // Data Labels
        DLbls *CT_DLbls
        // Drop Lines
        DropLines *CT_ChartLines
        // Gap Depth
        GapDepth *CT_GapAmount
        // Axis ID
        AxId []*CT_UnsignedInt
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_Line3DChart ¶

    func NewCT_Line3DChart() *CT_Line3DChart

### func (*CT_Line3DChart) MarshalXML ¶

    func (m *CT_Line3DChart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Line3DChart) UnmarshalXML ¶

    func (m *CT_Line3DChart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Line3DChart) Validate ¶

    func (m *CT_Line3DChart) Validate() error

Validate validates the CT_Line3DChart and its children

### func (*CT_Line3DChart) ValidateWithPath ¶

    func (m *CT_Line3DChart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Line3DChart and its children, prefixing error messages with path

## type CT_LineChart ¶

    type CT_LineChart struct {
        // Grouping
        Grouping   *CT_Grouping
        VaryColors *CT_Boolean
        Ser        []*CT_LineSer
        // Data Labels
        DLbls *CT_DLbls
        // Drop Lines
        DropLines *CT_ChartLines
        // High Low Lines
        HiLowLines *CT_ChartLines
        UpDownBars *CT_UpDownBars
        // Show Marker
        Marker *CT_Boolean
        Smooth *CT_Boolean
        // Axis ID
        AxId []*CT_UnsignedInt
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_LineChart ¶

    func NewCT_LineChart() *CT_LineChart

### func (*CT_LineChart) MarshalXML ¶

    func (m *CT_LineChart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_LineChart) UnmarshalXML ¶

    func (m *CT_LineChart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_LineChart) Validate ¶

    func (m *CT_LineChart) Validate() error

Validate validates the CT_LineChart and its children

### func (*CT_LineChart) ValidateWithPath ¶

    func (m *CT_LineChart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_LineChart and its children, prefixing error messages with path

## type CT_LineSer ¶

    type CT_LineSer struct {
        // Index
        Idx *CT_UnsignedInt
        // Order
        Order *CT_UnsignedInt
        // Series Text
        Tx   *CT_SerTx
        SpPr *dml.CT_ShapeProperties
        // Marker
        Marker *CT_Marker
        // Data Point
        DPt []*CT_DPt
        // Data Labels
        DLbls     *CT_DLbls
        Trendline []*CT_Trendline
        // Error Bars
        ErrBars *CT_ErrBars
        // Category Axis Data
        Cat    *CT_AxDataSource
        Val    *CT_NumDataSource
        Smooth *CT_Boolean
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_LineSer ¶

    func NewCT_LineSer() *CT_LineSer

### func (*CT_LineSer) MarshalXML ¶

    func (m *CT_LineSer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_LineSer) UnmarshalXML ¶

    func (m *CT_LineSer) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_LineSer) Validate ¶

    func (m *CT_LineSer) Validate() error

Validate validates the CT_LineSer and its children

### func (*CT_LineSer) ValidateWithPath ¶

    func (m *CT_LineSer) ValidateWithPath(path string) error

ValidateWithPath validates the CT_LineSer and its children, prefixing error messages with path

## type CT_LogBase ¶

    type CT_LogBase struct {
        // Logarithmic Base Value
        ValAttr float64
    }

### func NewCT_LogBase ¶

    func NewCT_LogBase() *CT_LogBase

### func (*CT_LogBase) MarshalXML ¶

    func (m *CT_LogBase) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_LogBase) UnmarshalXML ¶

    func (m *CT_LogBase) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_LogBase) Validate ¶

    func (m *CT_LogBase) Validate() error

Validate validates the CT_LogBase and its children

### func (*CT_LogBase) ValidateWithPath ¶

    func (m *CT_LogBase) ValidateWithPath(path string) error

ValidateWithPath validates the CT_LogBase and its children, prefixing error messages with path

## type CT_Lvl ¶

    type CT_Lvl struct {
        // String Point
        Pt []*CT_StrVal
    }

### func NewCT_Lvl ¶

    func NewCT_Lvl() *CT_Lvl

### func (*CT_Lvl) MarshalXML ¶

    func (m *CT_Lvl) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Lvl) UnmarshalXML ¶

    func (m *CT_Lvl) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Lvl) Validate ¶

    func (m *CT_Lvl) Validate() error

Validate validates the CT_Lvl and its children

### func (*CT_Lvl) ValidateWithPath ¶

    func (m *CT_Lvl) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Lvl and its children, prefixing error messages with path

## type CT_ManualLayout ¶

    type CT_ManualLayout struct {
        // Layout Target
        LayoutTarget *CT_LayoutTarget
        // Left Mode
        XMode *CT_LayoutMode
        // Top Mode
        YMode *CT_LayoutMode
        // Width Mode
        WMode *CT_LayoutMode
        // Height Mode
        HMode *CT_LayoutMode
        // Left
        X *CT_Double
        // Top
        Y *CT_Double
        // Width
        W *CT_Double
        // Height
        H *CT_Double
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_ManualLayout ¶

    func NewCT_ManualLayout() *CT_ManualLayout

### func (*CT_ManualLayout) MarshalXML ¶

    func (m *CT_ManualLayout) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_ManualLayout) UnmarshalXML ¶

    func (m *CT_ManualLayout) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_ManualLayout) Validate ¶

    func (m *CT_ManualLayout) Validate() error

Validate validates the CT_ManualLayout and its children

### func (*CT_ManualLayout) ValidateWithPath ¶

    func (m *CT_ManualLayout) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ManualLayout and its children, prefixing error messages with path

## type CT_Marker ¶

    type CT_Marker struct {
        // Symbol
        Symbol *CT_MarkerStyle
        // Size
        Size *CT_MarkerSize
        SpPr *dml.CT_ShapeProperties
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_Marker ¶

    func NewCT_Marker() *CT_Marker

### func (*CT_Marker) MarshalXML ¶

    func (m *CT_Marker) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Marker) UnmarshalXML ¶

    func (m *CT_Marker) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Marker) Validate ¶

    func (m *CT_Marker) Validate() error

Validate validates the CT_Marker and its children

### func (*CT_Marker) ValidateWithPath ¶

    func (m *CT_Marker) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Marker and its children, prefixing error messages with path

## type CT_MarkerSize ¶

    type CT_MarkerSize struct {
        // Marker Size Value
        ValAttr *uint8
    }

### func NewCT_MarkerSize ¶

    func NewCT_MarkerSize() *CT_MarkerSize

### func (*CT_MarkerSize) MarshalXML ¶

    func (m *CT_MarkerSize) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_MarkerSize) UnmarshalXML ¶

    func (m *CT_MarkerSize) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_MarkerSize) Validate ¶

    func (m *CT_MarkerSize) Validate() error

Validate validates the CT_MarkerSize and its children

### func (*CT_MarkerSize) ValidateWithPath ¶

    func (m *CT_MarkerSize) ValidateWithPath(path string) error

ValidateWithPath validates the CT_MarkerSize and its children, prefixing error messages with path

## type CT_MarkerStyle ¶

    type CT_MarkerStyle struct {
        // Marker Style Value
        ValAttr ST_MarkerStyle
    }

### func NewCT_MarkerStyle ¶

    func NewCT_MarkerStyle() *CT_MarkerStyle

### func (*CT_MarkerStyle) MarshalXML ¶

    func (m *CT_MarkerStyle) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_MarkerStyle) UnmarshalXML ¶

    func (m *CT_MarkerStyle) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_MarkerStyle) Validate ¶

    func (m *CT_MarkerStyle) Validate() error

Validate validates the CT_MarkerStyle and its children

### func (*CT_MarkerStyle) ValidateWithPath ¶

    func (m *CT_MarkerStyle) ValidateWithPath(path string) error

ValidateWithPath validates the CT_MarkerStyle and its children, prefixing error messages with path

## type CT_MultiLvlStrData ¶

    type CT_MultiLvlStrData struct {
        PtCount *CT_UnsignedInt
        // Level
        Lvl    []*CT_Lvl
        ExtLst *CT_ExtensionList
    }

### func NewCT_MultiLvlStrData ¶

    func NewCT_MultiLvlStrData() *CT_MultiLvlStrData

### func (*CT_MultiLvlStrData) MarshalXML ¶

    func (m *CT_MultiLvlStrData) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_MultiLvlStrData) UnmarshalXML ¶

    func (m *CT_MultiLvlStrData) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_MultiLvlStrData) Validate ¶

    func (m *CT_MultiLvlStrData) Validate() error

Validate validates the CT_MultiLvlStrData and its children

### func (*CT_MultiLvlStrData) ValidateWithPath ¶

    func (m *CT_MultiLvlStrData) ValidateWithPath(path string) error

ValidateWithPath validates the CT_MultiLvlStrData and its children, prefixing error messages with path

## type CT_MultiLvlStrRef ¶

    type CT_MultiLvlStrRef struct {
        // Formula
        F string
        // Multi Level String Cache
        MultiLvlStrCache *CT_MultiLvlStrData
        ExtLst           *CT_ExtensionList
    }

### func NewCT_MultiLvlStrRef ¶

    func NewCT_MultiLvlStrRef() *CT_MultiLvlStrRef

### func (*CT_MultiLvlStrRef) MarshalXML ¶

    func (m *CT_MultiLvlStrRef) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_MultiLvlStrRef) UnmarshalXML ¶

    func (m *CT_MultiLvlStrRef) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_MultiLvlStrRef) Validate ¶

    func (m *CT_MultiLvlStrRef) Validate() error

Validate validates the CT_MultiLvlStrRef and its children

### func (*CT_MultiLvlStrRef) ValidateWithPath ¶

    func (m *CT_MultiLvlStrRef) ValidateWithPath(path string) error

ValidateWithPath validates the CT_MultiLvlStrRef and its children, prefixing error messages with path

## type CT_NumData ¶

    type CT_NumData struct {
        // Format Code
        FormatCode *string
        // Point Count
        PtCount *CT_UnsignedInt
        // Numeric Point
        Pt     []*CT_NumVal
        ExtLst *CT_ExtensionList
    }

### func NewCT_NumData ¶

    func NewCT_NumData() *CT_NumData

### func (*CT_NumData) MarshalXML ¶

    func (m *CT_NumData) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_NumData) UnmarshalXML ¶

    func (m *CT_NumData) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_NumData) Validate ¶

    func (m *CT_NumData) Validate() error

Validate validates the CT_NumData and its children

### func (*CT_NumData) ValidateWithPath ¶

    func (m *CT_NumData) ValidateWithPath(path string) error

ValidateWithPath validates the CT_NumData and its children, prefixing error messages with path

## type CT_NumDataSource ¶

    type CT_NumDataSource struct {
        NumDataSourceChoice *CT_NumDataSourceChoice
    }

### func NewCT_NumDataSource ¶

    func NewCT_NumDataSource() *CT_NumDataSource

### func (*CT_NumDataSource) MarshalXML ¶

    func (m *CT_NumDataSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_NumDataSource) UnmarshalXML ¶

    func (m *CT_NumDataSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_NumDataSource) Validate ¶

    func (m *CT_NumDataSource) Validate() error

Validate validates the CT_NumDataSource and its children

### func (*CT_NumDataSource) ValidateWithPath ¶

    func (m *CT_NumDataSource) ValidateWithPath(path string) error

ValidateWithPath validates the CT_NumDataSource and its children, prefixing error messages with path

## type CT_NumDataSourceChoice ¶

    type CT_NumDataSourceChoice struct {
        NumRef *CT_NumRef
        NumLit *CT_NumData
    }

### func NewCT_NumDataSourceChoice ¶

    func NewCT_NumDataSourceChoice() *CT_NumDataSourceChoice

### func (*CT_NumDataSourceChoice) MarshalXML ¶

    func (m *CT_NumDataSourceChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_NumDataSourceChoice) UnmarshalXML ¶

    func (m *CT_NumDataSourceChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_NumDataSourceChoice) Validate ¶

    func (m *CT_NumDataSourceChoice) Validate() error

Validate validates the CT_NumDataSourceChoice and its children

### func (*CT_NumDataSourceChoice) ValidateWithPath ¶

    func (m *CT_NumDataSourceChoice) ValidateWithPath(path string) error

ValidateWithPath validates the CT_NumDataSourceChoice and its children, prefixing error messages with path

## type CT_NumFmt ¶

    type CT_NumFmt struct {
        // Number Format Code
        FormatCodeAttr string
        // Linked to Source
        SourceLinkedAttr *bool
    }

### func NewCT_NumFmt ¶

    func NewCT_NumFmt() *CT_NumFmt

### func (*CT_NumFmt) MarshalXML ¶

    func (m *CT_NumFmt) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_NumFmt) UnmarshalXML ¶

    func (m *CT_NumFmt) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_NumFmt) Validate ¶

    func (m *CT_NumFmt) Validate() error

Validate validates the CT_NumFmt and its children

### func (*CT_NumFmt) ValidateWithPath ¶

    func (m *CT_NumFmt) ValidateWithPath(path string) error

ValidateWithPath validates the CT_NumFmt and its children, prefixing error messages with path

## type CT_NumRef ¶

    type CT_NumRef struct {
        // Formula
        F string
        // Number Cache
        NumCache *CT_NumData
        ExtLst   *CT_ExtensionList
    }

### func NewCT_NumRef ¶

    func NewCT_NumRef() *CT_NumRef

### func (*CT_NumRef) MarshalXML ¶

    func (m *CT_NumRef) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_NumRef) UnmarshalXML ¶

    func (m *CT_NumRef) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_NumRef) Validate ¶

    func (m *CT_NumRef) Validate() error

Validate validates the CT_NumRef and its children

### func (*CT_NumRef) ValidateWithPath ¶

    func (m *CT_NumRef) ValidateWithPath(path string) error

ValidateWithPath validates the CT_NumRef and its children, prefixing error messages with path

## type CT_NumVal ¶

    type CT_NumVal struct {
        // Index
        IdxAttr uint32
        // Number Format
        FormatCodeAttr *string
        // Numeric Value
        V string
    }

### func NewCT_NumVal ¶

    func NewCT_NumVal() *CT_NumVal

### func (*CT_NumVal) MarshalXML ¶

    func (m *CT_NumVal) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_NumVal) UnmarshalXML ¶

    func (m *CT_NumVal) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_NumVal) Validate ¶

    func (m *CT_NumVal) Validate() error

Validate validates the CT_NumVal and its children

### func (*CT_NumVal) ValidateWithPath ¶

    func (m *CT_NumVal) ValidateWithPath(path string) error

ValidateWithPath validates the CT_NumVal and its children, prefixing error messages with path

## type CT_OfPieChart ¶

    type CT_OfPieChart struct {
        // Pie of Pie or Bar of Pie Type
        OfPieType  *CT_OfPieType
        VaryColors *CT_Boolean
        // Pie Chart Series
        Ser []*CT_PieSer
        // Data Labels
        DLbls *CT_DLbls
        // Gap Width
        GapWidth *CT_GapAmount
        // Split Type
        SplitType *CT_SplitType
        // Split Position
        SplitPos *CT_Double
        // Custom Split
        CustSplit *CT_CustSplit
        // Second Pie Size
        SecondPieSize *CT_SecondPieSize
        SerLines      []*CT_ChartLines
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_OfPieChart ¶

    func NewCT_OfPieChart() *CT_OfPieChart

### func (*CT_OfPieChart) MarshalXML ¶

    func (m *CT_OfPieChart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_OfPieChart) UnmarshalXML ¶

    func (m *CT_OfPieChart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_OfPieChart) Validate ¶

    func (m *CT_OfPieChart) Validate() error

Validate validates the CT_OfPieChart and its children

### func (*CT_OfPieChart) ValidateWithPath ¶

    func (m *CT_OfPieChart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_OfPieChart and its children, prefixing error messages with path

## type CT_OfPieType ¶

    type CT_OfPieType struct {
        // Pie of Pie or Bar of Pie Type Value
        ValAttr ST_OfPieType
    }

### func NewCT_OfPieType ¶

    func NewCT_OfPieType() *CT_OfPieType

### func (*CT_OfPieType) MarshalXML ¶

    func (m *CT_OfPieType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_OfPieType) UnmarshalXML ¶

    func (m *CT_OfPieType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_OfPieType) Validate ¶

    func (m *CT_OfPieType) Validate() error

Validate validates the CT_OfPieType and its children

### func (*CT_OfPieType) ValidateWithPath ¶

    func (m *CT_OfPieType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_OfPieType and its children, prefixing error messages with path

## type CT_Order ¶

    type CT_Order struct {
        // Order Value
        ValAttr *uint8
    }

### func NewCT_Order ¶

    func NewCT_Order() *CT_Order

### func (*CT_Order) MarshalXML ¶

    func (m *CT_Order) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Order) UnmarshalXML ¶

    func (m *CT_Order) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Order) Validate ¶

    func (m *CT_Order) Validate() error

Validate validates the CT_Order and its children

### func (*CT_Order) ValidateWithPath ¶

    func (m *CT_Order) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Order and its children, prefixing error messages with path

## type CT_Orientation ¶

    type CT_Orientation struct {
        // Orientation Value
        ValAttr ST_Orientation
    }

### func NewCT_Orientation ¶

    func NewCT_Orientation() *CT_Orientation

### func (*CT_Orientation) MarshalXML ¶

    func (m *CT_Orientation) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Orientation) UnmarshalXML ¶

    func (m *CT_Orientation) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Orientation) Validate ¶

    func (m *CT_Orientation) Validate() error

Validate validates the CT_Orientation and its children

### func (*CT_Orientation) ValidateWithPath ¶

    func (m *CT_Orientation) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Orientation and its children, prefixing error messages with path

## type CT_Overlap ¶

    type CT_Overlap struct {
        // Overlap Value
        ValAttr *ST_Overlap
    }

### func NewCT_Overlap ¶

    func NewCT_Overlap() *CT_Overlap

### func (*CT_Overlap) MarshalXML ¶

    func (m *CT_Overlap) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Overlap) UnmarshalXML ¶

    func (m *CT_Overlap) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Overlap) Validate ¶

    func (m *CT_Overlap) Validate() error

Validate validates the CT_Overlap and its children

### func (*CT_Overlap) ValidateWithPath ¶

    func (m *CT_Overlap) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Overlap and its children, prefixing error messages with path

## type CT_PageMargins ¶

    type CT_PageMargins struct {
        // Left
        LAttr float64
        // Right
        RAttr float64
        // Top
        TAttr float64
        // Bottom
        BAttr float64
        // Header
        HeaderAttr float64
        // Footer
        FooterAttr float64
    }

### func NewCT_PageMargins ¶

    func NewCT_PageMargins() *CT_PageMargins

### func (*CT_PageMargins) MarshalXML ¶

    func (m *CT_PageMargins) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_PageMargins) UnmarshalXML ¶

    func (m *CT_PageMargins) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_PageMargins) Validate ¶

    func (m *CT_PageMargins) Validate() error

Validate validates the CT_PageMargins and its children

### func (*CT_PageMargins) ValidateWithPath ¶

    func (m *CT_PageMargins) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PageMargins and its children, prefixing error messages with path

## type CT_PageSetup ¶

    type CT_PageSetup struct {
        // Page Size
        PaperSizeAttr *uint32
        // Paper Height
        PaperHeightAttr *string
        // Paper Width
        PaperWidthAttr *string
        // First Page Number
        FirstPageNumberAttr *uint32
        // Orientation
        OrientationAttr ST_PageSetupOrientation
        // Black and White
        BlackAndWhiteAttr *bool
        // Draft
        DraftAttr *bool
        // Use First Page Number
        UseFirstPageNumberAttr *bool
        // Horizontal DPI
        HorizontalDpiAttr *int32
        // Vertical DPI
        VerticalDpiAttr *int32
        // Copies
        CopiesAttr *uint32
    }

### func NewCT_PageSetup ¶

    func NewCT_PageSetup() *CT_PageSetup

### func (*CT_PageSetup) MarshalXML ¶

    func (m *CT_PageSetup) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_PageSetup) UnmarshalXML ¶

    func (m *CT_PageSetup) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_PageSetup) Validate ¶

    func (m *CT_PageSetup) Validate() error

Validate validates the CT_PageSetup and its children

### func (*CT_PageSetup) ValidateWithPath ¶

    func (m *CT_PageSetup) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PageSetup and its children, prefixing error messages with path

## type CT_Period ¶

    type CT_Period struct {
        // Period Value
        ValAttr *uint32
    }

### func NewCT_Period ¶

    func NewCT_Period() *CT_Period

### func (*CT_Period) MarshalXML ¶

    func (m *CT_Period) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Period) UnmarshalXML ¶

    func (m *CT_Period) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Period) Validate ¶

    func (m *CT_Period) Validate() error

Validate validates the CT_Period and its children

### func (*CT_Period) ValidateWithPath ¶

    func (m *CT_Period) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Period and its children, prefixing error messages with path

## type CT_Perspective ¶

    type CT_Perspective struct {
        // Perspective Value
        ValAttr *uint8
    }

### func NewCT_Perspective ¶

    func NewCT_Perspective() *CT_Perspective

### func (*CT_Perspective) MarshalXML ¶

    func (m *CT_Perspective) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Perspective) UnmarshalXML ¶

    func (m *CT_Perspective) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Perspective) Validate ¶

    func (m *CT_Perspective) Validate() error

Validate validates the CT_Perspective and its children

### func (*CT_Perspective) ValidateWithPath ¶

    func (m *CT_Perspective) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Perspective and its children, prefixing error messages with path

## type CT_PictureFormat ¶

    type CT_PictureFormat struct {
        // Picture Format Value
        ValAttr ST_PictureFormat
    }

### func NewCT_PictureFormat ¶

    func NewCT_PictureFormat() *CT_PictureFormat

### func (*CT_PictureFormat) MarshalXML ¶

    func (m *CT_PictureFormat) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_PictureFormat) UnmarshalXML ¶

    func (m *CT_PictureFormat) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_PictureFormat) Validate ¶

    func (m *CT_PictureFormat) Validate() error

Validate validates the CT_PictureFormat and its children

### func (*CT_PictureFormat) ValidateWithPath ¶

    func (m *CT_PictureFormat) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PictureFormat and its children, prefixing error messages with path

## type CT_PictureOptions ¶

    type CT_PictureOptions struct {
        // Apply To Front
        ApplyToFront *CT_Boolean
        // Apply To Sides
        ApplyToSides *CT_Boolean
        // Apply to End
        ApplyToEnd *CT_Boolean
        // Picture Format
        PictureFormat *CT_PictureFormat
        // Picture Stack Unit
        PictureStackUnit *CT_PictureStackUnit
    }

### func NewCT_PictureOptions ¶

    func NewCT_PictureOptions() *CT_PictureOptions

### func (*CT_PictureOptions) MarshalXML ¶

    func (m *CT_PictureOptions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_PictureOptions) UnmarshalXML ¶

    func (m *CT_PictureOptions) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_PictureOptions) Validate ¶

    func (m *CT_PictureOptions) Validate() error

Validate validates the CT_PictureOptions and its children

### func (*CT_PictureOptions) ValidateWithPath ¶

    func (m *CT_PictureOptions) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PictureOptions and its children, prefixing error messages with path

## type CT_PictureStackUnit ¶

    type CT_PictureStackUnit struct {
        // Picture Stack Unit
        ValAttr float64
    }

### func NewCT_PictureStackUnit ¶

    func NewCT_PictureStackUnit() *CT_PictureStackUnit

### func (*CT_PictureStackUnit) MarshalXML ¶

    func (m *CT_PictureStackUnit) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_PictureStackUnit) UnmarshalXML ¶

    func (m *CT_PictureStackUnit) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_PictureStackUnit) Validate ¶

    func (m *CT_PictureStackUnit) Validate() error

Validate validates the CT_PictureStackUnit and its children

### func (*CT_PictureStackUnit) ValidateWithPath ¶

    func (m *CT_PictureStackUnit) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PictureStackUnit and its children, prefixing error messages with path

## type CT_Pie3DChart ¶

    type CT_Pie3DChart struct {
        VaryColors *CT_Boolean
        // Pie Chart Series
        Ser []*CT_PieSer
        // Data Labels
        DLbls *CT_DLbls
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_Pie3DChart ¶

    func NewCT_Pie3DChart() *CT_Pie3DChart

### func (*CT_Pie3DChart) MarshalXML ¶

    func (m *CT_Pie3DChart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Pie3DChart) UnmarshalXML ¶

    func (m *CT_Pie3DChart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Pie3DChart) Validate ¶

    func (m *CT_Pie3DChart) Validate() error

Validate validates the CT_Pie3DChart and its children

### func (*CT_Pie3DChart) ValidateWithPath ¶

    func (m *CT_Pie3DChart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Pie3DChart and its children, prefixing error messages with path

## type CT_PieChart ¶

    type CT_PieChart struct {
        VaryColors *CT_Boolean
        // Pie Chart Series
        Ser []*CT_PieSer
        // Data Labels
        DLbls *CT_DLbls
        // First Slice Angle
        FirstSliceAng *CT_FirstSliceAng
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_PieChart ¶

    func NewCT_PieChart() *CT_PieChart

### func (*CT_PieChart) MarshalXML ¶

    func (m *CT_PieChart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_PieChart) UnmarshalXML ¶

    func (m *CT_PieChart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_PieChart) Validate ¶

    func (m *CT_PieChart) Validate() error

Validate validates the CT_PieChart and its children

### func (*CT_PieChart) ValidateWithPath ¶

    func (m *CT_PieChart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PieChart and its children, prefixing error messages with path

## type CT_PieSer ¶

    type CT_PieSer struct {
        // Index
        Idx *CT_UnsignedInt
        // Order
        Order *CT_UnsignedInt
        // Series Text
        Tx   *CT_SerTx
        SpPr *dml.CT_ShapeProperties
        // Explosion
        Explosion *CT_UnsignedInt
        // Data Point
        DPt []*CT_DPt
        // Data Labels
        DLbls *CT_DLbls
        // Category Axis Data
        Cat *CT_AxDataSource
        Val *CT_NumDataSource
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_PieSer ¶

    func NewCT_PieSer() *CT_PieSer

### func (*CT_PieSer) MarshalXML ¶

    func (m *CT_PieSer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_PieSer) UnmarshalXML ¶

    func (m *CT_PieSer) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_PieSer) Validate ¶

    func (m *CT_PieSer) Validate() error

Validate validates the CT_PieSer and its children

### func (*CT_PieSer) ValidateWithPath ¶

    func (m *CT_PieSer) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PieSer and its children, prefixing error messages with path

## type CT_PivotFmt ¶

    type CT_PivotFmt struct {
        // Index
        Idx  *CT_UnsignedInt
        SpPr *dml.CT_ShapeProperties
        TxPr *dml.CT_TextBody
        // Marker
        Marker *CT_Marker
        // Data Label
        DLbl *CT_DLbl
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_PivotFmt ¶

    func NewCT_PivotFmt() *CT_PivotFmt

### func (*CT_PivotFmt) MarshalXML ¶

    func (m *CT_PivotFmt) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_PivotFmt) UnmarshalXML ¶

    func (m *CT_PivotFmt) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_PivotFmt) Validate ¶

    func (m *CT_PivotFmt) Validate() error

Validate validates the CT_PivotFmt and its children

### func (*CT_PivotFmt) ValidateWithPath ¶

    func (m *CT_PivotFmt) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotFmt and its children, prefixing error messages with path

## type CT_PivotFmts ¶

    type CT_PivotFmts struct {
        // Pivot Format
        PivotFmt []*CT_PivotFmt
    }

### func NewCT_PivotFmts ¶

    func NewCT_PivotFmts() *CT_PivotFmts

### func (*CT_PivotFmts) MarshalXML ¶

    func (m *CT_PivotFmts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_PivotFmts) UnmarshalXML ¶

    func (m *CT_PivotFmts) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_PivotFmts) Validate ¶

    func (m *CT_PivotFmts) Validate() error

Validate validates the CT_PivotFmts and its children

### func (*CT_PivotFmts) ValidateWithPath ¶

    func (m *CT_PivotFmts) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotFmts and its children, prefixing error messages with path

## type CT_PivotSource ¶

    type CT_PivotSource struct {
        // Pivot Name
        Name string
        // Format ID
        FmtId *CT_UnsignedInt
        // Chart Extensibility
        ExtLst []*CT_ExtensionList
    }

### func NewCT_PivotSource ¶

    func NewCT_PivotSource() *CT_PivotSource

### func (*CT_PivotSource) MarshalXML ¶

    func (m *CT_PivotSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_PivotSource) UnmarshalXML ¶

    func (m *CT_PivotSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_PivotSource) Validate ¶

    func (m *CT_PivotSource) Validate() error

Validate validates the CT_PivotSource and its children

### func (*CT_PivotSource) ValidateWithPath ¶

    func (m *CT_PivotSource) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotSource and its children, prefixing error messages with path

## type CT_PlotArea ¶

    type CT_PlotArea struct {
        // Layout
        Layout          *CT_Layout
        PlotAreaChoice  []*CT_PlotAreaChoice
        PlotAreaChoice1 []*CT_PlotAreaChoice1
        // Data Table
        DTable *CT_DTable
        SpPr   *dml.CT_ShapeProperties
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_PlotArea ¶

    func NewCT_PlotArea() *CT_PlotArea

### func (*CT_PlotArea) MarshalXML ¶

    func (m *CT_PlotArea) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_PlotArea) UnmarshalXML ¶

    func (m *CT_PlotArea) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_PlotArea) Validate ¶

    func (m *CT_PlotArea) Validate() error

Validate validates the CT_PlotArea and its children

### func (*CT_PlotArea) ValidateWithPath ¶

    func (m *CT_PlotArea) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PlotArea and its children, prefixing error messages with path

## type CT_PlotAreaChoice ¶

    type CT_PlotAreaChoice struct {
        AreaChart      *CT_AreaChart
        Area3DChart    *CT_Area3DChart
        LineChart      *CT_LineChart
        Line3DChart    *CT_Line3DChart
        StockChart     *CT_StockChart
        RadarChart     *CT_RadarChart
        ScatterChart   *CT_ScatterChart
        PieChart       *CT_PieChart
        Pie3DChart     *CT_Pie3DChart
        DoughnutChart  *CT_DoughnutChart
        BarChart       *CT_BarChart
        Bar3DChart     *CT_Bar3DChart
        OfPieChart     *CT_OfPieChart
        SurfaceChart   *CT_SurfaceChart
        Surface3DChart *CT_Surface3DChart
        BubbleChart    *CT_BubbleChart
    }

### func NewCT_PlotAreaChoice ¶

    func NewCT_PlotAreaChoice() *CT_PlotAreaChoice

### func (*CT_PlotAreaChoice) MarshalXML ¶

    func (m *CT_PlotAreaChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_PlotAreaChoice) UnmarshalXML ¶

    func (m *CT_PlotAreaChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_PlotAreaChoice) Validate ¶

    func (m *CT_PlotAreaChoice) Validate() error

Validate validates the CT_PlotAreaChoice and its children

### func (*CT_PlotAreaChoice) ValidateWithPath ¶

    func (m *CT_PlotAreaChoice) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PlotAreaChoice and its children, prefixing error messages with path

## type CT_PlotAreaChoice1 ¶

    type CT_PlotAreaChoice1 struct {
        ValAx  *CT_ValAx
        CatAx  *CT_CatAx
        DateAx *CT_DateAx
        SerAx  *CT_SerAx
    }

### func NewCT_PlotAreaChoice1 ¶

    func NewCT_PlotAreaChoice1() *CT_PlotAreaChoice1

### func (*CT_PlotAreaChoice1) MarshalXML ¶

    func (m *CT_PlotAreaChoice1) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_PlotAreaChoice1) UnmarshalXML ¶

    func (m *CT_PlotAreaChoice1) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_PlotAreaChoice1) Validate ¶

    func (m *CT_PlotAreaChoice1) Validate() error

Validate validates the CT_PlotAreaChoice1 and its children

### func (*CT_PlotAreaChoice1) ValidateWithPath ¶

    func (m *CT_PlotAreaChoice1) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PlotAreaChoice1 and its children, prefixing error messages with path

## type CT_PrintSettings ¶

    type CT_PrintSettings struct {
        // Header and Footer
        HeaderFooter *CT_HeaderFooter
        // Page Margins
        PageMargins *CT_PageMargins
        // Page Setup
        PageSetup *CT_PageSetup
        // Legacy Drawing for Headers and Footers
        LegacyDrawingHF *CT_RelId
    }

### func NewCT_PrintSettings ¶

    func NewCT_PrintSettings() *CT_PrintSettings

### func (*CT_PrintSettings) MarshalXML ¶

    func (m *CT_PrintSettings) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_PrintSettings) UnmarshalXML ¶

    func (m *CT_PrintSettings) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_PrintSettings) Validate ¶

    func (m *CT_PrintSettings) Validate() error

Validate validates the CT_PrintSettings and its children

### func (*CT_PrintSettings) ValidateWithPath ¶

    func (m *CT_PrintSettings) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PrintSettings and its children, prefixing error messages with path

## type CT_Protection ¶

    type CT_Protection struct {
        // Chart Object
        ChartObject *CT_Boolean
        // Data Cannot Be Changed
        Data *CT_Boolean
        // Formatting
        Formatting *CT_Boolean
        // Selection
        Selection *CT_Boolean
        // User Interface
        UserInterface *CT_Boolean
    }

### func NewCT_Protection ¶

    func NewCT_Protection() *CT_Protection

### func (*CT_Protection) MarshalXML ¶

    func (m *CT_Protection) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Protection) UnmarshalXML ¶

    func (m *CT_Protection) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Protection) Validate ¶

    func (m *CT_Protection) Validate() error

Validate validates the CT_Protection and its children

### func (*CT_Protection) ValidateWithPath ¶

    func (m *CT_Protection) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Protection and its children, prefixing error messages with path

## type CT_RadarChart ¶

    type CT_RadarChart struct {
        // Radar Style
        RadarStyle *CT_RadarStyle
        VaryColors *CT_Boolean
        // Radar Chart Series
        Ser []*CT_RadarSer
        // Data Labels
        DLbls *CT_DLbls
        // Axis ID
        AxId []*CT_UnsignedInt
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_RadarChart ¶

    func NewCT_RadarChart() *CT_RadarChart

### func (*CT_RadarChart) MarshalXML ¶

    func (m *CT_RadarChart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_RadarChart) UnmarshalXML ¶

    func (m *CT_RadarChart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_RadarChart) Validate ¶

    func (m *CT_RadarChart) Validate() error

Validate validates the CT_RadarChart and its children

### func (*CT_RadarChart) ValidateWithPath ¶

    func (m *CT_RadarChart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RadarChart and its children, prefixing error messages with path

## type CT_RadarSer ¶

    type CT_RadarSer struct {
        // Index
        Idx *CT_UnsignedInt
        // Order
        Order *CT_UnsignedInt
        // Series Text
        Tx   *CT_SerTx
        SpPr *dml.CT_ShapeProperties
        // Marker
        Marker *CT_Marker
        // Data Point
        DPt []*CT_DPt
        // Data Labels
        DLbls *CT_DLbls
        // Category Axis Data
        Cat *CT_AxDataSource
        Val *CT_NumDataSource
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_RadarSer ¶

    func NewCT_RadarSer() *CT_RadarSer

### func (*CT_RadarSer) MarshalXML ¶

    func (m *CT_RadarSer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_RadarSer) UnmarshalXML ¶

    func (m *CT_RadarSer) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_RadarSer) Validate ¶

    func (m *CT_RadarSer) Validate() error

Validate validates the CT_RadarSer and its children

### func (*CT_RadarSer) ValidateWithPath ¶

    func (m *CT_RadarSer) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RadarSer and its children, prefixing error messages with path

## type CT_RadarStyle ¶

    type CT_RadarStyle struct {
        // Radar Style Value
        ValAttr ST_RadarStyle
    }

### func NewCT_RadarStyle ¶

    func NewCT_RadarStyle() *CT_RadarStyle

### func (*CT_RadarStyle) MarshalXML ¶

    func (m *CT_RadarStyle) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_RadarStyle) UnmarshalXML ¶

    func (m *CT_RadarStyle) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_RadarStyle) Validate ¶

    func (m *CT_RadarStyle) Validate() error

Validate validates the CT_RadarStyle and its children

### func (*CT_RadarStyle) ValidateWithPath ¶

    func (m *CT_RadarStyle) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RadarStyle and its children, prefixing error messages with path

## type CT_RelId ¶

    type CT_RelId struct {
        IdAttr string
    }

### func NewCT_RelId ¶

    func NewCT_RelId() *CT_RelId

### func (*CT_RelId) MarshalXML ¶

    func (m *CT_RelId) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_RelId) UnmarshalXML ¶

    func (m *CT_RelId) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_RelId) Validate ¶

    func (m *CT_RelId) Validate() error

Validate validates the CT_RelId and its children

### func (*CT_RelId) ValidateWithPath ¶

    func (m *CT_RelId) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RelId and its children, prefixing error messages with path

## type CT_RotX ¶

    type CT_RotX struct {
        // X Rotation Value
        ValAttr *int8
    }

### func NewCT_RotX ¶

    func NewCT_RotX() *CT_RotX

### func (*CT_RotX) MarshalXML ¶

    func (m *CT_RotX) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_RotX) UnmarshalXML ¶

    func (m *CT_RotX) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_RotX) Validate ¶

    func (m *CT_RotX) Validate() error

Validate validates the CT_RotX and its children

### func (*CT_RotX) ValidateWithPath ¶

    func (m *CT_RotX) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RotX and its children, prefixing error messages with path

## type CT_RotY ¶

    type CT_RotY struct {
        // Y Rotation Value
        ValAttr *uint16
    }

### func NewCT_RotY ¶

    func NewCT_RotY() *CT_RotY

### func (*CT_RotY) MarshalXML ¶

    func (m *CT_RotY) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_RotY) UnmarshalXML ¶

    func (m *CT_RotY) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_RotY) Validate ¶

    func (m *CT_RotY) Validate() error

Validate validates the CT_RotY and its children

### func (*CT_RotY) ValidateWithPath ¶

    func (m *CT_RotY) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RotY and its children, prefixing error messages with path

## type CT_Scaling ¶

    type CT_Scaling struct {
        // Logarithmic Base
        LogBase *CT_LogBase
        // Axis Orientation
        Orientation *CT_Orientation
        // Maximum
        Max *CT_Double
        // Minimum
        Min *CT_Double
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_Scaling ¶

    func NewCT_Scaling() *CT_Scaling

### func (*CT_Scaling) MarshalXML ¶

    func (m *CT_Scaling) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Scaling) UnmarshalXML ¶

    func (m *CT_Scaling) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Scaling) Validate ¶

    func (m *CT_Scaling) Validate() error

Validate validates the CT_Scaling and its children

### func (*CT_Scaling) ValidateWithPath ¶

    func (m *CT_Scaling) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Scaling and its children, prefixing error messages with path

## type CT_ScatterChart ¶

    type CT_ScatterChart struct {
        // Scatter Style
        ScatterStyle *CT_ScatterStyle
        // Vary Colors by Point
        VaryColors *CT_Boolean
        // Scatter Chart Series
        Ser []*CT_ScatterSer
        // Data Labels
        DLbls *CT_DLbls
        // Axis ID
        AxId []*CT_UnsignedInt
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_ScatterChart ¶

    func NewCT_ScatterChart() *CT_ScatterChart

### func (*CT_ScatterChart) MarshalXML ¶

    func (m *CT_ScatterChart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_ScatterChart) UnmarshalXML ¶

    func (m *CT_ScatterChart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_ScatterChart) Validate ¶

    func (m *CT_ScatterChart) Validate() error

Validate validates the CT_ScatterChart and its children

### func (*CT_ScatterChart) ValidateWithPath ¶

    func (m *CT_ScatterChart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ScatterChart and its children, prefixing error messages with path

## type CT_ScatterSer ¶

    type CT_ScatterSer struct {
        // Index
        Idx *CT_UnsignedInt
        // Order
        Order *CT_UnsignedInt
        // Series Text
        Tx   *CT_SerTx
        SpPr *dml.CT_ShapeProperties
        // Marker
        Marker *CT_Marker
        // Data Point
        DPt []*CT_DPt
        // Data Labels
        DLbls     *CT_DLbls
        Trendline []*CT_Trendline
        // Error Bars
        ErrBars []*CT_ErrBars
        XVal    *CT_AxDataSource
        YVal    *CT_NumDataSource
        // Smoothing
        Smooth *CT_Boolean
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_ScatterSer ¶

    func NewCT_ScatterSer() *CT_ScatterSer

### func (*CT_ScatterSer) MarshalXML ¶

    func (m *CT_ScatterSer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_ScatterSer) UnmarshalXML ¶

    func (m *CT_ScatterSer) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_ScatterSer) Validate ¶

    func (m *CT_ScatterSer) Validate() error

Validate validates the CT_ScatterSer and its children

### func (*CT_ScatterSer) ValidateWithPath ¶

    func (m *CT_ScatterSer) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ScatterSer and its children, prefixing error messages with path

## type CT_ScatterStyle ¶

    type CT_ScatterStyle struct {
        // Scatter Style Value
        ValAttr ST_ScatterStyle
    }

### func NewCT_ScatterStyle ¶

    func NewCT_ScatterStyle() *CT_ScatterStyle

### func (*CT_ScatterStyle) MarshalXML ¶

    func (m *CT_ScatterStyle) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_ScatterStyle) UnmarshalXML ¶

    func (m *CT_ScatterStyle) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_ScatterStyle) Validate ¶

    func (m *CT_ScatterStyle) Validate() error

Validate validates the CT_ScatterStyle and its children

### func (*CT_ScatterStyle) ValidateWithPath ¶

    func (m *CT_ScatterStyle) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ScatterStyle and its children, prefixing error messages with path

## type CT_SecondPieSize ¶

    type CT_SecondPieSize struct {
        // Second Pie Size Value
        ValAttr *ST_SecondPieSize
    }

### func NewCT_SecondPieSize ¶

    func NewCT_SecondPieSize() *CT_SecondPieSize

### func (*CT_SecondPieSize) MarshalXML ¶

    func (m *CT_SecondPieSize) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_SecondPieSize) UnmarshalXML ¶

    func (m *CT_SecondPieSize) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_SecondPieSize) Validate ¶

    func (m *CT_SecondPieSize) Validate() error

Validate validates the CT_SecondPieSize and its children

### func (*CT_SecondPieSize) ValidateWithPath ¶

    func (m *CT_SecondPieSize) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SecondPieSize and its children, prefixing error messages with path

## type CT_SerAx ¶

    type CT_SerAx struct {
        // Axis ID
        AxId *CT_UnsignedInt
        // Scaling
        Scaling *CT_Scaling
        // Delete
        Delete *CT_Boolean
        // Axis Position
        AxPos *CT_AxPos
        // Major Gridlines
        MajorGridlines *CT_ChartLines
        // Minor Gridlines
        MinorGridlines *CT_ChartLines
        // Title
        Title *CT_Title
        // Number Format
        NumFmt *CT_NumFmt
        // Major Tick Mark
        MajorTickMark *CT_TickMark
        // Minor Tick Mark
        MinorTickMark *CT_TickMark
        // Tick Label Position
        TickLblPos *CT_TickLblPos
        SpPr       *dml.CT_ShapeProperties
        TxPr       *dml.CT_TextBody
        // Crossing Axis ID
        CrossAx        *CT_UnsignedInt
        AxSharedChoice *EG_AxSharedChoice
        // Tick Label Skip
        TickLblSkip  *CT_Skip
        TickMarkSkip *CT_Skip
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_SerAx ¶

    func NewCT_SerAx() *CT_SerAx

### func (*CT_SerAx) MarshalXML ¶

    func (m *CT_SerAx) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_SerAx) UnmarshalXML ¶

    func (m *CT_SerAx) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_SerAx) Validate ¶

    func (m *CT_SerAx) Validate() error

Validate validates the CT_SerAx and its children

### func (*CT_SerAx) ValidateWithPath ¶

    func (m *CT_SerAx) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SerAx and its children, prefixing error messages with path

## type CT_SerTx ¶

    type CT_SerTx struct {
        SerTxChoice *CT_SerTxChoice
    }

### func NewCT_SerTx ¶

    func NewCT_SerTx() *CT_SerTx

### func (*CT_SerTx) MarshalXML ¶

    func (m *CT_SerTx) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_SerTx) UnmarshalXML ¶

    func (m *CT_SerTx) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_SerTx) Validate ¶

    func (m *CT_SerTx) Validate() error

Validate validates the CT_SerTx and its children

### func (*CT_SerTx) ValidateWithPath ¶

    func (m *CT_SerTx) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SerTx and its children, prefixing error messages with path

## type CT_SerTxChoice ¶

    type CT_SerTxChoice struct {
        StrRef *CT_StrRef
        V      *string
    }

### func NewCT_SerTxChoice ¶

    func NewCT_SerTxChoice() *CT_SerTxChoice

### func (*CT_SerTxChoice) MarshalXML ¶

    func (m *CT_SerTxChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_SerTxChoice) UnmarshalXML ¶

    func (m *CT_SerTxChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_SerTxChoice) Validate ¶

    func (m *CT_SerTxChoice) Validate() error

Validate validates the CT_SerTxChoice and its children

### func (*CT_SerTxChoice) ValidateWithPath ¶

    func (m *CT_SerTxChoice) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SerTxChoice and its children, prefixing error messages with path

## type CT_Shape ¶

    type CT_Shape struct {
        // Shape Value
        ValAttr ST_Shape
    }

### func NewCT_Shape ¶

    func NewCT_Shape() *CT_Shape

### func (*CT_Shape) MarshalXML ¶

    func (m *CT_Shape) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Shape) UnmarshalXML ¶

    func (m *CT_Shape) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Shape) Validate ¶

    func (m *CT_Shape) Validate() error

Validate validates the CT_Shape and its children

### func (*CT_Shape) ValidateWithPath ¶

    func (m *CT_Shape) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Shape and its children, prefixing error messages with path

## type CT_SizeRepresents ¶

    type CT_SizeRepresents struct {
        // Size Represents Value
        ValAttr ST_SizeRepresents
    }

### func NewCT_SizeRepresents ¶

    func NewCT_SizeRepresents() *CT_SizeRepresents

### func (*CT_SizeRepresents) MarshalXML ¶

    func (m *CT_SizeRepresents) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_SizeRepresents) UnmarshalXML ¶

    func (m *CT_SizeRepresents) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_SizeRepresents) Validate ¶

    func (m *CT_SizeRepresents) Validate() error

Validate validates the CT_SizeRepresents and its children

### func (*CT_SizeRepresents) ValidateWithPath ¶

    func (m *CT_SizeRepresents) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SizeRepresents and its children, prefixing error messages with path

## type CT_Skip ¶

    type CT_Skip struct {
        // Tick Skip Value
        ValAttr uint32
    }

### func NewCT_Skip ¶

    func NewCT_Skip() *CT_Skip

### func (*CT_Skip) MarshalXML ¶

    func (m *CT_Skip) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Skip) UnmarshalXML ¶

    func (m *CT_Skip) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Skip) Validate ¶

    func (m *CT_Skip) Validate() error

Validate validates the CT_Skip and its children

### func (*CT_Skip) ValidateWithPath ¶

    func (m *CT_Skip) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Skip and its children, prefixing error messages with path

## type CT_SplitType ¶

    type CT_SplitType struct {
        // Split Type Value
        ValAttr ST_SplitType
    }

### func NewCT_SplitType ¶

    func NewCT_SplitType() *CT_SplitType

### func (*CT_SplitType) MarshalXML ¶

    func (m *CT_SplitType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_SplitType) UnmarshalXML ¶

    func (m *CT_SplitType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_SplitType) Validate ¶

    func (m *CT_SplitType) Validate() error

Validate validates the CT_SplitType and its children

### func (*CT_SplitType) ValidateWithPath ¶

    func (m *CT_SplitType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SplitType and its children, prefixing error messages with path

## type CT_StockChart ¶

    type CT_StockChart struct {
        // Line Chart Series
        Ser []*CT_LineSer
        // Data Labels
        DLbls     *CT_DLbls
        DropLines *CT_ChartLines
        // High Low Lines
        HiLowLines *CT_ChartLines
        // Up/Down Bars
        UpDownBars *CT_UpDownBars
        // Axis ID
        AxId []*CT_UnsignedInt
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_StockChart ¶

    func NewCT_StockChart() *CT_StockChart

### func (*CT_StockChart) MarshalXML ¶

    func (m *CT_StockChart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_StockChart) UnmarshalXML ¶

    func (m *CT_StockChart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_StockChart) Validate ¶

    func (m *CT_StockChart) Validate() error

Validate validates the CT_StockChart and its children

### func (*CT_StockChart) ValidateWithPath ¶

    func (m *CT_StockChart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_StockChart and its children, prefixing error messages with path

## type CT_StrData ¶

    type CT_StrData struct {
        PtCount *CT_UnsignedInt
        Pt      []*CT_StrVal
        ExtLst  *CT_ExtensionList
    }

### func NewCT_StrData ¶

    func NewCT_StrData() *CT_StrData

### func (*CT_StrData) MarshalXML ¶

    func (m *CT_StrData) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_StrData) UnmarshalXML ¶

    func (m *CT_StrData) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_StrData) Validate ¶

    func (m *CT_StrData) Validate() error

Validate validates the CT_StrData and its children

### func (*CT_StrData) ValidateWithPath ¶

    func (m *CT_StrData) ValidateWithPath(path string) error

ValidateWithPath validates the CT_StrData and its children, prefixing error messages with path

## type CT_StrRef ¶

    type CT_StrRef struct {
        // Formula
        F string
        // String Cache
        StrCache *CT_StrData
        ExtLst   *CT_ExtensionList
    }

### func NewCT_StrRef ¶

    func NewCT_StrRef() *CT_StrRef

### func (*CT_StrRef) MarshalXML ¶

    func (m *CT_StrRef) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_StrRef) UnmarshalXML ¶

    func (m *CT_StrRef) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_StrRef) Validate ¶

    func (m *CT_StrRef) Validate() error

Validate validates the CT_StrRef and its children

### func (*CT_StrRef) ValidateWithPath ¶

    func (m *CT_StrRef) ValidateWithPath(path string) error

ValidateWithPath validates the CT_StrRef and its children, prefixing error messages with path

## type CT_StrVal ¶

    type CT_StrVal struct {
        // Index
        IdxAttr uint32
        // Text Value
        V string
    }

### func NewCT_StrVal ¶

    func NewCT_StrVal() *CT_StrVal

### func (*CT_StrVal) MarshalXML ¶

    func (m *CT_StrVal) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_StrVal) UnmarshalXML ¶

    func (m *CT_StrVal) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_StrVal) Validate ¶

    func (m *CT_StrVal) Validate() error

Validate validates the CT_StrVal and its children

### func (*CT_StrVal) ValidateWithPath ¶

    func (m *CT_StrVal) ValidateWithPath(path string) error

ValidateWithPath validates the CT_StrVal and its children, prefixing error messages with path

## type CT_Style ¶

    type CT_Style struct {
        // Style Type
        ValAttr uint8
    }

### func NewCT_Style ¶

    func NewCT_Style() *CT_Style

### func (*CT_Style) MarshalXML ¶

    func (m *CT_Style) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Style) UnmarshalXML ¶

    func (m *CT_Style) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Style) Validate ¶

    func (m *CT_Style) Validate() error

Validate validates the CT_Style and its children

### func (*CT_Style) ValidateWithPath ¶

    func (m *CT_Style) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Style and its children, prefixing error messages with path

## type CT_Surface ¶

    type CT_Surface struct {
        // Thickness
        Thickness *CT_Thickness
        SpPr      *dml.CT_ShapeProperties
        // Picture Options
        PictureOptions *CT_PictureOptions
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_Surface ¶

    func NewCT_Surface() *CT_Surface

### func (*CT_Surface) MarshalXML ¶

    func (m *CT_Surface) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Surface) UnmarshalXML ¶

    func (m *CT_Surface) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Surface) Validate ¶

    func (m *CT_Surface) Validate() error

Validate validates the CT_Surface and its children

### func (*CT_Surface) ValidateWithPath ¶

    func (m *CT_Surface) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Surface and its children, prefixing error messages with path

## type CT_Surface3DChart ¶

    type CT_Surface3DChart struct {
        // Wireframe
        Wireframe *CT_Boolean
        // Surface Chart Series
        Ser []*CT_SurfaceSer
        // Band Formats
        BandFmts *CT_BandFmts
        // Axis ID
        AxId []*CT_UnsignedInt
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_Surface3DChart ¶

    func NewCT_Surface3DChart() *CT_Surface3DChart

### func (*CT_Surface3DChart) MarshalXML ¶

    func (m *CT_Surface3DChart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Surface3DChart) UnmarshalXML ¶

    func (m *CT_Surface3DChart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Surface3DChart) Validate ¶

    func (m *CT_Surface3DChart) Validate() error

Validate validates the CT_Surface3DChart and its children

### func (*CT_Surface3DChart) ValidateWithPath ¶

    func (m *CT_Surface3DChart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Surface3DChart and its children, prefixing error messages with path

## type CT_SurfaceChart ¶

    type CT_SurfaceChart struct {
        // Wireframe
        Wireframe *CT_Boolean
        // Surface Chart Series
        Ser []*CT_SurfaceSer
        // Band Formats
        BandFmts *CT_BandFmts
        // Axis ID
        AxId []*CT_UnsignedInt
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_SurfaceChart ¶

    func NewCT_SurfaceChart() *CT_SurfaceChart

### func (*CT_SurfaceChart) MarshalXML ¶

    func (m *CT_SurfaceChart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_SurfaceChart) UnmarshalXML ¶

    func (m *CT_SurfaceChart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_SurfaceChart) Validate ¶

    func (m *CT_SurfaceChart) Validate() error

Validate validates the CT_SurfaceChart and its children

### func (*CT_SurfaceChart) ValidateWithPath ¶

    func (m *CT_SurfaceChart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SurfaceChart and its children, prefixing error messages with path

## type CT_SurfaceSer ¶

    type CT_SurfaceSer struct {
        // Index
        Idx *CT_UnsignedInt
        // Order
        Order *CT_UnsignedInt
        // Series Text
        Tx   *CT_SerTx
        SpPr *dml.CT_ShapeProperties
        // Category Axis Data
        Cat *CT_AxDataSource
        Val *CT_NumDataSource
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_SurfaceSer ¶

    func NewCT_SurfaceSer() *CT_SurfaceSer

### func (*CT_SurfaceSer) MarshalXML ¶

    func (m *CT_SurfaceSer) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_SurfaceSer) UnmarshalXML ¶

    func (m *CT_SurfaceSer) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_SurfaceSer) Validate ¶

    func (m *CT_SurfaceSer) Validate() error

Validate validates the CT_SurfaceSer and its children

### func (*CT_SurfaceSer) ValidateWithPath ¶

    func (m *CT_SurfaceSer) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SurfaceSer and its children, prefixing error messages with path

## type CT_TextLanguageID ¶

    type CT_TextLanguageID struct {
        // Language Code
        ValAttr string
    }

### func NewCT_TextLanguageID ¶

    func NewCT_TextLanguageID() *CT_TextLanguageID

### func (*CT_TextLanguageID) MarshalXML ¶

    func (m *CT_TextLanguageID) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_TextLanguageID) UnmarshalXML ¶

    func (m *CT_TextLanguageID) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_TextLanguageID) Validate ¶

    func (m *CT_TextLanguageID) Validate() error

Validate validates the CT_TextLanguageID and its children

### func (*CT_TextLanguageID) ValidateWithPath ¶

    func (m *CT_TextLanguageID) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TextLanguageID and its children, prefixing error messages with path

## type CT_Thickness ¶

    type CT_Thickness struct {
        ValAttr ST_Thickness
    }

### func NewCT_Thickness ¶

    func NewCT_Thickness() *CT_Thickness

### func (*CT_Thickness) MarshalXML ¶

    func (m *CT_Thickness) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Thickness) UnmarshalXML ¶

    func (m *CT_Thickness) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Thickness) Validate ¶

    func (m *CT_Thickness) Validate() error

Validate validates the CT_Thickness and its children

### func (*CT_Thickness) ValidateWithPath ¶

    func (m *CT_Thickness) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Thickness and its children, prefixing error messages with path

## type CT_TickLblPos ¶

    type CT_TickLblPos struct {
        // Tick Label Position Value
        ValAttr ST_TickLblPos
    }

### func NewCT_TickLblPos ¶

    func NewCT_TickLblPos() *CT_TickLblPos

### func (*CT_TickLblPos) MarshalXML ¶

    func (m *CT_TickLblPos) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_TickLblPos) UnmarshalXML ¶

    func (m *CT_TickLblPos) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_TickLblPos) Validate ¶

    func (m *CT_TickLblPos) Validate() error

Validate validates the CT_TickLblPos and its children

### func (*CT_TickLblPos) ValidateWithPath ¶

    func (m *CT_TickLblPos) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TickLblPos and its children, prefixing error messages with path

## type CT_TickMark ¶

    type CT_TickMark struct {
        // Tick Mark Value
        ValAttr ST_TickMark
    }

### func NewCT_TickMark ¶

    func NewCT_TickMark() *CT_TickMark

### func (*CT_TickMark) MarshalXML ¶

    func (m *CT_TickMark) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_TickMark) UnmarshalXML ¶

    func (m *CT_TickMark) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_TickMark) Validate ¶

    func (m *CT_TickMark) Validate() error

Validate validates the CT_TickMark and its children

### func (*CT_TickMark) ValidateWithPath ¶

    func (m *CT_TickMark) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TickMark and its children, prefixing error messages with path

## type CT_TimeUnit ¶

    type CT_TimeUnit struct {
        // Time Unit Value
        ValAttr ST_TimeUnit
    }

### func NewCT_TimeUnit ¶

    func NewCT_TimeUnit() *CT_TimeUnit

### func (*CT_TimeUnit) MarshalXML ¶

    func (m *CT_TimeUnit) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_TimeUnit) UnmarshalXML ¶

    func (m *CT_TimeUnit) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_TimeUnit) Validate ¶

    func (m *CT_TimeUnit) Validate() error

Validate validates the CT_TimeUnit and its children

### func (*CT_TimeUnit) ValidateWithPath ¶

    func (m *CT_TimeUnit) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TimeUnit and its children, prefixing error messages with path

## type CT_Title ¶

    type CT_Title struct {
        // Chart Text
        Tx *CT_Tx
        // Layout
        Layout *CT_Layout
        // Overlay
        Overlay *CT_Boolean
        SpPr    *dml.CT_ShapeProperties
        TxPr    *dml.CT_TextBody
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_Title ¶

    func NewCT_Title() *CT_Title

### func (*CT_Title) MarshalXML ¶

    func (m *CT_Title) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Title) UnmarshalXML ¶

    func (m *CT_Title) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Title) Validate ¶

    func (m *CT_Title) Validate() error

Validate validates the CT_Title and its children

### func (*CT_Title) ValidateWithPath ¶

    func (m *CT_Title) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Title and its children, prefixing error messages with path

## type CT_Trendline ¶

    type CT_Trendline struct {
        // Trendline Name
        Name *string
        SpPr *dml.CT_ShapeProperties
        // Trendline Type
        TrendlineType *CT_TrendlineType
        // Polynomial Trendline Order
        Order *CT_Order
        // Period
        Period *CT_Period
        // Forward
        Forward *CT_Double
        // Backward
        Backward *CT_Double
        // Intercept
        Intercept *CT_Double
        // Display R Squared Value
        DispRSqr *CT_Boolean
        // Display Equation
        DispEq *CT_Boolean
        // Trendline Label
        TrendlineLbl *CT_TrendlineLbl
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_Trendline ¶

    func NewCT_Trendline() *CT_Trendline

### func (*CT_Trendline) MarshalXML ¶

    func (m *CT_Trendline) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Trendline) UnmarshalXML ¶

    func (m *CT_Trendline) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Trendline) Validate ¶

    func (m *CT_Trendline) Validate() error

Validate validates the CT_Trendline and its children

### func (*CT_Trendline) ValidateWithPath ¶

    func (m *CT_Trendline) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Trendline and its children, prefixing error messages with path

## type CT_TrendlineLbl ¶

    type CT_TrendlineLbl struct {
        // Layout
        Layout *CT_Layout
        Tx     *CT_Tx
        // Number Format
        NumFmt *CT_NumFmt
        SpPr   *dml.CT_ShapeProperties
        TxPr   *dml.CT_TextBody
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_TrendlineLbl ¶

    func NewCT_TrendlineLbl() *CT_TrendlineLbl

### func (*CT_TrendlineLbl) MarshalXML ¶

    func (m *CT_TrendlineLbl) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_TrendlineLbl) UnmarshalXML ¶

    func (m *CT_TrendlineLbl) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_TrendlineLbl) Validate ¶

    func (m *CT_TrendlineLbl) Validate() error

Validate validates the CT_TrendlineLbl and its children

### func (*CT_TrendlineLbl) ValidateWithPath ¶

    func (m *CT_TrendlineLbl) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TrendlineLbl and its children, prefixing error messages with path

## type CT_TrendlineType ¶

    type CT_TrendlineType struct {
        // Trendline Type Value
        ValAttr ST_TrendlineType
    }

### func NewCT_TrendlineType ¶

    func NewCT_TrendlineType() *CT_TrendlineType

### func (*CT_TrendlineType) MarshalXML ¶

    func (m *CT_TrendlineType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_TrendlineType) UnmarshalXML ¶

    func (m *CT_TrendlineType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_TrendlineType) Validate ¶

    func (m *CT_TrendlineType) Validate() error

Validate validates the CT_TrendlineType and its children

### func (*CT_TrendlineType) ValidateWithPath ¶

    func (m *CT_TrendlineType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TrendlineType and its children, prefixing error messages with path

## type CT_Tx ¶

    type CT_Tx struct {
        TxChoice *CT_TxChoice
    }

### func NewCT_Tx ¶

    func NewCT_Tx() *CT_Tx

### func (*CT_Tx) MarshalXML ¶

    func (m *CT_Tx) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_Tx) UnmarshalXML ¶

    func (m *CT_Tx) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_Tx) Validate ¶

    func (m *CT_Tx) Validate() error

Validate validates the CT_Tx and its children

### func (*CT_Tx) ValidateWithPath ¶

    func (m *CT_Tx) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Tx and its children, prefixing error messages with path

## type CT_TxChoice ¶

    type CT_TxChoice struct {
        StrRef *CT_StrRef
        Rich   *dml.CT_TextBody
    }

### func NewCT_TxChoice ¶

    func NewCT_TxChoice() *CT_TxChoice

### func (*CT_TxChoice) MarshalXML ¶

    func (m *CT_TxChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_TxChoice) UnmarshalXML ¶

    func (m *CT_TxChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_TxChoice) Validate ¶

    func (m *CT_TxChoice) Validate() error

Validate validates the CT_TxChoice and its children

### func (*CT_TxChoice) ValidateWithPath ¶

    func (m *CT_TxChoice) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TxChoice and its children, prefixing error messages with path

## type CT_UnsignedInt ¶

    type CT_UnsignedInt struct {
        // Integer Value
        ValAttr uint32
    }

### func NewCT_UnsignedInt ¶

    func NewCT_UnsignedInt() *CT_UnsignedInt

### func (*CT_UnsignedInt) MarshalXML ¶

    func (m *CT_UnsignedInt) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_UnsignedInt) UnmarshalXML ¶

    func (m *CT_UnsignedInt) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_UnsignedInt) Validate ¶

    func (m *CT_UnsignedInt) Validate() error

Validate validates the CT_UnsignedInt and its children

### func (*CT_UnsignedInt) ValidateWithPath ¶

    func (m *CT_UnsignedInt) ValidateWithPath(path string) error

ValidateWithPath validates the CT_UnsignedInt and its children, prefixing error messages with path

## type CT_UpDownBar ¶

    type CT_UpDownBar struct {
        SpPr *dml.CT_ShapeProperties
    }

### func NewCT_UpDownBar ¶

    func NewCT_UpDownBar() *CT_UpDownBar

### func (*CT_UpDownBar) MarshalXML ¶

    func (m *CT_UpDownBar) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_UpDownBar) UnmarshalXML ¶

    func (m *CT_UpDownBar) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_UpDownBar) Validate ¶

    func (m *CT_UpDownBar) Validate() error

Validate validates the CT_UpDownBar and its children

### func (*CT_UpDownBar) ValidateWithPath ¶

    func (m *CT_UpDownBar) ValidateWithPath(path string) error

ValidateWithPath validates the CT_UpDownBar and its children, prefixing error messages with path

## type CT_UpDownBars ¶

    type CT_UpDownBars struct {
        // Gap Width
        GapWidth *CT_GapAmount
        // Up Bars
        UpBars *CT_UpDownBar
        // Down Bars
        DownBars *CT_UpDownBar
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_UpDownBars ¶

    func NewCT_UpDownBars() *CT_UpDownBars

### func (*CT_UpDownBars) MarshalXML ¶

    func (m *CT_UpDownBars) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_UpDownBars) UnmarshalXML ¶

    func (m *CT_UpDownBars) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_UpDownBars) Validate ¶

    func (m *CT_UpDownBars) Validate() error

Validate validates the CT_UpDownBars and its children

### func (*CT_UpDownBars) ValidateWithPath ¶

    func (m *CT_UpDownBars) ValidateWithPath(path string) error

ValidateWithPath validates the CT_UpDownBars and its children, prefixing error messages with path

## type CT_ValAx ¶

    type CT_ValAx struct {
        // Axis ID
        AxId *CT_UnsignedInt
        // Scaling
        Scaling *CT_Scaling
        // Delete
        Delete *CT_Boolean
        // Axis Position
        AxPos *CT_AxPos
        // Major Gridlines
        MajorGridlines *CT_ChartLines
        // Minor Gridlines
        MinorGridlines *CT_ChartLines
        // Title
        Title *CT_Title
        // Number Format
        NumFmt *CT_NumFmt
        // Major Tick Mark
        MajorTickMark *CT_TickMark
        // Minor Tick Mark
        MinorTickMark *CT_TickMark
        // Tick Label Position
        TickLblPos *CT_TickLblPos
        SpPr       *dml.CT_ShapeProperties
        TxPr       *dml.CT_TextBody
        // Crossing Axis ID
        CrossAx        *CT_UnsignedInt
        AxSharedChoice *EG_AxSharedChoice
        // Cross Between
        CrossBetween *CT_CrossBetween
        // Major Unit
        MajorUnit *CT_AxisUnit
        // Minor Unit
        MinorUnit *CT_AxisUnit
        // Display Units
        DispUnits *CT_DispUnits
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_ValAx ¶

    func NewCT_ValAx() *CT_ValAx

### func (*CT_ValAx) MarshalXML ¶

    func (m *CT_ValAx) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_ValAx) UnmarshalXML ¶

    func (m *CT_ValAx) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_ValAx) Validate ¶

    func (m *CT_ValAx) Validate() error

Validate validates the CT_ValAx and its children

### func (*CT_ValAx) ValidateWithPath ¶

    func (m *CT_ValAx) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ValAx and its children, prefixing error messages with path

## type CT_View3D ¶

    type CT_View3D struct {
        // X Rotation
        RotX *CT_RotX
        // Height Percent
        HPercent *CT_HPercent
        // Y Rotation
        RotY *CT_RotY
        // Depth Percent
        DepthPercent *CT_DepthPercent
        // Right Angle Axes
        RAngAx *CT_Boolean
        // Perspective
        Perspective *CT_Perspective
        // Chart Extensibility
        ExtLst *CT_ExtensionList
    }

### func NewCT_View3D ¶

    func NewCT_View3D() *CT_View3D

### func (*CT_View3D) MarshalXML ¶

    func (m *CT_View3D) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*CT_View3D) UnmarshalXML ¶

    func (m *CT_View3D) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*CT_View3D) Validate ¶

    func (m *CT_View3D) Validate() error

Validate validates the CT_View3D and its children

### func (*CT_View3D) ValidateWithPath ¶

    func (m *CT_View3D) ValidateWithPath(path string) error

ValidateWithPath validates the CT_View3D and its children, prefixing error messages with path

## type Chart ¶

    type Chart struct {
        CT_RelId
    }

### func NewChart ¶

    func NewChart() *Chart

### func (*Chart) MarshalXML ¶

    func (m *Chart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*Chart) UnmarshalXML ¶

    func (m *Chart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*Chart) Validate ¶

    func (m *Chart) Validate() error

Validate validates the Chart and its children

### func (*Chart) ValidateWithPath ¶

    func (m *Chart) ValidateWithPath(path string) error

ValidateWithPath validates the Chart and its children, prefixing error messages with path

## type ChartSpace ¶

    type ChartSpace struct {
        CT_ChartSpace
    }

### func NewChartSpace ¶

    func NewChartSpace() *ChartSpace

### func (*ChartSpace) MarshalXML ¶

    func (m *ChartSpace) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*ChartSpace) UnmarshalXML ¶

    func (m *ChartSpace) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ChartSpace) Validate ¶

    func (m *ChartSpace) Validate() error

Validate validates the ChartSpace and its children

### func (*ChartSpace) ValidateWithPath ¶

    func (m *ChartSpace) ValidateWithPath(path string) error

ValidateWithPath validates the ChartSpace and its children, prefixing error messages with path

## type EG_AreaChartShared ¶

    type EG_AreaChartShared struct {
        // Grouping
        Grouping   *CT_Grouping
        VaryColors *CT_Boolean
        // Area Chart Series
        Ser []*CT_AreaSer
        // Data Labels
        DLbls *CT_DLbls
        // Drop Lines
        DropLines *CT_ChartLines
    }

### func NewEG_AreaChartShared ¶

    func NewEG_AreaChartShared() *EG_AreaChartShared

### func (*EG_AreaChartShared) MarshalXML ¶

    func (m *EG_AreaChartShared) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*EG_AreaChartShared) UnmarshalXML ¶

    func (m *EG_AreaChartShared) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*EG_AreaChartShared) Validate ¶

    func (m *EG_AreaChartShared) Validate() error

Validate validates the EG_AreaChartShared and its children

### func (*EG_AreaChartShared) ValidateWithPath ¶

    func (m *EG_AreaChartShared) ValidateWithPath(path string) error

ValidateWithPath validates the EG_AreaChartShared and its children, prefixing error messages with path

## type EG_AxShared ¶

    type EG_AxShared struct {
        // Axis ID
        AxId *CT_UnsignedInt
        // Scaling
        Scaling *CT_Scaling
        // Delete
        Delete *CT_Boolean
        // Axis Position
        AxPos *CT_AxPos
        // Major Gridlines
        MajorGridlines *CT_ChartLines
        // Minor Gridlines
        MinorGridlines *CT_ChartLines
        // Title
        Title *CT_Title
        // Number Format
        NumFmt *CT_NumFmt
        // Major Tick Mark
        MajorTickMark *CT_TickMark
        // Minor Tick Mark
        MinorTickMark *CT_TickMark
        // Tick Label Position
        TickLblPos *CT_TickLblPos
        SpPr       *dml.CT_ShapeProperties
        TxPr       *dml.CT_TextBody
        // Crossing Axis ID
        CrossAx        *CT_UnsignedInt
        AxSharedChoice *EG_AxSharedChoice
    }

### func NewEG_AxShared ¶

    func NewEG_AxShared() *EG_AxShared

### func (*EG_AxShared) MarshalXML ¶

    func (m *EG_AxShared) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*EG_AxShared) UnmarshalXML ¶

    func (m *EG_AxShared) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*EG_AxShared) Validate ¶

    func (m *EG_AxShared) Validate() error

Validate validates the EG_AxShared and its children

### func (*EG_AxShared) ValidateWithPath ¶

    func (m *EG_AxShared) ValidateWithPath(path string) error

ValidateWithPath validates the EG_AxShared and its children, prefixing error messages with path

## type EG_AxSharedChoice ¶

    type EG_AxSharedChoice struct {
        Crosses   *CT_Crosses
        CrossesAt *CT_Double
    }

### func NewEG_AxSharedChoice ¶

    func NewEG_AxSharedChoice() *EG_AxSharedChoice

### func (*EG_AxSharedChoice) MarshalXML ¶

    func (m *EG_AxSharedChoice) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*EG_AxSharedChoice) UnmarshalXML ¶

    func (m *EG_AxSharedChoice) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*EG_AxSharedChoice) Validate ¶

    func (m *EG_AxSharedChoice) Validate() error

Validate validates the EG_AxSharedChoice and its children

### func (*EG_AxSharedChoice) ValidateWithPath ¶

    func (m *EG_AxSharedChoice) ValidateWithPath(path string) error

ValidateWithPath validates the EG_AxSharedChoice and its children, prefixing error messages with path

## type EG_BarChartShared ¶

    type EG_BarChartShared struct {
        // Bar Direction
        BarDir *CT_BarDir
        // Bar Grouping
        Grouping   *CT_BarGrouping
        VaryColors *CT_Boolean
        // Bar Chart Series
        Ser []*CT_BarSer
        // Data Labels
        DLbls *CT_DLbls
    }

### func NewEG_BarChartShared ¶

    func NewEG_BarChartShared() *EG_BarChartShared

### func (*EG_BarChartShared) MarshalXML ¶

    func (m *EG_BarChartShared) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*EG_BarChartShared) UnmarshalXML ¶

    func (m *EG_BarChartShared) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*EG_BarChartShared) Validate ¶

    func (m *EG_BarChartShared) Validate() error

Validate validates the EG_BarChartShared and its children

### func (*EG_BarChartShared) ValidateWithPath ¶

    func (m *EG_BarChartShared) ValidateWithPath(path string) error

ValidateWithPath validates the EG_BarChartShared and its children, prefixing error messages with path

## type EG_DLblShared ¶

    type EG_DLblShared struct {
        // Number Format
        NumFmt *CT_NumFmt
        SpPr   *dml.CT_ShapeProperties
        TxPr   *dml.CT_TextBody
        // Data Label Position
        DLblPos *CT_DLblPos
        // Show Legend Key
        ShowLegendKey *CT_Boolean
        // Show Value
        ShowVal *CT_Boolean
        // Show Category Name
        ShowCatName *CT_Boolean
        // Show Series Name
        ShowSerName *CT_Boolean
        // Show Percent
        ShowPercent *CT_Boolean
        // Show Bubble Size
        ShowBubbleSize *CT_Boolean
        // Separator
        Separator *string
    }

### func NewEG_DLblShared ¶

    func NewEG_DLblShared() *EG_DLblShared

### func (*EG_DLblShared) MarshalXML ¶

    func (m *EG_DLblShared) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*EG_DLblShared) UnmarshalXML ¶

    func (m *EG_DLblShared) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*EG_DLblShared) Validate ¶

    func (m *EG_DLblShared) Validate() error

Validate validates the EG_DLblShared and its children

### func (*EG_DLblShared) ValidateWithPath ¶

    func (m *EG_DLblShared) ValidateWithPath(path string) error

ValidateWithPath validates the EG_DLblShared and its children, prefixing error messages with path

## type EG_LegendEntryData ¶

    type EG_LegendEntryData struct {
        TxPr *dml.CT_TextBody
    }

### func NewEG_LegendEntryData ¶

    func NewEG_LegendEntryData() *EG_LegendEntryData

### func (*EG_LegendEntryData) MarshalXML ¶

    func (m *EG_LegendEntryData) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*EG_LegendEntryData) UnmarshalXML ¶

    func (m *EG_LegendEntryData) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*EG_LegendEntryData) Validate ¶

    func (m *EG_LegendEntryData) Validate() error

Validate validates the EG_LegendEntryData and its children

### func (*EG_LegendEntryData) ValidateWithPath ¶

    func (m *EG_LegendEntryData) ValidateWithPath(path string) error

ValidateWithPath validates the EG_LegendEntryData and its children, prefixing error messages with path

## type EG_LineChartShared ¶

    type EG_LineChartShared struct {
        // Grouping
        Grouping   *CT_Grouping
        VaryColors *CT_Boolean
        Ser        []*CT_LineSer
        // Data Labels
        DLbls *CT_DLbls
        // Drop Lines
        DropLines *CT_ChartLines
    }

### func NewEG_LineChartShared ¶

    func NewEG_LineChartShared() *EG_LineChartShared

### func (*EG_LineChartShared) MarshalXML ¶

    func (m *EG_LineChartShared) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*EG_LineChartShared) UnmarshalXML ¶

    func (m *EG_LineChartShared) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*EG_LineChartShared) Validate ¶

    func (m *EG_LineChartShared) Validate() error

Validate validates the EG_LineChartShared and its children

### func (*EG_LineChartShared) ValidateWithPath ¶

    func (m *EG_LineChartShared) ValidateWithPath(path string) error

ValidateWithPath validates the EG_LineChartShared and its children, prefixing error messages with path

## type EG_PieChartShared ¶

    type EG_PieChartShared struct {
        VaryColors *CT_Boolean
        // Pie Chart Series
        Ser []*CT_PieSer
        // Data Labels
        DLbls *CT_DLbls
    }

### func NewEG_PieChartShared ¶

    func NewEG_PieChartShared() *EG_PieChartShared

### func (*EG_PieChartShared) MarshalXML ¶

    func (m *EG_PieChartShared) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*EG_PieChartShared) UnmarshalXML ¶

    func (m *EG_PieChartShared) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*EG_PieChartShared) Validate ¶

    func (m *EG_PieChartShared) Validate() error

Validate validates the EG_PieChartShared and its children

### func (*EG_PieChartShared) ValidateWithPath ¶

    func (m *EG_PieChartShared) ValidateWithPath(path string) error

ValidateWithPath validates the EG_PieChartShared and its children, prefixing error messages with path

## type EG_SerShared ¶

    type EG_SerShared struct {
        // Index
        Idx *CT_UnsignedInt
        // Order
        Order *CT_UnsignedInt
        // Series Text
        Tx   *CT_SerTx
        SpPr *dml.CT_ShapeProperties
    }

### func NewEG_SerShared ¶

    func NewEG_SerShared() *EG_SerShared

### func (*EG_SerShared) MarshalXML ¶

    func (m *EG_SerShared) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*EG_SerShared) UnmarshalXML ¶

    func (m *EG_SerShared) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*EG_SerShared) Validate ¶

    func (m *EG_SerShared) Validate() error

Validate validates the EG_SerShared and its children

### func (*EG_SerShared) ValidateWithPath ¶

    func (m *EG_SerShared) ValidateWithPath(path string) error

ValidateWithPath validates the EG_SerShared and its children, prefixing error messages with path

## type EG_SurfaceChartShared ¶

    type EG_SurfaceChartShared struct {
        // Wireframe
        Wireframe *CT_Boolean
        // Surface Chart Series
        Ser []*CT_SurfaceSer
        // Band Formats
        BandFmts *CT_BandFmts
    }

### func NewEG_SurfaceChartShared ¶

    func NewEG_SurfaceChartShared() *EG_SurfaceChartShared

### func (*EG_SurfaceChartShared) MarshalXML ¶

    func (m *EG_SurfaceChartShared) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*EG_SurfaceChartShared) UnmarshalXML ¶

    func (m *EG_SurfaceChartShared) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*EG_SurfaceChartShared) Validate ¶

    func (m *EG_SurfaceChartShared) Validate() error

Validate validates the EG_SurfaceChartShared and its children

### func (*EG_SurfaceChartShared) ValidateWithPath ¶

    func (m *EG_SurfaceChartShared) ValidateWithPath(path string) error

ValidateWithPath validates the EG_SurfaceChartShared and its children, prefixing error messages with path

## type Group_DLbl ¶

    type Group_DLbl struct {
        // Layout
        Layout *CT_Layout
        Tx     *CT_Tx
        // Number Format
        NumFmt *CT_NumFmt
        SpPr   *dml.CT_ShapeProperties
        TxPr   *dml.CT_TextBody
        // Data Label Position
        DLblPos *CT_DLblPos
        // Show Legend Key
        ShowLegendKey *CT_Boolean
        // Show Value
        ShowVal *CT_Boolean
        // Show Category Name
        ShowCatName *CT_Boolean
        // Show Series Name
        ShowSerName *CT_Boolean
        // Show Percent
        ShowPercent *CT_Boolean
        // Show Bubble Size
        ShowBubbleSize *CT_Boolean
        // Separator
        Separator *string
    }

### func NewGroup_DLbl ¶

    func NewGroup_DLbl() *Group_DLbl

### func (*Group_DLbl) MarshalXML ¶

    func (m *Group_DLbl) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*Group_DLbl) UnmarshalXML ¶

    func (m *Group_DLbl) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*Group_DLbl) Validate ¶

    func (m *Group_DLbl) Validate() error

Validate validates the Group_DLbl and its children

### func (*Group_DLbl) ValidateWithPath ¶

    func (m *Group_DLbl) ValidateWithPath(path string) error

ValidateWithPath validates the Group_DLbl and its children, prefixing error messages with path

## type Group_DLbls ¶

    type Group_DLbls struct {
        // Number Format
        NumFmt *CT_NumFmt
        SpPr   *dml.CT_ShapeProperties
        TxPr   *dml.CT_TextBody
        // Data Label Position
        DLblPos *CT_DLblPos
        // Show Legend Key
        ShowLegendKey *CT_Boolean
        // Show Value
        ShowVal *CT_Boolean
        // Show Category Name
        ShowCatName *CT_Boolean
        // Show Series Name
        ShowSerName *CT_Boolean
        // Show Percent
        ShowPercent *CT_Boolean
        // Show Bubble Size
        ShowBubbleSize *CT_Boolean
        // Separator
        Separator *string
        // Show Leader Lines
        ShowLeaderLines *CT_Boolean
        // Leader Lines
        LeaderLines *CT_ChartLines
    }

### func NewGroup_DLbls ¶

    func NewGroup_DLbls() *Group_DLbls

### func (*Group_DLbls) MarshalXML ¶

    func (m *Group_DLbls) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*Group_DLbls) UnmarshalXML ¶

    func (m *Group_DLbls) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*Group_DLbls) Validate ¶

    func (m *Group_DLbls) Validate() error

Validate validates the Group_DLbls and its children

### func (*Group_DLbls) ValidateWithPath ¶

    func (m *Group_DLbls) ValidateWithPath(path string) error

ValidateWithPath validates the Group_DLbls and its children, prefixing error messages with path

## type ST_AxPos ¶

    type ST_AxPos byte

    const (
        ST_AxPosUnset ST_AxPos = 0
        ST_AxPosB     ST_AxPos = 1
        ST_AxPosL     ST_AxPos = 2
        ST_AxPosR     ST_AxPos = 3
        ST_AxPosT     ST_AxPos = 4
    )

### func (ST_AxPos) MarshalXML ¶

    func (m ST_AxPos) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_AxPos) MarshalXMLAttr ¶

    func (e ST_AxPos) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_AxPos) String ¶

    func (m ST_AxPos) String() string

### func (*ST_AxPos) UnmarshalXML ¶

    func (m *ST_AxPos) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_AxPos) UnmarshalXMLAttr ¶

    func (e *ST_AxPos) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_AxPos) Validate ¶

    func (m ST_AxPos) Validate() error

### func (ST_AxPos) ValidateWithPath ¶

    func (m ST_AxPos) ValidateWithPath(path string) error

## type ST_BarDir ¶

    type ST_BarDir byte

    const (
        ST_BarDirUnset ST_BarDir = 0
        ST_BarDirBar   ST_BarDir = 1
        ST_BarDirCol   ST_BarDir = 2
    )

### func (ST_BarDir) MarshalXML ¶

    func (m ST_BarDir) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_BarDir) MarshalXMLAttr ¶

    func (e ST_BarDir) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_BarDir) String ¶

    func (m ST_BarDir) String() string

### func (*ST_BarDir) UnmarshalXML ¶

    func (m *ST_BarDir) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_BarDir) UnmarshalXMLAttr ¶

    func (e *ST_BarDir) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_BarDir) Validate ¶

    func (m ST_BarDir) Validate() error

### func (ST_BarDir) ValidateWithPath ¶

    func (m ST_BarDir) ValidateWithPath(path string) error

## type ST_BarGrouping ¶

    type ST_BarGrouping byte

    const (
        ST_BarGroupingUnset          ST_BarGrouping = 0
        ST_BarGroupingPercentStacked ST_BarGrouping = 1
        ST_BarGroupingClustered      ST_BarGrouping = 2
        ST_BarGroupingStandard       ST_BarGrouping = 3
        ST_BarGroupingStacked        ST_BarGrouping = 4
    )

### func (ST_BarGrouping) MarshalXML ¶

    func (m ST_BarGrouping) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_BarGrouping) MarshalXMLAttr ¶

    func (e ST_BarGrouping) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_BarGrouping) String ¶

    func (m ST_BarGrouping) String() string

### func (*ST_BarGrouping) UnmarshalXML ¶

    func (m *ST_BarGrouping) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_BarGrouping) UnmarshalXMLAttr ¶

    func (e *ST_BarGrouping) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_BarGrouping) Validate ¶

    func (m ST_BarGrouping) Validate() error

### func (ST_BarGrouping) ValidateWithPath ¶

    func (m ST_BarGrouping) ValidateWithPath(path string) error

## type ST_BubbleScale ¶

ST_BubbleScale is a union type

    type ST_BubbleScale struct {
        ST_BubbleScalePercent *string
        ST_BubbleScaleUInt    *uint32
    }

### func ParseUnionST_BubbleScale ¶

    func ParseUnionST_BubbleScale(s string) (ST_BubbleScale, error)

### func (ST_BubbleScale) MarshalXML ¶

    func (m ST_BubbleScale) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_BubbleScale) String ¶

    func (m ST_BubbleScale) String() string

### func (*ST_BubbleScale) Validate ¶

    func (m *ST_BubbleScale) Validate() error

### func (*ST_BubbleScale) ValidateWithPath ¶

    func (m *ST_BubbleScale) ValidateWithPath(path string) error

## type ST_BuiltInUnit ¶

    type ST_BuiltInUnit byte

    const (
        ST_BuiltInUnitUnset            ST_BuiltInUnit = 0
        ST_BuiltInUnitHundreds         ST_BuiltInUnit = 1
        ST_BuiltInUnitThousands        ST_BuiltInUnit = 2
        ST_BuiltInUnitTenThousands     ST_BuiltInUnit = 3
        ST_BuiltInUnitHundredThousands ST_BuiltInUnit = 4
        ST_BuiltInUnitMillions         ST_BuiltInUnit = 5
        ST_BuiltInUnitTenMillions      ST_BuiltInUnit = 6
        ST_BuiltInUnitHundredMillions  ST_BuiltInUnit = 7
        ST_BuiltInUnitBillions         ST_BuiltInUnit = 8
        ST_BuiltInUnitTrillions        ST_BuiltInUnit = 9
    )

### func (ST_BuiltInUnit) MarshalXML ¶

    func (m ST_BuiltInUnit) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_BuiltInUnit) MarshalXMLAttr ¶

    func (e ST_BuiltInUnit) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_BuiltInUnit) String ¶

    func (m ST_BuiltInUnit) String() string

### func (*ST_BuiltInUnit) UnmarshalXML ¶

    func (m *ST_BuiltInUnit) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_BuiltInUnit) UnmarshalXMLAttr ¶

    func (e *ST_BuiltInUnit) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_BuiltInUnit) Validate ¶

    func (m ST_BuiltInUnit) Validate() error

### func (ST_BuiltInUnit) ValidateWithPath ¶

    func (m ST_BuiltInUnit) ValidateWithPath(path string) error

## type ST_CrossBetween ¶

    type ST_CrossBetween byte

    const (
        ST_CrossBetweenUnset   ST_CrossBetween = 0
        ST_CrossBetweenBetween ST_CrossBetween = 1
        ST_CrossBetweenMidCat  ST_CrossBetween = 2
    )

### func (ST_CrossBetween) MarshalXML ¶

    func (m ST_CrossBetween) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_CrossBetween) MarshalXMLAttr ¶

    func (e ST_CrossBetween) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_CrossBetween) String ¶

    func (m ST_CrossBetween) String() string

### func (*ST_CrossBetween) UnmarshalXML ¶

    func (m *ST_CrossBetween) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_CrossBetween) UnmarshalXMLAttr ¶

    func (e *ST_CrossBetween) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_CrossBetween) Validate ¶

    func (m ST_CrossBetween) Validate() error

### func (ST_CrossBetween) ValidateWithPath ¶

    func (m ST_CrossBetween) ValidateWithPath(path string) error

## type ST_Crosses ¶

    type ST_Crosses byte

    const (
        ST_CrossesUnset    ST_Crosses = 0
        ST_CrossesAutoZero ST_Crosses = 1
        ST_CrossesMax      ST_Crosses = 2
        ST_CrossesMin      ST_Crosses = 3
    )

### func (ST_Crosses) MarshalXML ¶

    func (m ST_Crosses) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_Crosses) MarshalXMLAttr ¶

    func (e ST_Crosses) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_Crosses) String ¶

    func (m ST_Crosses) String() string

### func (*ST_Crosses) UnmarshalXML ¶

    func (m *ST_Crosses) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_Crosses) UnmarshalXMLAttr ¶

    func (e *ST_Crosses) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_Crosses) Validate ¶

    func (m ST_Crosses) Validate() error

### func (ST_Crosses) ValidateWithPath ¶

    func (m ST_Crosses) ValidateWithPath(path string) error

## type ST_DLblPos ¶

    type ST_DLblPos byte

    const (
        ST_DLblPosUnset   ST_DLblPos = 0
        ST_DLblPosBestFit ST_DLblPos = 1
        ST_DLblPosB       ST_DLblPos = 2
        ST_DLblPosCtr     ST_DLblPos = 3
        ST_DLblPosInBase  ST_DLblPos = 4
        ST_DLblPosInEnd   ST_DLblPos = 5
        ST_DLblPosL       ST_DLblPos = 6
        ST_DLblPosOutEnd  ST_DLblPos = 7
        ST_DLblPosR       ST_DLblPos = 8
        ST_DLblPosT       ST_DLblPos = 9
    )

### func (ST_DLblPos) MarshalXML ¶

    func (m ST_DLblPos) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_DLblPos) MarshalXMLAttr ¶

    func (e ST_DLblPos) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_DLblPos) String ¶

    func (m ST_DLblPos) String() string

### func (*ST_DLblPos) UnmarshalXML ¶

    func (m *ST_DLblPos) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_DLblPos) UnmarshalXMLAttr ¶

    func (e *ST_DLblPos) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_DLblPos) Validate ¶

    func (m ST_DLblPos) Validate() error

### func (ST_DLblPos) ValidateWithPath ¶

    func (m ST_DLblPos) ValidateWithPath(path string) error

## type ST_DepthPercent ¶

ST_DepthPercent is a union type

    type ST_DepthPercent struct {
        ST_DepthPercentWithSymbol *string
        ST_DepthPercentUShort     *uint16
    }

### func ParseUnionST_DepthPercent ¶

    func ParseUnionST_DepthPercent(s string) (ST_DepthPercent, error)

### func (ST_DepthPercent) MarshalXML ¶

    func (m ST_DepthPercent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_DepthPercent) String ¶

    func (m ST_DepthPercent) String() string

### func (*ST_DepthPercent) Validate ¶

    func (m *ST_DepthPercent) Validate() error

### func (*ST_DepthPercent) ValidateWithPath ¶

    func (m *ST_DepthPercent) ValidateWithPath(path string) error

## type ST_DispBlanksAs ¶

    type ST_DispBlanksAs byte

    const (
        ST_DispBlanksAsUnset ST_DispBlanksAs = 0
        ST_DispBlanksAsSpan  ST_DispBlanksAs = 1
        ST_DispBlanksAsGap   ST_DispBlanksAs = 2
        ST_DispBlanksAsZero  ST_DispBlanksAs = 3
    )

### func (ST_DispBlanksAs) MarshalXML ¶

    func (m ST_DispBlanksAs) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_DispBlanksAs) MarshalXMLAttr ¶

    func (e ST_DispBlanksAs) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_DispBlanksAs) String ¶

    func (m ST_DispBlanksAs) String() string

### func (*ST_DispBlanksAs) UnmarshalXML ¶

    func (m *ST_DispBlanksAs) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_DispBlanksAs) UnmarshalXMLAttr ¶

    func (e *ST_DispBlanksAs) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_DispBlanksAs) Validate ¶

    func (m ST_DispBlanksAs) Validate() error

### func (ST_DispBlanksAs) ValidateWithPath ¶

    func (m ST_DispBlanksAs) ValidateWithPath(path string) error

## type ST_ErrBarType ¶

    type ST_ErrBarType byte

    const (
        ST_ErrBarTypeUnset ST_ErrBarType = 0
        ST_ErrBarTypeBoth  ST_ErrBarType = 1
        ST_ErrBarTypeMinus ST_ErrBarType = 2
        ST_ErrBarTypePlus  ST_ErrBarType = 3
    )

### func (ST_ErrBarType) MarshalXML ¶

    func (m ST_ErrBarType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_ErrBarType) MarshalXMLAttr ¶

    func (e ST_ErrBarType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_ErrBarType) String ¶

    func (m ST_ErrBarType) String() string

### func (*ST_ErrBarType) UnmarshalXML ¶

    func (m *ST_ErrBarType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_ErrBarType) UnmarshalXMLAttr ¶

    func (e *ST_ErrBarType) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_ErrBarType) Validate ¶

    func (m ST_ErrBarType) Validate() error

### func (ST_ErrBarType) ValidateWithPath ¶

    func (m ST_ErrBarType) ValidateWithPath(path string) error

## type ST_ErrDir ¶

    type ST_ErrDir byte

    const (
        ST_ErrDirUnset ST_ErrDir = 0
        ST_ErrDirX     ST_ErrDir = 1
        ST_ErrDirY     ST_ErrDir = 2
    )

### func (ST_ErrDir) MarshalXML ¶

    func (m ST_ErrDir) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_ErrDir) MarshalXMLAttr ¶

    func (e ST_ErrDir) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_ErrDir) String ¶

    func (m ST_ErrDir) String() string

### func (*ST_ErrDir) UnmarshalXML ¶

    func (m *ST_ErrDir) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_ErrDir) UnmarshalXMLAttr ¶

    func (e *ST_ErrDir) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_ErrDir) Validate ¶

    func (m ST_ErrDir) Validate() error

### func (ST_ErrDir) ValidateWithPath ¶

    func (m ST_ErrDir) ValidateWithPath(path string) error

## type ST_ErrValType ¶

    type ST_ErrValType byte

    const (
        ST_ErrValTypeUnset      ST_ErrValType = 0
        ST_ErrValTypeCust       ST_ErrValType = 1
        ST_ErrValTypeFixedVal   ST_ErrValType = 2
        ST_ErrValTypePercentage ST_ErrValType = 3
        ST_ErrValTypeStdDev     ST_ErrValType = 4
        ST_ErrValTypeStdErr     ST_ErrValType = 5
    )

### func (ST_ErrValType) MarshalXML ¶

    func (m ST_ErrValType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_ErrValType) MarshalXMLAttr ¶

    func (e ST_ErrValType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_ErrValType) String ¶

    func (m ST_ErrValType) String() string

### func (*ST_ErrValType) UnmarshalXML ¶

    func (m *ST_ErrValType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_ErrValType) UnmarshalXMLAttr ¶

    func (e *ST_ErrValType) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_ErrValType) Validate ¶

    func (m ST_ErrValType) Validate() error

### func (ST_ErrValType) ValidateWithPath ¶

    func (m ST_ErrValType) ValidateWithPath(path string) error

## type ST_GapAmount ¶

ST_GapAmount is a union type

    type ST_GapAmount struct {
        ST_GapAmountPercent *string
        ST_GapAmountUShort  *uint16
    }

### func ParseUnionST_GapAmount ¶

    func ParseUnionST_GapAmount(s string) (ST_GapAmount, error)

### func (ST_GapAmount) MarshalXML ¶

    func (m ST_GapAmount) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_GapAmount) String ¶

    func (m ST_GapAmount) String() string

### func (*ST_GapAmount) Validate ¶

    func (m *ST_GapAmount) Validate() error

### func (*ST_GapAmount) ValidateWithPath ¶

    func (m *ST_GapAmount) ValidateWithPath(path string) error

## type ST_Grouping ¶

    type ST_Grouping byte

    const (
        ST_GroupingUnset          ST_Grouping = 0
        ST_GroupingPercentStacked ST_Grouping = 1
        ST_GroupingStandard       ST_Grouping = 2
        ST_GroupingStacked        ST_Grouping = 3
    )

### func (ST_Grouping) MarshalXML ¶

    func (m ST_Grouping) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_Grouping) MarshalXMLAttr ¶

    func (e ST_Grouping) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_Grouping) String ¶

    func (m ST_Grouping) String() string

### func (*ST_Grouping) UnmarshalXML ¶

    func (m *ST_Grouping) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_Grouping) UnmarshalXMLAttr ¶

    func (e *ST_Grouping) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_Grouping) Validate ¶

    func (m ST_Grouping) Validate() error

### func (ST_Grouping) ValidateWithPath ¶

    func (m ST_Grouping) ValidateWithPath(path string) error

## type ST_HPercent ¶

ST_HPercent is a union type

    type ST_HPercent struct {
        ST_HPercentWithSymbol *string
        ST_HPercentUShort     *uint16
    }

### func ParseUnionST_HPercent ¶

    func ParseUnionST_HPercent(s string) (ST_HPercent, error)

### func (ST_HPercent) MarshalXML ¶

    func (m ST_HPercent) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_HPercent) String ¶

    func (m ST_HPercent) String() string

### func (*ST_HPercent) Validate ¶

    func (m *ST_HPercent) Validate() error

### func (*ST_HPercent) ValidateWithPath ¶

    func (m *ST_HPercent) ValidateWithPath(path string) error

## type ST_HoleSize ¶

ST_HoleSize is a union type

    type ST_HoleSize struct {
        ST_HoleSizePercent *string
        ST_HoleSizeUByte   *uint8
    }

### func ParseUnionST_HoleSize ¶

    func ParseUnionST_HoleSize(s string) (ST_HoleSize, error)

### func (ST_HoleSize) MarshalXML ¶

    func (m ST_HoleSize) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_HoleSize) String ¶

    func (m ST_HoleSize) String() string

### func (*ST_HoleSize) Validate ¶

    func (m *ST_HoleSize) Validate() error

### func (*ST_HoleSize) ValidateWithPath ¶

    func (m *ST_HoleSize) ValidateWithPath(path string) error

## type ST_LayoutMode ¶

    type ST_LayoutMode byte

    const (
        ST_LayoutModeUnset  ST_LayoutMode = 0
        ST_LayoutModeEdge   ST_LayoutMode = 1
        ST_LayoutModeFactor ST_LayoutMode = 2
    )

### func (ST_LayoutMode) MarshalXML ¶

    func (m ST_LayoutMode) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_LayoutMode) MarshalXMLAttr ¶

    func (e ST_LayoutMode) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_LayoutMode) String ¶

    func (m ST_LayoutMode) String() string

### func (*ST_LayoutMode) UnmarshalXML ¶

    func (m *ST_LayoutMode) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_LayoutMode) UnmarshalXMLAttr ¶

    func (e *ST_LayoutMode) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_LayoutMode) Validate ¶

    func (m ST_LayoutMode) Validate() error

### func (ST_LayoutMode) ValidateWithPath ¶

    func (m ST_LayoutMode) ValidateWithPath(path string) error

## type ST_LayoutTarget ¶

    type ST_LayoutTarget byte

    const (
        ST_LayoutTargetUnset ST_LayoutTarget = 0
        ST_LayoutTargetInner ST_LayoutTarget = 1
        ST_LayoutTargetOuter ST_LayoutTarget = 2
    )

### func (ST_LayoutTarget) MarshalXML ¶

    func (m ST_LayoutTarget) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_LayoutTarget) MarshalXMLAttr ¶

    func (e ST_LayoutTarget) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_LayoutTarget) String ¶

    func (m ST_LayoutTarget) String() string

### func (*ST_LayoutTarget) UnmarshalXML ¶

    func (m *ST_LayoutTarget) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_LayoutTarget) UnmarshalXMLAttr ¶

    func (e *ST_LayoutTarget) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_LayoutTarget) Validate ¶

    func (m ST_LayoutTarget) Validate() error

### func (ST_LayoutTarget) ValidateWithPath ¶

    func (m ST_LayoutTarget) ValidateWithPath(path string) error

## type ST_LblAlgn ¶

    type ST_LblAlgn byte

    const (
        ST_LblAlgnUnset ST_LblAlgn = 0
        ST_LblAlgnCtr   ST_LblAlgn = 1
        ST_LblAlgnL     ST_LblAlgn = 2
        ST_LblAlgnR     ST_LblAlgn = 3
    )

### func (ST_LblAlgn) MarshalXML ¶

    func (m ST_LblAlgn) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_LblAlgn) MarshalXMLAttr ¶

    func (e ST_LblAlgn) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_LblAlgn) String ¶

    func (m ST_LblAlgn) String() string

### func (*ST_LblAlgn) UnmarshalXML ¶

    func (m *ST_LblAlgn) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_LblAlgn) UnmarshalXMLAttr ¶

    func (e *ST_LblAlgn) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_LblAlgn) Validate ¶

    func (m ST_LblAlgn) Validate() error

### func (ST_LblAlgn) ValidateWithPath ¶

    func (m ST_LblAlgn) ValidateWithPath(path string) error

## type ST_LblOffset ¶

ST_LblOffset is a union type

    type ST_LblOffset struct {
        ST_LblOffsetPercent *string
        ST_LblOffsetUShort  *uint16
    }

### func ParseUnionST_LblOffset ¶

    func ParseUnionST_LblOffset(s string) (ST_LblOffset, error)

### func (ST_LblOffset) MarshalXML ¶

    func (m ST_LblOffset) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_LblOffset) String ¶

    func (m ST_LblOffset) String() string

### func (*ST_LblOffset) Validate ¶

    func (m *ST_LblOffset) Validate() error

### func (*ST_LblOffset) ValidateWithPath ¶

    func (m *ST_LblOffset) ValidateWithPath(path string) error

## type ST_LegendPos ¶

    type ST_LegendPos byte

    const (
        ST_LegendPosUnset ST_LegendPos = 0
        ST_LegendPosB     ST_LegendPos = 1
        ST_LegendPosTr    ST_LegendPos = 2
        ST_LegendPosL     ST_LegendPos = 3
        ST_LegendPosR     ST_LegendPos = 4
        ST_LegendPosT     ST_LegendPos = 5
    )

### func (ST_LegendPos) MarshalXML ¶

    func (m ST_LegendPos) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_LegendPos) MarshalXMLAttr ¶

    func (e ST_LegendPos) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_LegendPos) String ¶

    func (m ST_LegendPos) String() string

### func (*ST_LegendPos) UnmarshalXML ¶

    func (m *ST_LegendPos) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_LegendPos) UnmarshalXMLAttr ¶

    func (e *ST_LegendPos) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_LegendPos) Validate ¶

    func (m ST_LegendPos) Validate() error

### func (ST_LegendPos) ValidateWithPath ¶

    func (m ST_LegendPos) ValidateWithPath(path string) error

## type ST_MarkerStyle ¶

    type ST_MarkerStyle byte

    const (
        ST_MarkerStyleUnset    ST_MarkerStyle = 0
        ST_MarkerStyleCircle   ST_MarkerStyle = 1
        ST_MarkerStyleDash     ST_MarkerStyle = 2
        ST_MarkerStyleDiamond  ST_MarkerStyle = 3
        ST_MarkerStyleDot      ST_MarkerStyle = 4
        ST_MarkerStyleNone     ST_MarkerStyle = 5
        ST_MarkerStylePicture  ST_MarkerStyle = 6
        ST_MarkerStylePlus     ST_MarkerStyle = 7
        ST_MarkerStyleSquare   ST_MarkerStyle = 8
        ST_MarkerStyleStar     ST_MarkerStyle = 9
        ST_MarkerStyleTriangle ST_MarkerStyle = 10
        ST_MarkerStyleX        ST_MarkerStyle = 11
        ST_MarkerStyleAuto     ST_MarkerStyle = 12
    )

### func (ST_MarkerStyle) MarshalXML ¶

    func (m ST_MarkerStyle) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_MarkerStyle) MarshalXMLAttr ¶

    func (e ST_MarkerStyle) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_MarkerStyle) String ¶

    func (m ST_MarkerStyle) String() string

### func (*ST_MarkerStyle) UnmarshalXML ¶

    func (m *ST_MarkerStyle) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_MarkerStyle) UnmarshalXMLAttr ¶

    func (e *ST_MarkerStyle) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_MarkerStyle) Validate ¶

    func (m ST_MarkerStyle) Validate() error

### func (ST_MarkerStyle) ValidateWithPath ¶

    func (m ST_MarkerStyle) ValidateWithPath(path string) error

## type ST_OfPieType ¶

    type ST_OfPieType byte

    const (
        ST_OfPieTypeUnset ST_OfPieType = 0
        ST_OfPieTypePie   ST_OfPieType = 1
        ST_OfPieTypeBar   ST_OfPieType = 2
    )

### func (ST_OfPieType) MarshalXML ¶

    func (m ST_OfPieType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_OfPieType) MarshalXMLAttr ¶

    func (e ST_OfPieType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_OfPieType) String ¶

    func (m ST_OfPieType) String() string

### func (*ST_OfPieType) UnmarshalXML ¶

    func (m *ST_OfPieType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_OfPieType) UnmarshalXMLAttr ¶

    func (e *ST_OfPieType) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_OfPieType) Validate ¶

    func (m ST_OfPieType) Validate() error

### func (ST_OfPieType) ValidateWithPath ¶

    func (m ST_OfPieType) ValidateWithPath(path string) error

## type ST_Orientation ¶

    type ST_Orientation byte

    const (
        ST_OrientationUnset  ST_Orientation = 0
        ST_OrientationMaxMin ST_Orientation = 1
        ST_OrientationMinMax ST_Orientation = 2
    )

### func (ST_Orientation) MarshalXML ¶

    func (m ST_Orientation) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_Orientation) MarshalXMLAttr ¶

    func (e ST_Orientation) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_Orientation) String ¶

    func (m ST_Orientation) String() string

### func (*ST_Orientation) UnmarshalXML ¶

    func (m *ST_Orientation) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_Orientation) UnmarshalXMLAttr ¶

    func (e *ST_Orientation) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_Orientation) Validate ¶

    func (m ST_Orientation) Validate() error

### func (ST_Orientation) ValidateWithPath ¶

    func (m ST_Orientation) ValidateWithPath(path string) error

## type ST_Overlap ¶

ST_Overlap is a union type

    type ST_Overlap struct {
        ST_OverlapPercent *string
        ST_OverlapByte    *int8
    }

### func ParseUnionST_Overlap ¶

    func ParseUnionST_Overlap(s string) (ST_Overlap, error)

### func (ST_Overlap) MarshalXML ¶

    func (m ST_Overlap) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_Overlap) String ¶

    func (m ST_Overlap) String() string

### func (*ST_Overlap) Validate ¶

    func (m *ST_Overlap) Validate() error

### func (*ST_Overlap) ValidateWithPath ¶

    func (m *ST_Overlap) ValidateWithPath(path string) error

## type ST_PageSetupOrientation ¶

    type ST_PageSetupOrientation byte

    const (
        ST_PageSetupOrientationUnset     ST_PageSetupOrientation = 0
        ST_PageSetupOrientationDefault   ST_PageSetupOrientation = 1
        ST_PageSetupOrientationPortrait  ST_PageSetupOrientation = 2
        ST_PageSetupOrientationLandscape ST_PageSetupOrientation = 3
    )

### func (ST_PageSetupOrientation) MarshalXML ¶

    func (m ST_PageSetupOrientation) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_PageSetupOrientation) MarshalXMLAttr ¶

    func (e ST_PageSetupOrientation) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_PageSetupOrientation) String ¶

    func (m ST_PageSetupOrientation) String() string

### func (*ST_PageSetupOrientation) UnmarshalXML ¶

    func (m *ST_PageSetupOrientation) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_PageSetupOrientation) UnmarshalXMLAttr ¶

    func (e *ST_PageSetupOrientation) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_PageSetupOrientation) Validate ¶

    func (m ST_PageSetupOrientation) Validate() error

### func (ST_PageSetupOrientation) ValidateWithPath ¶

    func (m ST_PageSetupOrientation) ValidateWithPath(path string) error

## type ST_PictureFormat ¶

    type ST_PictureFormat byte

    const (
        ST_PictureFormatUnset      ST_PictureFormat = 0
        ST_PictureFormatStretch    ST_PictureFormat = 1
        ST_PictureFormatStack      ST_PictureFormat = 2
        ST_PictureFormatStackScale ST_PictureFormat = 3
    )

### func (ST_PictureFormat) MarshalXML ¶

    func (m ST_PictureFormat) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_PictureFormat) MarshalXMLAttr ¶

    func (e ST_PictureFormat) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_PictureFormat) String ¶

    func (m ST_PictureFormat) String() string

### func (*ST_PictureFormat) UnmarshalXML ¶

    func (m *ST_PictureFormat) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_PictureFormat) UnmarshalXMLAttr ¶

    func (e *ST_PictureFormat) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_PictureFormat) Validate ¶

    func (m ST_PictureFormat) Validate() error

### func (ST_PictureFormat) ValidateWithPath ¶

    func (m ST_PictureFormat) ValidateWithPath(path string) error

## type ST_RadarStyle ¶

    type ST_RadarStyle byte

    const (
        ST_RadarStyleUnset    ST_RadarStyle = 0
        ST_RadarStyleStandard ST_RadarStyle = 1
        ST_RadarStyleMarker   ST_RadarStyle = 2
        ST_RadarStyleFilled   ST_RadarStyle = 3
    )

### func (ST_RadarStyle) MarshalXML ¶

    func (m ST_RadarStyle) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_RadarStyle) MarshalXMLAttr ¶

    func (e ST_RadarStyle) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_RadarStyle) String ¶

    func (m ST_RadarStyle) String() string

### func (*ST_RadarStyle) UnmarshalXML ¶

    func (m *ST_RadarStyle) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_RadarStyle) UnmarshalXMLAttr ¶

    func (e *ST_RadarStyle) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_RadarStyle) Validate ¶

    func (m ST_RadarStyle) Validate() error

### func (ST_RadarStyle) ValidateWithPath ¶

    func (m ST_RadarStyle) ValidateWithPath(path string) error

## type ST_ScatterStyle ¶

    type ST_ScatterStyle byte

    const (
        ST_ScatterStyleUnset        ST_ScatterStyle = 0
        ST_ScatterStyleNone         ST_ScatterStyle = 1
        ST_ScatterStyleLine         ST_ScatterStyle = 2
        ST_ScatterStyleLineMarker   ST_ScatterStyle = 3
        ST_ScatterStyleMarker       ST_ScatterStyle = 4
        ST_ScatterStyleSmooth       ST_ScatterStyle = 5
        ST_ScatterStyleSmoothMarker ST_ScatterStyle = 6
    )

### func (ST_ScatterStyle) MarshalXML ¶

    func (m ST_ScatterStyle) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_ScatterStyle) MarshalXMLAttr ¶

    func (e ST_ScatterStyle) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_ScatterStyle) String ¶

    func (m ST_ScatterStyle) String() string

### func (*ST_ScatterStyle) UnmarshalXML ¶

    func (m *ST_ScatterStyle) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_ScatterStyle) UnmarshalXMLAttr ¶

    func (e *ST_ScatterStyle) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_ScatterStyle) Validate ¶

    func (m ST_ScatterStyle) Validate() error

### func (ST_ScatterStyle) ValidateWithPath ¶

    func (m ST_ScatterStyle) ValidateWithPath(path string) error

## type ST_SecondPieSize ¶

ST_SecondPieSize is a union type

    type ST_SecondPieSize struct {
        ST_SecondPieSizePercent *string
        ST_SecondPieSizeUShort  *uint16
    }

### func ParseUnionST_SecondPieSize ¶

    func ParseUnionST_SecondPieSize(s string) (ST_SecondPieSize, error)

### func (ST_SecondPieSize) MarshalXML ¶

    func (m ST_SecondPieSize) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_SecondPieSize) String ¶

    func (m ST_SecondPieSize) String() string

### func (*ST_SecondPieSize) Validate ¶

    func (m *ST_SecondPieSize) Validate() error

### func (*ST_SecondPieSize) ValidateWithPath ¶

    func (m *ST_SecondPieSize) ValidateWithPath(path string) error

## type ST_Shape ¶

    type ST_Shape byte

    const (
        ST_ShapeUnset        ST_Shape = 0
        ST_ShapeCone         ST_Shape = 1
        ST_ShapeConeToMax    ST_Shape = 2
        ST_ShapeBox          ST_Shape = 3
        ST_ShapeCylinder     ST_Shape = 4
        ST_ShapePyramid      ST_Shape = 5
        ST_ShapePyramidToMax ST_Shape = 6
    )

### func (ST_Shape) MarshalXML ¶

    func (m ST_Shape) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_Shape) MarshalXMLAttr ¶

    func (e ST_Shape) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_Shape) String ¶

    func (m ST_Shape) String() string

### func (*ST_Shape) UnmarshalXML ¶

    func (m *ST_Shape) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_Shape) UnmarshalXMLAttr ¶

    func (e *ST_Shape) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_Shape) Validate ¶

    func (m ST_Shape) Validate() error

### func (ST_Shape) ValidateWithPath ¶

    func (m ST_Shape) ValidateWithPath(path string) error

## type ST_SizeRepresents ¶

    type ST_SizeRepresents byte

    const (
        ST_SizeRepresentsUnset ST_SizeRepresents = 0
        ST_SizeRepresentsArea  ST_SizeRepresents = 1
        ST_SizeRepresentsW     ST_SizeRepresents = 2
    )

### func (ST_SizeRepresents) MarshalXML ¶

    func (m ST_SizeRepresents) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_SizeRepresents) MarshalXMLAttr ¶

    func (e ST_SizeRepresents) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_SizeRepresents) String ¶

    func (m ST_SizeRepresents) String() string

### func (*ST_SizeRepresents) UnmarshalXML ¶

    func (m *ST_SizeRepresents) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_SizeRepresents) UnmarshalXMLAttr ¶

    func (e *ST_SizeRepresents) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_SizeRepresents) Validate ¶

    func (m ST_SizeRepresents) Validate() error

### func (ST_SizeRepresents) ValidateWithPath ¶

    func (m ST_SizeRepresents) ValidateWithPath(path string) error

## type ST_SplitType ¶

    type ST_SplitType byte

    const (
        ST_SplitTypeUnset   ST_SplitType = 0
        ST_SplitTypeAuto    ST_SplitType = 1
        ST_SplitTypeCust    ST_SplitType = 2
        ST_SplitTypePercent ST_SplitType = 3
        ST_SplitTypePos     ST_SplitType = 4
        ST_SplitTypeVal     ST_SplitType = 5
    )

### func (ST_SplitType) MarshalXML ¶

    func (m ST_SplitType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_SplitType) MarshalXMLAttr ¶

    func (e ST_SplitType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_SplitType) String ¶

    func (m ST_SplitType) String() string

### func (*ST_SplitType) UnmarshalXML ¶

    func (m *ST_SplitType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_SplitType) UnmarshalXMLAttr ¶

    func (e *ST_SplitType) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_SplitType) Validate ¶

    func (m ST_SplitType) Validate() error

### func (ST_SplitType) ValidateWithPath ¶

    func (m ST_SplitType) ValidateWithPath(path string) error

## type ST_Thickness ¶

ST_Thickness is a union type

    type ST_Thickness struct {
        ST_ThicknessPercent *string
        Uint32              *uint32
    }

### func ParseUnionST_Thickness ¶

    func ParseUnionST_Thickness(s string) (ST_Thickness, error)

### func (ST_Thickness) MarshalXML ¶

    func (m ST_Thickness) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_Thickness) String ¶

    func (m ST_Thickness) String() string

### func (*ST_Thickness) Validate ¶

    func (m *ST_Thickness) Validate() error

### func (*ST_Thickness) ValidateWithPath ¶

    func (m *ST_Thickness) ValidateWithPath(path string) error

## type ST_TickLblPos ¶

    type ST_TickLblPos byte

    const (
        ST_TickLblPosUnset  ST_TickLblPos = 0
        ST_TickLblPosHigh   ST_TickLblPos = 1
        ST_TickLblPosLow    ST_TickLblPos = 2
        ST_TickLblPosNextTo ST_TickLblPos = 3
        ST_TickLblPosNone   ST_TickLblPos = 4
    )

### func (ST_TickLblPos) MarshalXML ¶

    func (m ST_TickLblPos) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_TickLblPos) MarshalXMLAttr ¶

    func (e ST_TickLblPos) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_TickLblPos) String ¶

    func (m ST_TickLblPos) String() string

### func (*ST_TickLblPos) UnmarshalXML ¶

    func (m *ST_TickLblPos) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_TickLblPos) UnmarshalXMLAttr ¶

    func (e *ST_TickLblPos) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_TickLblPos) Validate ¶

    func (m ST_TickLblPos) Validate() error

### func (ST_TickLblPos) ValidateWithPath ¶

    func (m ST_TickLblPos) ValidateWithPath(path string) error

## type ST_TickMark ¶

    type ST_TickMark byte

    const (
        ST_TickMarkUnset ST_TickMark = 0
        ST_TickMarkCross ST_TickMark = 1
        ST_TickMarkIn    ST_TickMark = 2
        ST_TickMarkNone  ST_TickMark = 3
        ST_TickMarkOut   ST_TickMark = 4
    )

### func (ST_TickMark) MarshalXML ¶

    func (m ST_TickMark) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_TickMark) MarshalXMLAttr ¶

    func (e ST_TickMark) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_TickMark) String ¶

    func (m ST_TickMark) String() string

### func (*ST_TickMark) UnmarshalXML ¶

    func (m *ST_TickMark) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_TickMark) UnmarshalXMLAttr ¶

    func (e *ST_TickMark) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_TickMark) Validate ¶

    func (m ST_TickMark) Validate() error

### func (ST_TickMark) ValidateWithPath ¶

    func (m ST_TickMark) ValidateWithPath(path string) error

## type ST_TimeUnit ¶

    type ST_TimeUnit byte

    const (
        ST_TimeUnitUnset  ST_TimeUnit = 0
        ST_TimeUnitDays   ST_TimeUnit = 1
        ST_TimeUnitMonths ST_TimeUnit = 2
        ST_TimeUnitYears  ST_TimeUnit = 3
    )

### func (ST_TimeUnit) MarshalXML ¶

    func (m ST_TimeUnit) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_TimeUnit) MarshalXMLAttr ¶

    func (e ST_TimeUnit) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_TimeUnit) String ¶

    func (m ST_TimeUnit) String() string

### func (*ST_TimeUnit) UnmarshalXML ¶

    func (m *ST_TimeUnit) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_TimeUnit) UnmarshalXMLAttr ¶

    func (e *ST_TimeUnit) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_TimeUnit) Validate ¶

    func (m ST_TimeUnit) Validate() error

### func (ST_TimeUnit) ValidateWithPath ¶

    func (m ST_TimeUnit) ValidateWithPath(path string) error

## type ST_TrendlineType ¶

    type ST_TrendlineType byte

    const (
        ST_TrendlineTypeUnset     ST_TrendlineType = 0
        ST_TrendlineTypeExp       ST_TrendlineType = 1
        ST_TrendlineTypeLinear    ST_TrendlineType = 2
        ST_TrendlineTypeLog       ST_TrendlineType = 3
        ST_TrendlineTypeMovingAvg ST_TrendlineType = 4
        ST_TrendlineTypePoly      ST_TrendlineType = 5
        ST_TrendlineTypePower     ST_TrendlineType = 6
    )

### func (ST_TrendlineType) MarshalXML ¶

    func (m ST_TrendlineType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (ST_TrendlineType) MarshalXMLAttr ¶

    func (e ST_TrendlineType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

### func (ST_TrendlineType) String ¶

    func (m ST_TrendlineType) String() string

### func (*ST_TrendlineType) UnmarshalXML ¶

    func (m *ST_TrendlineType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*ST_TrendlineType) UnmarshalXMLAttr ¶

    func (e *ST_TrendlineType) UnmarshalXMLAttr(attr xml.Attr) error

### func (ST_TrendlineType) Validate ¶

    func (m ST_TrendlineType) Validate() error

### func (ST_TrendlineType) ValidateWithPath ¶

    func (m ST_TrendlineType) ValidateWithPath(path string) error

## type UserShapes ¶

    type UserShapes struct {
        chartDrawing.CT_Drawing
    }

### func NewUserShapes ¶

    func NewUserShapes() *UserShapes

### func (*UserShapes) MarshalXML ¶

    func (m *UserShapes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

### func (*UserShapes) UnmarshalXML ¶

    func (m *UserShapes) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

### func (*UserShapes) Validate ¶

    func (m *UserShapes) Validate() error

Validate validates the UserShapes and its children

### func (*UserShapes) ValidateWithPath ¶

    func (m *UserShapes) ValidateWithPath(path string) error

ValidateWithPath validates the UserShapes and its children, prefixing error messages with path