spreadsheetml

package
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 2, 2017 License: AGPL-3.0 Imports: 9 Imported by: 0

Documentation ¶

Index ¶

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

func ParseStdlibTime ¶ 

func ParseStdlibTime(s string) (time.Time, error)

Types ¶

type AG_AutoFormat ¶ 

type AG_AutoFormat struct {
	AutoFormatIdAttr            *uint32
	ApplyNumberFormatsAttr      *bool
	ApplyBorderFormatsAttr      *bool
	ApplyFontFormatsAttr        *bool
	ApplyPatternFormatsAttr     *bool
	ApplyAlignmentFormatsAttr   *bool
	ApplyWidthHeightFormatsAttr *bool
}

func NewAG_AutoFormat ¶ 

func NewAG_AutoFormat() *AG_AutoFormat

func (*AG_AutoFormat) MarshalXML ¶ 

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

func (*AG_AutoFormat) UnmarshalXML ¶ 

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

func (*AG_AutoFormat) Validate ¶ 

func (m *AG_AutoFormat) Validate() error

Validate validates the AG_AutoFormat and its children

func (*AG_AutoFormat) ValidateWithPath ¶ 

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

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

type AG_RevData ¶ 

type AG_RevData struct {
	RIdAttr *uint32
	UaAttr  *bool
	RaAttr  *bool
}

func NewAG_RevData ¶ 

func NewAG_RevData() *AG_RevData

func (*AG_RevData) MarshalXML ¶ 

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

func (*AG_RevData) UnmarshalXML ¶ 

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

func (*AG_RevData) Validate ¶ 

func (m *AG_RevData) Validate() error

Validate validates the AG_RevData and its children

func (*AG_RevData) ValidateWithPath ¶ 

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

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

type CT_Authors ¶ 

type CT_Authors struct {
	// Author
	Author []string
}

func NewCT_Authors ¶ 

func NewCT_Authors() *CT_Authors

func (*CT_Authors) MarshalXML ¶ 

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

func (*CT_Authors) UnmarshalXML ¶ 

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

func (*CT_Authors) Validate ¶ 

func (m *CT_Authors) Validate() error

Validate validates the CT_Authors and its children

func (*CT_Authors) ValidateWithPath ¶ 

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

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

type CT_AutoFilter ¶ 

type CT_AutoFilter struct {
	// Cell or Range Reference
	RefAttr *string
	// AutoFilter Column
	FilterColumn []*CT_FilterColumn
	// Sort State for Auto Filter
	SortState *CT_SortState
	ExtLst    *CT_ExtensionList
}

func NewCT_AutoFilter ¶ 

func NewCT_AutoFilter() *CT_AutoFilter

func (*CT_AutoFilter) MarshalXML ¶ 

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

func (*CT_AutoFilter) UnmarshalXML ¶ 

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

func (*CT_AutoFilter) Validate ¶ 

func (m *CT_AutoFilter) Validate() error

Validate validates the CT_AutoFilter and its children

func (*CT_AutoFilter) ValidateWithPath ¶ 

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

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

type CT_AutoSortScope ¶ 

type CT_AutoSortScope struct {
	// Auto Sort Scope
	PivotArea *CT_PivotArea
}

func NewCT_AutoSortScope ¶ 

func NewCT_AutoSortScope() *CT_AutoSortScope

func (*CT_AutoSortScope) MarshalXML ¶ 

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

func (*CT_AutoSortScope) UnmarshalXML ¶ 

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

func (*CT_AutoSortScope) Validate ¶ 

func (m *CT_AutoSortScope) Validate() error

Validate validates the CT_AutoSortScope and its children

func (*CT_AutoSortScope) ValidateWithPath ¶ 

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

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

type CT_BookView ¶ 

type CT_BookView struct {
	// Visibility
	VisibilityAttr ST_Visibility
	// Minimized
	MinimizedAttr *bool
	// Show Horizontal Scroll
	ShowHorizontalScrollAttr *bool
	// Show Vertical Scroll
	ShowVerticalScrollAttr *bool
	// Show Sheet Tabs
	ShowSheetTabsAttr *bool
	// Upper Left Corner (X Coordinate)
	XWindowAttr *int32
	// Upper Left Corner (Y Coordinate)
	YWindowAttr *int32
	// Window Width
	WindowWidthAttr *uint32
	// Window Height
	WindowHeightAttr *uint32
	// Sheet Tab Ratio
	TabRatioAttr *uint32
	// First Sheet
	FirstSheetAttr *uint32
	// Active Sheet Index
	ActiveTabAttr *uint32
	// AutoFilter Date Grouping
	AutoFilterDateGroupingAttr *bool
	ExtLst                     *CT_ExtensionList
}

func NewCT_BookView ¶ 

func NewCT_BookView() *CT_BookView

func (*CT_BookView) MarshalXML ¶ 

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

func (*CT_BookView) UnmarshalXML ¶ 

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

func (*CT_BookView) Validate ¶ 

func (m *CT_BookView) Validate() error

Validate validates the CT_BookView and its children

func (*CT_BookView) ValidateWithPath ¶ 

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

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

type CT_BookViews ¶ 

type CT_BookViews struct {
	// Workbook View
	WorkbookView []*CT_BookView
}

func NewCT_BookViews ¶ 

func NewCT_BookViews() *CT_BookViews

func (*CT_BookViews) MarshalXML ¶ 

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

func (*CT_BookViews) UnmarshalXML ¶ 

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

func (*CT_BookViews) Validate ¶ 

func (m *CT_BookViews) Validate() error

Validate validates the CT_BookViews and its children

func (*CT_BookViews) ValidateWithPath ¶ 

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

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

type CT_Boolean ¶ 

type CT_Boolean struct {
	// Value
	VAttr bool
	// Unused Item
	UAttr *bool
	// Calculated Item
	FAttr *bool
	// Caption
	CAttr *string
	// Member Property Count
	CpAttr *uint32
	// Member Property Indexes
	X []*CT_X
}

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_BooleanProperty ¶ 

type CT_BooleanProperty struct {
	// Value
	ValAttr *bool
}

func NewCT_BooleanProperty ¶ 

func NewCT_BooleanProperty() *CT_BooleanProperty

func (*CT_BooleanProperty) MarshalXML ¶ 

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

func (*CT_BooleanProperty) UnmarshalXML ¶ 

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

func (*CT_BooleanProperty) Validate ¶ 

func (m *CT_BooleanProperty) Validate() error

Validate validates the CT_BooleanProperty and its children

func (*CT_BooleanProperty) ValidateWithPath ¶ 

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

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

type CT_Border ¶ 

type CT_Border struct {
	// Diagonal Up
	DiagonalUpAttr *bool
	// Diagonal Down
	DiagonalDownAttr *bool
	// Outline
	OutlineAttr *bool
	// Leading Edge Border
	Start *CT_BorderPr
	// Trailing Edge Border
	End *CT_BorderPr
	// Leading Edge Border
	Left *CT_BorderPr
	// Trailing Edge Border
	Right *CT_BorderPr
	// Top Border
	Top *CT_BorderPr
	// Bottom Border
	Bottom *CT_BorderPr
	// Diagonal
	Diagonal *CT_BorderPr
	// Vertical Inner Border
	Vertical *CT_BorderPr
	// Horizontal Inner Borders
	Horizontal *CT_BorderPr
}

func NewCT_Border ¶ 

func NewCT_Border() *CT_Border

func (*CT_Border) MarshalXML ¶ 

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

func (*CT_Border) UnmarshalXML ¶ 

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

func (*CT_Border) Validate ¶ 

func (m *CT_Border) Validate() error

Validate validates the CT_Border and its children

func (*CT_Border) ValidateWithPath ¶ 

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

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

type CT_BorderPr ¶ 

type CT_BorderPr struct {
	// Line Style
	StyleAttr ST_BorderStyle
	// Color
	Color *CT_Color
}

func NewCT_BorderPr ¶ 

func NewCT_BorderPr() *CT_BorderPr

func (*CT_BorderPr) MarshalXML ¶ 

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

func (*CT_BorderPr) UnmarshalXML ¶ 

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

func (*CT_BorderPr) Validate ¶ 

func (m *CT_BorderPr) Validate() error

Validate validates the CT_BorderPr and its children

func (*CT_BorderPr) ValidateWithPath ¶ 

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

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

type CT_Borders ¶ 

type CT_Borders struct {
	// Border Count
	CountAttr *uint32
	// Border
	Border []*CT_Border
}

func NewCT_Borders ¶ 

func NewCT_Borders() *CT_Borders

func (*CT_Borders) MarshalXML ¶ 

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

func (*CT_Borders) UnmarshalXML ¶ 

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

func (*CT_Borders) Validate ¶ 

func (m *CT_Borders) Validate() error

Validate validates the CT_Borders and its children

func (*CT_Borders) ValidateWithPath ¶ 

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

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

type CT_Break ¶ 

type CT_Break struct {
	// Id
	IdAttr *uint32
	// Minimum
	MinAttr *uint32
	// Maximum
	MaxAttr *uint32
	// Manual Page Break
	ManAttr *bool
	// Pivot-Created Page Break
	PtAttr *bool
}

func NewCT_Break ¶ 

func NewCT_Break() *CT_Break

func (*CT_Break) MarshalXML ¶ 

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

func (*CT_Break) UnmarshalXML ¶ 

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

func (*CT_Break) Validate ¶ 

func (m *CT_Break) Validate() error

Validate validates the CT_Break and its children

func (*CT_Break) ValidateWithPath ¶ 

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

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

type CT_CacheField ¶ 

type CT_CacheField struct {
	// PivotCache Field Name
	NameAttr string
	// PivotCache Field Caption
	CaptionAttr *string
	// Property Name
	PropertyNameAttr *string
	// Server-based Field
	ServerFieldAttr *bool
	// Unique List Retrieved
	UniqueListAttr *bool
	// Number Format Id
	NumFmtIdAttr *uint32
	// Calculated Field Formula
	FormulaAttr *string
	// SQL Data Type
	SqlTypeAttr *int32
	// Hierarchy
	HierarchyAttr *int32
	// Hierarchy Level
	LevelAttr *uint32
	// Database Field
	DatabaseFieldAttr *bool
	// Member Property Count
	MappingCountAttr *uint32
	// Member Property Field
	MemberPropertyFieldAttr *bool
	// Shared Items
	SharedItems *CT_SharedItems
	// Field Group Properties
	FieldGroup *CT_FieldGroup
	// Member Properties Map
	MpMap []*CT_X
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_CacheField ¶ 

func NewCT_CacheField() *CT_CacheField

func (*CT_CacheField) MarshalXML ¶ 

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

func (*CT_CacheField) UnmarshalXML ¶ 

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

func (*CT_CacheField) Validate ¶ 

func (m *CT_CacheField) Validate() error

Validate validates the CT_CacheField and its children

func (*CT_CacheField) ValidateWithPath ¶ 

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

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

type CT_CacheFields ¶ 

type CT_CacheFields struct {
	// Field Count
	CountAttr *uint32
	// PivotCache Field
	CacheField []*CT_CacheField
}

func NewCT_CacheFields ¶ 

func NewCT_CacheFields() *CT_CacheFields

func (*CT_CacheFields) MarshalXML ¶ 

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

func (*CT_CacheFields) UnmarshalXML ¶ 

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

func (*CT_CacheFields) Validate ¶ 

func (m *CT_CacheFields) Validate() error

Validate validates the CT_CacheFields and its children

func (*CT_CacheFields) ValidateWithPath ¶ 

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

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

type CT_CacheHierarchies ¶ 

type CT_CacheHierarchies struct {
	// Hierarchy Count
	CountAttr *uint32
	// PivotCache Hierarchy
	CacheHierarchy []*CT_CacheHierarchy
}

func NewCT_CacheHierarchies ¶ 

func NewCT_CacheHierarchies() *CT_CacheHierarchies

func (*CT_CacheHierarchies) MarshalXML ¶ 

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

func (*CT_CacheHierarchies) UnmarshalXML ¶ 

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

func (*CT_CacheHierarchies) Validate ¶ 

func (m *CT_CacheHierarchies) Validate() error

Validate validates the CT_CacheHierarchies and its children

func (*CT_CacheHierarchies) ValidateWithPath ¶ 

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

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

type CT_CacheHierarchy ¶ 

type CT_CacheHierarchy struct {
	// Hierarchy Unique Name
	UniqueNameAttr string
	// Hierarchy Display Name
	CaptionAttr *string
	// Measure Hierarchy
	MeasureAttr *bool
	// Set
	SetAttr *bool
	// Parent Set
	ParentSetAttr *uint32
	// KPI Icon Set
	IconSetAttr *int32
	// Attribute Hierarchy
	AttributeAttr *bool
	// Time
	TimeAttr *bool
	// Key Attribute Hierarchy
	KeyAttributeAttr *bool
	// Default Member Unique Name
	DefaultMemberUniqueNameAttr *string
	// Unique Name of 'All'
	AllUniqueNameAttr *string
	// Display Name of 'All'
	AllCaptionAttr *string
	// Dimension Unique Name
	DimensionUniqueNameAttr *string
	// Display Folder
	DisplayFolderAttr *string
	// Measure Group Name
	MeasureGroupAttr *string
	// Measures
	MeasuresAttr *bool
	// Levels Count
	CountAttr uint32
	// One Field
	OneFieldAttr *bool
	// Member Value Data Type
	MemberValueDatatypeAttr *uint16
	// Unbalanced
	UnbalancedAttr *bool
	// Unbalanced Group
	UnbalancedGroupAttr *bool
	// Hidden
	HiddenAttr *bool
	// Fields Usage
	FieldsUsage *CT_FieldsUsage
	// OLAP Grouping Levels
	GroupLevels *CT_GroupLevels
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_CacheHierarchy ¶ 

func NewCT_CacheHierarchy() *CT_CacheHierarchy

func (*CT_CacheHierarchy) MarshalXML ¶ 

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

func (*CT_CacheHierarchy) UnmarshalXML ¶ 

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

func (*CT_CacheHierarchy) Validate ¶ 

func (m *CT_CacheHierarchy) Validate() error

Validate validates the CT_CacheHierarchy and its children

func (*CT_CacheHierarchy) ValidateWithPath ¶ 

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

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

type CT_CacheSource ¶ 

type CT_CacheSource struct {
	// Cache Type
	TypeAttr ST_SourceType
	// Connection Index
	ConnectionIdAttr *uint32
	// Worksheet PivotCache Source
	WorksheetSource *CT_WorksheetSource
	// Consolidation Source
	Consolidation *CT_Consolidation
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_CacheSource ¶ 

func NewCT_CacheSource() *CT_CacheSource

func (*CT_CacheSource) MarshalXML ¶ 

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

func (*CT_CacheSource) UnmarshalXML ¶ 

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

func (*CT_CacheSource) Validate ¶ 

func (m *CT_CacheSource) Validate() error

Validate validates the CT_CacheSource and its children

func (*CT_CacheSource) ValidateWithPath ¶ 

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

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

type CT_CalcCell ¶ 

type CT_CalcCell struct {
	// Cell Reference
	RAttr   *string
	RefAttr *string
	// Sheet Id
	IAttr *int32
	// Child Chain
	SAttr *bool
	// New Dependency Level
	LAttr *bool
	// New Thread
	TAttr *bool
	// Array
	AAttr *bool
}

func NewCT_CalcCell ¶ 

func NewCT_CalcCell() *CT_CalcCell

func (*CT_CalcCell) MarshalXML ¶ 

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

func (*CT_CalcCell) UnmarshalXML ¶ 

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

func (*CT_CalcCell) Validate ¶ 

func (m *CT_CalcCell) Validate() error

Validate validates the CT_CalcCell and its children

func (*CT_CalcCell) ValidateWithPath ¶ 

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

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

type CT_CalcChain ¶ 

type CT_CalcChain struct {
	// Cell
	C      []*CT_CalcCell
	ExtLst *CT_ExtensionList
}

func NewCT_CalcChain ¶ 

func NewCT_CalcChain() *CT_CalcChain

func (*CT_CalcChain) MarshalXML ¶ 

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

func (*CT_CalcChain) UnmarshalXML ¶ 

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

func (*CT_CalcChain) Validate ¶ 

func (m *CT_CalcChain) Validate() error

Validate validates the CT_CalcChain and its children

func (*CT_CalcChain) ValidateWithPath ¶ 

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

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

type CT_CalcPr ¶ 

type CT_CalcPr struct {
	// Calculation Id
	CalcIdAttr *uint32
	// Calculation Mode
	CalcModeAttr ST_CalcMode
	// Full Calculation On Load
	FullCalcOnLoadAttr *bool
	// Reference Mode
	RefModeAttr ST_RefMode
	// Calculation Iteration
	IterateAttr *bool
	// Iteration Count
	IterateCountAttr *uint32
	// Iterative Calculation Delta
	IterateDeltaAttr *float64
	// Full Precision Calculation
	FullPrecisionAttr *bool
	// Calc Completed
	CalcCompletedAttr *bool
	// Calculate On Save
	CalcOnSaveAttr *bool
	// Concurrent Calculations
	ConcurrentCalcAttr *bool
	// Concurrent Thread Manual Count
	ConcurrentManualCountAttr *uint32
	// Force Full Calculation
	ForceFullCalcAttr *bool
}

func NewCT_CalcPr ¶ 

func NewCT_CalcPr() *CT_CalcPr

func (*CT_CalcPr) MarshalXML ¶ 

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

func (*CT_CalcPr) UnmarshalXML ¶ 

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

func (*CT_CalcPr) Validate ¶ 

func (m *CT_CalcPr) Validate() error

Validate validates the CT_CalcPr and its children

func (*CT_CalcPr) ValidateWithPath ¶ 

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

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

type CT_CalculatedItem ¶ 

type CT_CalculatedItem struct {
	// Field Index
	FieldAttr *uint32
	// Calculated Item Formula
	FormulaAttr *string
	// Calculated Item Location
	PivotArea *CT_PivotArea
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_CalculatedItem ¶ 

func NewCT_CalculatedItem() *CT_CalculatedItem

func (*CT_CalculatedItem) MarshalXML ¶ 

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

func (*CT_CalculatedItem) UnmarshalXML ¶ 

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

func (*CT_CalculatedItem) Validate ¶ 

func (m *CT_CalculatedItem) Validate() error

Validate validates the CT_CalculatedItem and its children

func (*CT_CalculatedItem) ValidateWithPath ¶ 

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

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

type CT_CalculatedItems ¶ 

type CT_CalculatedItems struct {
	// Calculated Item Formula Count
	CountAttr *uint32
	// Calculated Item
	CalculatedItem []*CT_CalculatedItem
}

func NewCT_CalculatedItems ¶ 

func NewCT_CalculatedItems() *CT_CalculatedItems

func (*CT_CalculatedItems) MarshalXML ¶ 

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

func (*CT_CalculatedItems) UnmarshalXML ¶ 

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

func (*CT_CalculatedItems) Validate ¶ 

func (m *CT_CalculatedItems) Validate() error

Validate validates the CT_CalculatedItems and its children

func (*CT_CalculatedItems) ValidateWithPath ¶ 

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

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

type CT_CalculatedMember ¶ 

type CT_CalculatedMember struct {
	// Calculated Member Name
	NameAttr string
	// Calculated Member MDX Formula
	MdxAttr string
	// OLAP Calculated Member Name
	MemberNameAttr *string
	// Hierarchy Name
	HierarchyAttr *string
	// Parent Name
	ParentAttr *string
	// Calculated Members Solve Order
	SolveOrderAttr *int32
	// Set
	SetAttr *bool
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_CalculatedMember ¶ 

func NewCT_CalculatedMember() *CT_CalculatedMember

func (*CT_CalculatedMember) MarshalXML ¶ 

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

func (*CT_CalculatedMember) UnmarshalXML ¶ 

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

func (*CT_CalculatedMember) Validate ¶ 

func (m *CT_CalculatedMember) Validate() error

Validate validates the CT_CalculatedMember and its children

func (*CT_CalculatedMember) ValidateWithPath ¶ 

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

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

type CT_CalculatedMembers ¶ 

type CT_CalculatedMembers struct {
	// Calculated Members Count
	CountAttr *uint32
	// Calculated Member
	CalculatedMember []*CT_CalculatedMember
}

func NewCT_CalculatedMembers ¶ 

func NewCT_CalculatedMembers() *CT_CalculatedMembers

func (*CT_CalculatedMembers) MarshalXML ¶ 

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

func (*CT_CalculatedMembers) UnmarshalXML ¶ 

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

func (*CT_CalculatedMembers) Validate ¶ 

func (m *CT_CalculatedMembers) Validate() error

Validate validates the CT_CalculatedMembers and its children

func (*CT_CalculatedMembers) ValidateWithPath ¶ 

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

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

type CT_Cell ¶ 

type CT_Cell struct {
	// Reference
	RAttr *string
	// Style Index
	SAttr *uint32
	// Cell Data Type
	TAttr ST_CellType
	// Cell Metadata Index
	CmAttr *uint32
	// Value Metadata Index
	VmAttr *uint32
	// Show Phonetic
	PhAttr *bool
	// Formula
	F *CT_CellFormula
	// Cell Value
	V *string
	// Rich Text Inline
	Is *CT_Rst
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_Cell ¶ 

func NewCT_Cell() *CT_Cell

func (*CT_Cell) MarshalXML ¶ 

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

func (*CT_Cell) UnmarshalXML ¶ 

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

func (*CT_Cell) Validate ¶ 

func (m *CT_Cell) Validate() error

Validate validates the CT_Cell and its children

func (*CT_Cell) ValidateWithPath ¶ 

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

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

type CT_CellAlignment ¶ 

type CT_CellAlignment struct {
	// Horizontal Alignment
	HorizontalAttr ST_HorizontalAlignment
	// Vertical Alignment
	VerticalAttr ST_VerticalAlignment
	// Text Rotation
	TextRotationAttr *uint32
	// Wrap Text
	WrapTextAttr *bool
	// Indent
	IndentAttr *uint32
	// Relative Indent
	RelativeIndentAttr *int32
	// Justify Last Line
	JustifyLastLineAttr *bool
	// Shrink To Fit
	ShrinkToFitAttr *bool
	// Reading Order
	ReadingOrderAttr *uint32
}

func NewCT_CellAlignment ¶ 

func NewCT_CellAlignment() *CT_CellAlignment

func (*CT_CellAlignment) MarshalXML ¶ 

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

func (*CT_CellAlignment) UnmarshalXML ¶ 

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

func (*CT_CellAlignment) Validate ¶ 

func (m *CT_CellAlignment) Validate() error

Validate validates the CT_CellAlignment and its children

func (*CT_CellAlignment) ValidateWithPath ¶ 

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

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

type CT_CellFormula ¶ 

type CT_CellFormula struct {
	TAttr    ST_CellFormulaType
	AcaAttr  *bool
	RefAttr  *string
	Dt2DAttr *bool
	DtrAttr  *bool
	Del1Attr *bool
	Del2Attr *bool
	R1Attr   *string
	R2Attr   *string
	CaAttr   *bool
	SiAttr   *uint32
	BxAttr   *bool
	Content  string
}

func NewCT_CellFormula ¶ 

func NewCT_CellFormula() *CT_CellFormula

func (*CT_CellFormula) MarshalXML ¶ 

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

func (*CT_CellFormula) UnmarshalXML ¶ 

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

func (*CT_CellFormula) Validate ¶ 

func (m *CT_CellFormula) Validate() error

Validate validates the CT_CellFormula and its children

func (*CT_CellFormula) ValidateWithPath ¶ 

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

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

type CT_CellProtection ¶ 

type CT_CellProtection struct {
	// Cell Locked
	LockedAttr *bool
	// Hidden Cell
	HiddenAttr *bool
}

func NewCT_CellProtection ¶ 

func NewCT_CellProtection() *CT_CellProtection

func (*CT_CellProtection) MarshalXML ¶ 

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

func (*CT_CellProtection) UnmarshalXML ¶ 

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

func (*CT_CellProtection) Validate ¶ 

func (m *CT_CellProtection) Validate() error

Validate validates the CT_CellProtection and its children

func (*CT_CellProtection) ValidateWithPath ¶ 

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

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

type CT_CellSmartTag ¶ 

type CT_CellSmartTag struct {
	// Smart Tag Type Index
	TypeAttr uint32
	// Deleted
	DeletedAttr *bool
	// XML Based
	XmlBasedAttr *bool
	// Smart Tag Properties
	CellSmartTagPr []*CT_CellSmartTagPr
}

func NewCT_CellSmartTag ¶ 

func NewCT_CellSmartTag() *CT_CellSmartTag

func (*CT_CellSmartTag) MarshalXML ¶ 

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

func (*CT_CellSmartTag) UnmarshalXML ¶ 

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

func (*CT_CellSmartTag) Validate ¶ 

func (m *CT_CellSmartTag) Validate() error

Validate validates the CT_CellSmartTag and its children

func (*CT_CellSmartTag) ValidateWithPath ¶ 

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

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

type CT_CellSmartTagPr ¶ 

type CT_CellSmartTagPr struct {
	// Key Name
	KeyAttr string
	// Value
	ValAttr string
}

func NewCT_CellSmartTagPr ¶ 

func NewCT_CellSmartTagPr() *CT_CellSmartTagPr

func (*CT_CellSmartTagPr) MarshalXML ¶ 

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

func (*CT_CellSmartTagPr) UnmarshalXML ¶ 

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

func (*CT_CellSmartTagPr) Validate ¶ 

func (m *CT_CellSmartTagPr) Validate() error

Validate validates the CT_CellSmartTagPr and its children

func (*CT_CellSmartTagPr) ValidateWithPath ¶ 

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

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

type CT_CellSmartTags ¶ 

type CT_CellSmartTags struct {
	// Reference
	RAttr string
	// Cell Smart Tag
	CellSmartTag []*CT_CellSmartTag
}

func NewCT_CellSmartTags ¶ 

func NewCT_CellSmartTags() *CT_CellSmartTags

func (*CT_CellSmartTags) MarshalXML ¶ 

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

func (*CT_CellSmartTags) UnmarshalXML ¶ 

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

func (*CT_CellSmartTags) Validate ¶ 

func (m *CT_CellSmartTags) Validate() error

Validate validates the CT_CellSmartTags and its children

func (*CT_CellSmartTags) ValidateWithPath ¶ 

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

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

type CT_CellStyle ¶ 

type CT_CellStyle struct {
	// User Defined Cell Style
	NameAttr *string
	// Format Id
	XfIdAttr uint32
	// Built-In Style Id
	BuiltinIdAttr *uint32
	// Outline Style
	ILevelAttr *uint32
	// Hidden Style
	HiddenAttr *bool
	// Custom Built In
	CustomBuiltinAttr *bool
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_CellStyle ¶ 

func NewCT_CellStyle() *CT_CellStyle

func (*CT_CellStyle) MarshalXML ¶ 

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

func (*CT_CellStyle) UnmarshalXML ¶ 

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

func (*CT_CellStyle) Validate ¶ 

func (m *CT_CellStyle) Validate() error

Validate validates the CT_CellStyle and its children

func (*CT_CellStyle) ValidateWithPath ¶ 

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

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

type CT_CellStyleXfs ¶ 

type CT_CellStyleXfs struct {
	// Style Count
	CountAttr *uint32
	// Formatting Elements
	Xf []*CT_Xf
}

func NewCT_CellStyleXfs ¶ 

func NewCT_CellStyleXfs() *CT_CellStyleXfs

func (*CT_CellStyleXfs) MarshalXML ¶ 

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

func (*CT_CellStyleXfs) UnmarshalXML ¶ 

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

func (*CT_CellStyleXfs) Validate ¶ 

func (m *CT_CellStyleXfs) Validate() error

Validate validates the CT_CellStyleXfs and its children

func (*CT_CellStyleXfs) ValidateWithPath ¶ 

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

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

type CT_CellStyles ¶ 

type CT_CellStyles struct {
	// Style Count
	CountAttr *uint32
	// Cell Style
	CellStyle []*CT_CellStyle
}

func NewCT_CellStyles ¶ 

func NewCT_CellStyles() *CT_CellStyles

func (*CT_CellStyles) MarshalXML ¶ 

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

func (*CT_CellStyles) UnmarshalXML ¶ 

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

func (*CT_CellStyles) Validate ¶ 

func (m *CT_CellStyles) Validate() error

Validate validates the CT_CellStyles and its children

func (*CT_CellStyles) ValidateWithPath ¶ 

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

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

type CT_CellWatch ¶ 

type CT_CellWatch struct {
	// Reference
	RAttr string
}

func NewCT_CellWatch ¶ 

func NewCT_CellWatch() *CT_CellWatch

func (*CT_CellWatch) MarshalXML ¶ 

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

func (*CT_CellWatch) UnmarshalXML ¶ 

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

func (*CT_CellWatch) Validate ¶ 

func (m *CT_CellWatch) Validate() error

Validate validates the CT_CellWatch and its children

func (*CT_CellWatch) ValidateWithPath ¶ 

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

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

type CT_CellWatches ¶ 

type CT_CellWatches struct {
	// Cell Watch Item
	CellWatch []*CT_CellWatch
}

func NewCT_CellWatches ¶ 

func NewCT_CellWatches() *CT_CellWatches

func (*CT_CellWatches) MarshalXML ¶ 

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

func (*CT_CellWatches) UnmarshalXML ¶ 

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

func (*CT_CellWatches) Validate ¶ 

func (m *CT_CellWatches) Validate() error

Validate validates the CT_CellWatches and its children

func (*CT_CellWatches) ValidateWithPath ¶ 

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

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

type CT_CellXfs ¶ 

type CT_CellXfs struct {
	// Format Count
	CountAttr *uint32
	// Format
	Xf []*CT_Xf
}

func NewCT_CellXfs ¶ 

func NewCT_CellXfs() *CT_CellXfs

func (*CT_CellXfs) MarshalXML ¶ 

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

func (*CT_CellXfs) UnmarshalXML ¶ 

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

func (*CT_CellXfs) Validate ¶ 

func (m *CT_CellXfs) Validate() error

Validate validates the CT_CellXfs and its children

func (*CT_CellXfs) ValidateWithPath ¶ 

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

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

type CT_CfRule ¶ 

type CT_CfRule struct {
	// Type
	TypeAttr ST_CfType
	// Differential Formatting Id
	DxfIdAttr *uint32
	// Priority
	PriorityAttr int32
	// Stop If True
	StopIfTrueAttr *bool
	// Above Or Below Average
	AboveAverageAttr *bool
	// Top 10 Percent
	PercentAttr *bool
	// Bottom N
	BottomAttr *bool
	// Operator
	OperatorAttr ST_ConditionalFormattingOperator
	// Text
	TextAttr *string
	// Time Period
	TimePeriodAttr ST_TimePeriod
	// Rank
	RankAttr *uint32
	// StdDev
	StdDevAttr *int32
	// Equal Average
	EqualAverageAttr *bool
	// Formula
	Formula []string
	// Color Scale
	ColorScale *CT_ColorScale
	// Data Bar
	DataBar *CT_DataBar
	// Icon Set
	IconSet *CT_IconSet
	ExtLst  *CT_ExtensionList
}

func NewCT_CfRule ¶ 

func NewCT_CfRule() *CT_CfRule

func (*CT_CfRule) MarshalXML ¶ 

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

func (*CT_CfRule) UnmarshalXML ¶ 

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

func (*CT_CfRule) Validate ¶ 

func (m *CT_CfRule) Validate() error

Validate validates the CT_CfRule and its children

func (*CT_CfRule) ValidateWithPath ¶ 

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

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

type CT_Cfvo ¶ 

type CT_Cfvo struct {
	// Type
	TypeAttr ST_CfvoType
	// Value
	ValAttr *string
	// Greater Than Or Equal
	GteAttr *bool
	ExtLst  *CT_ExtensionList
}

func NewCT_Cfvo ¶ 

func NewCT_Cfvo() *CT_Cfvo

func (*CT_Cfvo) MarshalXML ¶ 

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

func (*CT_Cfvo) UnmarshalXML ¶ 

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

func (*CT_Cfvo) Validate ¶ 

func (m *CT_Cfvo) Validate() error

Validate validates the CT_Cfvo and its children

func (*CT_Cfvo) ValidateWithPath ¶ 

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

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

type CT_ChartFormat ¶ 

type CT_ChartFormat struct {
	// Chart Index
	ChartAttr uint32
	// Pivot Format Id
	FormatAttr uint32
	// Series Format
	SeriesAttr *bool
	// Pivot Table Location Rule
	PivotArea *CT_PivotArea
}

func NewCT_ChartFormat ¶ 

func NewCT_ChartFormat() *CT_ChartFormat

func (*CT_ChartFormat) MarshalXML ¶ 

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

func (*CT_ChartFormat) UnmarshalXML ¶ 

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

func (*CT_ChartFormat) Validate ¶ 

func (m *CT_ChartFormat) Validate() error

Validate validates the CT_ChartFormat and its children

func (*CT_ChartFormat) ValidateWithPath ¶ 

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

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

type CT_ChartFormats ¶ 

type CT_ChartFormats struct {
	// Format Count
	CountAttr *uint32
	// PivotChart Format
	ChartFormat []*CT_ChartFormat
}

func NewCT_ChartFormats ¶ 

func NewCT_ChartFormats() *CT_ChartFormats

func (*CT_ChartFormats) MarshalXML ¶ 

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

func (*CT_ChartFormats) UnmarshalXML ¶ 

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

func (*CT_ChartFormats) Validate ¶ 

func (m *CT_ChartFormats) Validate() error

Validate validates the CT_ChartFormats and its children

func (*CT_ChartFormats) ValidateWithPath ¶ 

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

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

type CT_Chartsheet ¶ 

type CT_Chartsheet struct {
	// Chart Sheet Properties
	SheetPr *CT_ChartsheetPr
	// Chart Sheet Views
	SheetViews *CT_ChartsheetViews
	// Chart Sheet Protection
	SheetProtection *CT_ChartsheetProtection
	// Custom Chart Sheet Views
	CustomSheetViews *CT_CustomChartsheetViews
	PageMargins      *CT_PageMargins
	PageSetup        *CT_CsPageSetup
	HeaderFooter     *CT_HeaderFooter
	// Drawing
	Drawing       *CT_Drawing
	LegacyDrawing *CT_LegacyDrawing
	// Legacy Drawing Reference in Header Footer
	LegacyDrawingHF *CT_LegacyDrawing
	// Drawing Reference in Header Footer
	DrawingHF       *CT_DrawingHF
	Picture         *CT_SheetBackgroundPicture
	WebPublishItems *CT_WebPublishItems
	ExtLst          *CT_ExtensionList
}

func NewCT_Chartsheet ¶ 

func NewCT_Chartsheet() *CT_Chartsheet

func (*CT_Chartsheet) MarshalXML ¶ 

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

func (*CT_Chartsheet) UnmarshalXML ¶ 

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

func (*CT_Chartsheet) Validate ¶ 

func (m *CT_Chartsheet) Validate() error

Validate validates the CT_Chartsheet and its children

func (*CT_Chartsheet) ValidateWithPath ¶ 

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

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

type CT_ChartsheetPr ¶ 

type CT_ChartsheetPr struct {
	// Published
	PublishedAttr *bool
	// Code Name
	CodeNameAttr *string
	TabColor     *CT_Color
}

func NewCT_ChartsheetPr ¶ 

func NewCT_ChartsheetPr() *CT_ChartsheetPr

func (*CT_ChartsheetPr) MarshalXML ¶ 

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

func (*CT_ChartsheetPr) UnmarshalXML ¶ 

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

func (*CT_ChartsheetPr) Validate ¶ 

func (m *CT_ChartsheetPr) Validate() error

Validate validates the CT_ChartsheetPr and its children

func (*CT_ChartsheetPr) ValidateWithPath ¶ 

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

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

type CT_ChartsheetProtection ¶ 

type CT_ChartsheetProtection struct {
	// Password
	PasswordAttr *string
	// Cryptographic Algorithm Name
	AlgorithmNameAttr *string
	// Password Hash Value
	HashValueAttr *string
	// Salt Value for Password Verifier
	SaltValueAttr *string
	// Iterations to Run Hashing Algorithm
	SpinCountAttr *uint32
	// Contents
	ContentAttr *bool
	// Objects Locked
	ObjectsAttr *bool
}

func NewCT_ChartsheetProtection ¶ 

func NewCT_ChartsheetProtection() *CT_ChartsheetProtection

func (*CT_ChartsheetProtection) MarshalXML ¶ 

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

func (*CT_ChartsheetProtection) UnmarshalXML ¶ 

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

func (*CT_ChartsheetProtection) Validate ¶ 

func (m *CT_ChartsheetProtection) Validate() error

Validate validates the CT_ChartsheetProtection and its children

func (*CT_ChartsheetProtection) ValidateWithPath ¶ 

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

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

type CT_ChartsheetView ¶ 

type CT_ChartsheetView struct {
	// Sheet Tab Selected
	TabSelectedAttr *bool
	// Window Zoom Scale
	ZoomScaleAttr *uint32
	// Workbook View Id
	WorkbookViewIdAttr uint32
	// Zoom To Fit
	ZoomToFitAttr *bool
	ExtLst        *CT_ExtensionList
}

func NewCT_ChartsheetView ¶ 

func NewCT_ChartsheetView() *CT_ChartsheetView

func (*CT_ChartsheetView) MarshalXML ¶ 

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

func (*CT_ChartsheetView) UnmarshalXML ¶ 

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

func (*CT_ChartsheetView) Validate ¶ 

func (m *CT_ChartsheetView) Validate() error

Validate validates the CT_ChartsheetView and its children

func (*CT_ChartsheetView) ValidateWithPath ¶ 

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

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

type CT_ChartsheetViews ¶ 

type CT_ChartsheetViews struct {
	// Chart Sheet View
	SheetView []*CT_ChartsheetView
	ExtLst    *CT_ExtensionList
}

func NewCT_ChartsheetViews ¶ 

func NewCT_ChartsheetViews() *CT_ChartsheetViews

func (*CT_ChartsheetViews) MarshalXML ¶ 

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

func (*CT_ChartsheetViews) UnmarshalXML ¶ 

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

func (*CT_ChartsheetViews) Validate ¶ 

func (m *CT_ChartsheetViews) Validate() error

Validate validates the CT_ChartsheetViews and its children

func (*CT_ChartsheetViews) ValidateWithPath ¶ 

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

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

type CT_Col ¶ 

type CT_Col struct {
	// Minimum Column
	MinAttr uint32
	// Maximum Column
	MaxAttr uint32
	// Column Width
	WidthAttr *float64
	// Style
	StyleAttr *uint32
	// Hidden Columns
	HiddenAttr *bool
	// Best Fit Column Width
	BestFitAttr *bool
	// Custom Width
	CustomWidthAttr *bool
	// Show Phonetic Information
	PhoneticAttr *bool
	// Outline Level
	OutlineLevelAttr *uint8
	// Collapsed
	CollapsedAttr *bool
}

func NewCT_Col ¶ 

func NewCT_Col() *CT_Col

func (*CT_Col) MarshalXML ¶ 

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

func (*CT_Col) UnmarshalXML ¶ 

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

func (*CT_Col) Validate ¶ 

func (m *CT_Col) Validate() error

Validate validates the CT_Col and its children

func (*CT_Col) ValidateWithPath ¶ 

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

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

type CT_ColFields ¶ 

type CT_ColFields struct {
	// Repeated Items Count
	CountAttr *uint32
	// Field
	Field []*CT_Field
}

func NewCT_ColFields ¶ 

func NewCT_ColFields() *CT_ColFields

func (*CT_ColFields) MarshalXML ¶ 

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

func (*CT_ColFields) UnmarshalXML ¶ 

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

func (*CT_ColFields) Validate ¶ 

func (m *CT_ColFields) Validate() error

Validate validates the CT_ColFields and its children

func (*CT_ColFields) ValidateWithPath ¶ 

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

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

type CT_ColHierarchiesUsage ¶ 

type CT_ColHierarchiesUsage struct {
	// Items Count
	CountAttr *uint32
	// Column OLAP Hierarchies
	ColHierarchyUsage []*CT_HierarchyUsage
}

func NewCT_ColHierarchiesUsage ¶ 

func NewCT_ColHierarchiesUsage() *CT_ColHierarchiesUsage

func (*CT_ColHierarchiesUsage) MarshalXML ¶ 

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

func (*CT_ColHierarchiesUsage) UnmarshalXML ¶ 

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

func (*CT_ColHierarchiesUsage) Validate ¶ 

func (m *CT_ColHierarchiesUsage) Validate() error

Validate validates the CT_ColHierarchiesUsage and its children

func (*CT_ColHierarchiesUsage) ValidateWithPath ¶ 

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

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

type CT_Color ¶ 

type CT_Color struct {
	// Automatic
	AutoAttr *bool
	// Index
	IndexedAttr *uint32
	// Alpha Red Green Blue Color Value
	RgbAttr *string
	// Theme Color
	ThemeAttr *uint32
	// Tint
	TintAttr *float64
}

func NewCT_Color ¶ 

func NewCT_Color() *CT_Color

func (*CT_Color) MarshalXML ¶ 

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

func (*CT_Color) UnmarshalXML ¶ 

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

func (*CT_Color) Validate ¶ 

func (m *CT_Color) Validate() error

Validate validates the CT_Color and its children

func (*CT_Color) ValidateWithPath ¶ 

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

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

type CT_ColorFilter ¶ 

type CT_ColorFilter struct {
	// Differential Format Record Id
	DxfIdAttr *uint32
	// Filter By Cell Color
	CellColorAttr *bool
}

func NewCT_ColorFilter ¶ 

func NewCT_ColorFilter() *CT_ColorFilter

func (*CT_ColorFilter) MarshalXML ¶ 

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

func (*CT_ColorFilter) UnmarshalXML ¶ 

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

func (*CT_ColorFilter) Validate ¶ 

func (m *CT_ColorFilter) Validate() error

Validate validates the CT_ColorFilter and its children

func (*CT_ColorFilter) ValidateWithPath ¶ 

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

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

type CT_ColorScale ¶ 

type CT_ColorScale struct {
	// Conditional Format Value Object
	Cfvo []*CT_Cfvo
	// Color Gradiant Interpolation
	Color []*CT_Color
}

func NewCT_ColorScale ¶ 

func NewCT_ColorScale() *CT_ColorScale

func (*CT_ColorScale) MarshalXML ¶ 

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

func (*CT_ColorScale) UnmarshalXML ¶ 

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

func (*CT_ColorScale) Validate ¶ 

func (m *CT_ColorScale) Validate() error

Validate validates the CT_ColorScale and its children

func (*CT_ColorScale) ValidateWithPath ¶ 

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

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

type CT_Colors ¶ 

type CT_Colors struct {
	// Color Indexes
	IndexedColors *CT_IndexedColors
	// MRU Colors
	MruColors *CT_MRUColors
}

func NewCT_Colors ¶ 

func NewCT_Colors() *CT_Colors

func (*CT_Colors) MarshalXML ¶ 

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

func (*CT_Colors) UnmarshalXML ¶ 

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

func (*CT_Colors) Validate ¶ 

func (m *CT_Colors) Validate() error

Validate validates the CT_Colors and its children

func (*CT_Colors) ValidateWithPath ¶ 

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

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

type CT_Cols ¶ 

type CT_Cols struct {
	// Column Width & Formatting
	Col []*CT_Col
}

func NewCT_Cols ¶ 

func NewCT_Cols() *CT_Cols

func (*CT_Cols) MarshalXML ¶ 

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

func (*CT_Cols) UnmarshalXML ¶ 

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

func (*CT_Cols) Validate ¶ 

func (m *CT_Cols) Validate() error

Validate validates the CT_Cols and its children

func (*CT_Cols) ValidateWithPath ¶ 

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

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

type CT_Comment ¶ 

type CT_Comment struct {
	// Cell Reference
	RefAttr string
	// Author Id
	AuthorIdAttr uint32
	// Unique Identifier for Comment
	GuidAttr *string
	// Shape ID
	ShapeIdAttr *uint32
	// Comment Text
	Text *CT_Rst
	// Comment Properties
	CommentPr *CT_CommentPr
}

func NewCT_Comment ¶ 

func NewCT_Comment() *CT_Comment

func (*CT_Comment) MarshalXML ¶ 

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

func (*CT_Comment) UnmarshalXML ¶ 

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

func (*CT_Comment) Validate ¶ 

func (m *CT_Comment) Validate() error

Validate validates the CT_Comment and its children

func (*CT_Comment) ValidateWithPath ¶ 

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

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

type CT_CommentList ¶ 

type CT_CommentList struct {
	// Comment
	Comment []*CT_Comment
}

func NewCT_CommentList ¶ 

func NewCT_CommentList() *CT_CommentList

func (*CT_CommentList) MarshalXML ¶ 

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

func (*CT_CommentList) UnmarshalXML ¶ 

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

func (*CT_CommentList) Validate ¶ 

func (m *CT_CommentList) Validate() error

Validate validates the CT_CommentList and its children

func (*CT_CommentList) ValidateWithPath ¶ 

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

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

type CT_CommentPr ¶ 

type CT_CommentPr struct {
	// Locked Flag
	LockedAttr *bool
	// Default Size Flag
	DefaultSizeAttr *bool
	// Print Flag
	PrintAttr *bool
	// Disabled Flag
	DisabledAttr *bool
	// Automatic Fill Flag
	AutoFillAttr *bool
	// Automatic Line Flag
	AutoLineAttr *bool
	// Alternative Text
	AltTextAttr *string
	// Text Horizontal Alignment
	TextHAlignAttr ST_TextHAlign
	// ext Vertical Alignment
	TextVAlignAttr ST_TextVAlign
	// Text Lock Flag
	LockTextAttr *bool
	// Far East Alignment Flag
	JustLastXAttr *bool
	// Automatic Text Scaling Flag
	AutoScaleAttr *bool
	Anchor        *CT_ObjectAnchor
}

func NewCT_CommentPr ¶ 

func NewCT_CommentPr() *CT_CommentPr

func (*CT_CommentPr) MarshalXML ¶ 

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

func (*CT_CommentPr) UnmarshalXML ¶ 

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

func (*CT_CommentPr) Validate ¶ 

func (m *CT_CommentPr) Validate() error

Validate validates the CT_CommentPr and its children

func (*CT_CommentPr) ValidateWithPath ¶ 

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

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

type CT_Comments ¶ 

type CT_Comments struct {
	// Authors
	Authors *CT_Authors
	// List of Comments
	CommentList *CT_CommentList
	ExtLst      *CT_ExtensionList
}

func NewCT_Comments ¶ 

func NewCT_Comments() *CT_Comments

func (*CT_Comments) MarshalXML ¶ 

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

func (*CT_Comments) UnmarshalXML ¶ 

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

func (*CT_Comments) Validate ¶ 

func (m *CT_Comments) Validate() error

Validate validates the CT_Comments and its children

func (*CT_Comments) ValidateWithPath ¶ 

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

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

type CT_ConditionalFormat ¶ 

type CT_ConditionalFormat struct {
	// Conditional Formatting Scope
	ScopeAttr ST_Scope
	// Conditional Formatting Rule Type
	TypeAttr ST_Type
	// Priority
	PriorityAttr uint32
	// Pivot Areas
	PivotAreas *CT_PivotAreas
	ExtLst     *CT_ExtensionList
}

func NewCT_ConditionalFormat ¶ 

func NewCT_ConditionalFormat() *CT_ConditionalFormat

func (*CT_ConditionalFormat) MarshalXML ¶ 

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

func (*CT_ConditionalFormat) UnmarshalXML ¶ 

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

func (*CT_ConditionalFormat) Validate ¶ 

func (m *CT_ConditionalFormat) Validate() error

Validate validates the CT_ConditionalFormat and its children

func (*CT_ConditionalFormat) ValidateWithPath ¶ 

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

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

type CT_ConditionalFormats ¶ 

type CT_ConditionalFormats struct {
	// Conditional Format Count
	CountAttr *uint32
	// Conditional Formatting
	ConditionalFormat []*CT_ConditionalFormat
}

func NewCT_ConditionalFormats ¶ 

func NewCT_ConditionalFormats() *CT_ConditionalFormats

func (*CT_ConditionalFormats) MarshalXML ¶ 

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

func (*CT_ConditionalFormats) UnmarshalXML ¶ 

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

func (*CT_ConditionalFormats) Validate ¶ 

func (m *CT_ConditionalFormats) Validate() error

Validate validates the CT_ConditionalFormats and its children

func (*CT_ConditionalFormats) ValidateWithPath ¶ 

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

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

type CT_ConditionalFormatting ¶ 

type CT_ConditionalFormatting struct {
	// PivotTable Conditional Formatting
	PivotAttr *bool
	// Sequence of Refernces
	SqrefAttr *ST_Sqref
	// Conditional Formatting Rule
	CfRule []*CT_CfRule
	ExtLst *CT_ExtensionList
}

func NewCT_ConditionalFormatting ¶ 

func NewCT_ConditionalFormatting() *CT_ConditionalFormatting

func (*CT_ConditionalFormatting) MarshalXML ¶ 

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

func (*CT_ConditionalFormatting) UnmarshalXML ¶ 

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

func (*CT_ConditionalFormatting) Validate ¶ 

func (m *CT_ConditionalFormatting) Validate() error

Validate validates the CT_ConditionalFormatting and its children

func (*CT_ConditionalFormatting) ValidateWithPath ¶ 

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

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

type CT_Connection ¶ 

type CT_Connection struct {
	// Connection Id
	IdAttr uint32
	// Source Database File
	SourceFileAttr *string
	// Connection File
	OdcFileAttr *string
	// Keep Connection Open
	KeepAliveAttr *bool
	// Automatic Refresh Interval
	IntervalAttr *uint32
	// Connection Name
	NameAttr *string
	// Connection Description
	DescriptionAttr *string
	// Database Source Type
	TypeAttr *uint32
	// Reconnection Method
	ReconnectionMethodAttr *uint32
	// Last Refresh Version
	RefreshedVersionAttr uint8
	// Minimum Version Required for Refresh
	MinRefreshableVersionAttr *uint8
	// Save Password
	SavePasswordAttr *bool
	// New Connection
	NewAttr *bool
	// Deleted Connection
	DeletedAttr *bool
	// Only Use Connection File
	OnlyUseConnectionFileAttr *bool
	// Background Refresh
	BackgroundAttr *bool
	// Refresh on Open
	RefreshOnLoadAttr *bool
	// Save Data
	SaveDataAttr *bool
	// Reconnection Method
	CredentialsAttr ST_CredMethod
	// SSO Id
	SingleSignOnIdAttr *string
	// Database Properties
	DbPr *CT_DbPr
	// OLAP Properties
	OlapPr *CT_OlapPr
	// Web Query Properties
	WebPr *CT_WebPr
	// Text Import Settings
	TextPr *CT_TextPr
	// Query Parameters
	Parameters *CT_Parameters
	// Future Feature Data Storage
	ExtLst *CT_ExtensionList
}

func NewCT_Connection ¶ 

func NewCT_Connection() *CT_Connection

func (*CT_Connection) MarshalXML ¶ 

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

func (*CT_Connection) UnmarshalXML ¶ 

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

func (*CT_Connection) Validate ¶ 

func (m *CT_Connection) Validate() error

Validate validates the CT_Connection and its children

func (*CT_Connection) ValidateWithPath ¶ 

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

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

type CT_Connections ¶ 

type CT_Connections struct {
	// Connection
	Connection []*CT_Connection
}

func NewCT_Connections ¶ 

func NewCT_Connections() *CT_Connections

func (*CT_Connections) MarshalXML ¶ 

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

func (*CT_Connections) UnmarshalXML ¶ 

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

func (*CT_Connections) Validate ¶ 

func (m *CT_Connections) Validate() error

Validate validates the CT_Connections and its children

func (*CT_Connections) ValidateWithPath ¶ 

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

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

type CT_Consolidation ¶ 

type CT_Consolidation struct {
	// Auto Page
	AutoPageAttr *bool
	// Page Item Values
	Pages *CT_Pages
	// Range Sets
	RangeSets *CT_RangeSets
}

func NewCT_Consolidation ¶ 

func NewCT_Consolidation() *CT_Consolidation

func (*CT_Consolidation) MarshalXML ¶ 

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

func (*CT_Consolidation) UnmarshalXML ¶ 

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

func (*CT_Consolidation) Validate ¶ 

func (m *CT_Consolidation) Validate() error

Validate validates the CT_Consolidation and its children

func (*CT_Consolidation) ValidateWithPath ¶ 

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

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

type CT_Control ¶ 

type CT_Control struct {
	// Shape Id
	ShapeIdAttr uint32
	IdAttr      string
	// Control Name
	NameAttr *string
	// Embedded Control Properties
	ControlPr *CT_ControlPr
}

func NewCT_Control ¶ 

func NewCT_Control() *CT_Control

func (*CT_Control) MarshalXML ¶ 

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

func (*CT_Control) UnmarshalXML ¶ 

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

func (*CT_Control) Validate ¶ 

func (m *CT_Control) Validate() error

Validate validates the CT_Control and its children

func (*CT_Control) ValidateWithPath ¶ 

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

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

type CT_ControlPr ¶ 

type CT_ControlPr struct {
	// Locked Flag
	LockedAttr *bool
	// Default Size Flag
	DefaultSizeAttr *bool
	// Print Flag
	PrintAttr *bool
	// Disabled Flag
	DisabledAttr *bool
	// Recalculation Flag
	RecalcAlwaysAttr *bool
	// UI Object Flag
	UiObjectAttr *bool
	// Automatic Fill Flag
	AutoFillAttr *bool
	// Automatic Line Flag
	AutoLineAttr *bool
	// Automatic Size Flag
	AutoPictAttr *bool
	// Custom Function
	MacroAttr *string
	// Alternative Text
	AltTextAttr *string
	// Linked Formula
	LinkedCellAttr *string
	// List Items Source Range
	ListFillRangeAttr *string
	// Image Format
	CfAttr *string
	IdAttr *string
	// Object Cell Anchor
	Anchor *CT_ObjectAnchor
}

func NewCT_ControlPr ¶ 

func NewCT_ControlPr() *CT_ControlPr

func (*CT_ControlPr) MarshalXML ¶ 

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

func (*CT_ControlPr) UnmarshalXML ¶ 

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

func (*CT_ControlPr) Validate ¶ 

func (m *CT_ControlPr) Validate() error

Validate validates the CT_ControlPr and its children

func (*CT_ControlPr) ValidateWithPath ¶ 

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

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

type CT_Controls ¶ 

type CT_Controls struct {
	// Embedded Control
	Control []*CT_Control
}

func NewCT_Controls ¶ 

func NewCT_Controls() *CT_Controls

func (*CT_Controls) MarshalXML ¶ 

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

func (*CT_Controls) UnmarshalXML ¶ 

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

func (*CT_Controls) Validate ¶ 

func (m *CT_Controls) Validate() error

Validate validates the CT_Controls and its children

func (*CT_Controls) ValidateWithPath ¶ 

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

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

type CT_CsPageSetup ¶ 

type CT_CsPageSetup struct {
	// Paper Size
	PaperSizeAttr *uint32
	// Paper Height
	PaperHeightAttr *string
	// Paper Width
	PaperWidthAttr *string
	// First Page Number
	FirstPageNumberAttr *uint32
	// Orientation
	OrientationAttr ST_Orientation
	// Use Printer Defaults
	UsePrinterDefaultsAttr *bool
	// Black And White
	BlackAndWhiteAttr *bool
	// Draft
	DraftAttr *bool
	// Use First Page Number
	UseFirstPageNumberAttr *bool
	// Horizontal DPI
	HorizontalDpiAttr *uint32
	// Vertical DPI
	VerticalDpiAttr *uint32
	// Number Of Copies
	CopiesAttr *uint32
	IdAttr     *string
}

func NewCT_CsPageSetup ¶ 

func NewCT_CsPageSetup() *CT_CsPageSetup

func (*CT_CsPageSetup) MarshalXML ¶ 

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

func (*CT_CsPageSetup) UnmarshalXML ¶ 

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

func (*CT_CsPageSetup) Validate ¶ 

func (m *CT_CsPageSetup) Validate() error

Validate validates the CT_CsPageSetup and its children

func (*CT_CsPageSetup) ValidateWithPath ¶ 

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

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

type CT_CustomChartsheetView ¶ 

type CT_CustomChartsheetView struct {
	// GUID
	GuidAttr string
	// Print Scale
	ScaleAttr *uint32
	// Visible State
	StateAttr ST_SheetState
	// Zoom To Fit
	ZoomToFitAttr *bool
	PageMargins   *CT_PageMargins
	// Chart Sheet Page Setup
	PageSetup    *CT_CsPageSetup
	HeaderFooter *CT_HeaderFooter
}

func NewCT_CustomChartsheetView ¶ 

func NewCT_CustomChartsheetView() *CT_CustomChartsheetView

func (*CT_CustomChartsheetView) MarshalXML ¶ 

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

func (*CT_CustomChartsheetView) UnmarshalXML ¶ 

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

func (*CT_CustomChartsheetView) Validate ¶ 

func (m *CT_CustomChartsheetView) Validate() error

Validate validates the CT_CustomChartsheetView and its children

func (*CT_CustomChartsheetView) ValidateWithPath ¶ 

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

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

type CT_CustomChartsheetViews ¶ 

type CT_CustomChartsheetViews struct {
	// Custom Chart Sheet View
	CustomSheetView []*CT_CustomChartsheetView
}

func NewCT_CustomChartsheetViews ¶ 

func NewCT_CustomChartsheetViews() *CT_CustomChartsheetViews

func (*CT_CustomChartsheetViews) MarshalXML ¶ 

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

func (*CT_CustomChartsheetViews) UnmarshalXML ¶ 

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

func (*CT_CustomChartsheetViews) Validate ¶ 

func (m *CT_CustomChartsheetViews) Validate() error

Validate validates the CT_CustomChartsheetViews and its children

func (*CT_CustomChartsheetViews) ValidateWithPath ¶ 

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

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

type CT_CustomFilter ¶ 

type CT_CustomFilter struct {
	// Filter Comparison Operator
	OperatorAttr ST_FilterOperator
	// Top or Bottom Value
	ValAttr *string
}

func NewCT_CustomFilter ¶ 

func NewCT_CustomFilter() *CT_CustomFilter

func (*CT_CustomFilter) MarshalXML ¶ 

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

func (*CT_CustomFilter) UnmarshalXML ¶ 

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

func (*CT_CustomFilter) Validate ¶ 

func (m *CT_CustomFilter) Validate() error

Validate validates the CT_CustomFilter and its children

func (*CT_CustomFilter) ValidateWithPath ¶ 

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

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

type CT_CustomFilters ¶ 

type CT_CustomFilters struct {
	// And
	AndAttr *bool
	// Custom Filter Criteria
	CustomFilter []*CT_CustomFilter
}

func NewCT_CustomFilters ¶ 

func NewCT_CustomFilters() *CT_CustomFilters

func (*CT_CustomFilters) MarshalXML ¶ 

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

func (*CT_CustomFilters) UnmarshalXML ¶ 

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

func (*CT_CustomFilters) Validate ¶ 

func (m *CT_CustomFilters) Validate() error

Validate validates the CT_CustomFilters and its children

func (*CT_CustomFilters) ValidateWithPath ¶ 

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

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

type CT_CustomProperties ¶ 

type CT_CustomProperties struct {
	// Custom Property
	CustomPr []*CT_CustomProperty
}

func NewCT_CustomProperties ¶ 

func NewCT_CustomProperties() *CT_CustomProperties

func (*CT_CustomProperties) MarshalXML ¶ 

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

func (*CT_CustomProperties) UnmarshalXML ¶ 

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

func (*CT_CustomProperties) Validate ¶ 

func (m *CT_CustomProperties) Validate() error

Validate validates the CT_CustomProperties and its children

func (*CT_CustomProperties) ValidateWithPath ¶ 

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

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

type CT_CustomProperty ¶ 

type CT_CustomProperty struct {
	// Custom Property Name
	NameAttr string
	IdAttr   string
}

func NewCT_CustomProperty ¶ 

func NewCT_CustomProperty() *CT_CustomProperty

func (*CT_CustomProperty) MarshalXML ¶ 

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

func (*CT_CustomProperty) UnmarshalXML ¶ 

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

func (*CT_CustomProperty) Validate ¶ 

func (m *CT_CustomProperty) Validate() error

Validate validates the CT_CustomProperty and its children

func (*CT_CustomProperty) ValidateWithPath ¶ 

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

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

type CT_CustomSheetView ¶ 

type CT_CustomSheetView struct {
	// GUID
	GuidAttr string
	// Print Scale
	ScaleAttr *uint32
	// Color Id
	ColorIdAttr *uint32
	// Show Page Breaks
	ShowPageBreaksAttr *bool
	// Show Formulas
	ShowFormulasAttr *bool
	// Show Grid Lines
	ShowGridLinesAttr *bool
	// Show Headers
	ShowRowColAttr *bool
	// Show Outline Symbols
	OutlineSymbolsAttr *bool
	// Show Zero Values
	ZeroValuesAttr *bool
	// Fit To Page
	FitToPageAttr *bool
	// Print Area Defined
	PrintAreaAttr *bool
	// Filtered List
	FilterAttr *bool
	// Show AutoFitler Drop Down Controls
	ShowAutoFilterAttr *bool
	// Hidden Rows
	HiddenRowsAttr *bool
	// Hidden Columns
	HiddenColumnsAttr *bool
	// Visible State
	StateAttr ST_SheetState
	// Filter
	FilterUniqueAttr *bool
	// View Type
	ViewAttr ST_SheetViewType
	// Show Ruler
	ShowRulerAttr *bool
	// Top Left Visible Cell
	TopLeftCellAttr *string
	// Pane Split Information
	Pane *CT_Pane
	// Selection
	Selection *CT_Selection
	// Horizontal Page Breaks
	RowBreaks *CT_PageBreak
	// Vertical Page Breaks
	ColBreaks *CT_PageBreak
	// Page Margins
	PageMargins *CT_PageMargins
	// Print Options
	PrintOptions *CT_PrintOptions
	// Page Setup Settings
	PageSetup *CT_PageSetup
	// Header Footer Settings
	HeaderFooter *CT_HeaderFooter
	// AutoFilter Settings
	AutoFilter *CT_AutoFilter
	ExtLst     *CT_ExtensionList
}

func NewCT_CustomSheetView ¶ 

func NewCT_CustomSheetView() *CT_CustomSheetView

func (*CT_CustomSheetView) MarshalXML ¶ 

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

func (*CT_CustomSheetView) UnmarshalXML ¶ 

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

func (*CT_CustomSheetView) Validate ¶ 

func (m *CT_CustomSheetView) Validate() error

Validate validates the CT_CustomSheetView and its children

func (*CT_CustomSheetView) ValidateWithPath ¶ 

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

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

type CT_CustomSheetViews ¶ 

type CT_CustomSheetViews struct {
	// Custom Sheet View
	CustomSheetView []*CT_CustomSheetView
}

func NewCT_CustomSheetViews ¶ 

func NewCT_CustomSheetViews() *CT_CustomSheetViews

func (*CT_CustomSheetViews) MarshalXML ¶ 

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

func (*CT_CustomSheetViews) UnmarshalXML ¶ 

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

func (*CT_CustomSheetViews) Validate ¶ 

func (m *CT_CustomSheetViews) Validate() error

Validate validates the CT_CustomSheetViews and its children

func (*CT_CustomSheetViews) ValidateWithPath ¶ 

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

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

type CT_CustomWorkbookView ¶ 

type CT_CustomWorkbookView struct {
	// Custom View Name
	NameAttr string
	// Custom View GUID
	GuidAttr string
	// Auto Update
	AutoUpdateAttr *bool
	// Merge Interval
	MergeIntervalAttr *uint32
	// Changes Saved Win
	ChangesSavedWinAttr *bool
	// Only Synch
	OnlySyncAttr *bool
	// Personal View
	PersonalViewAttr *bool
	// Include Print Settings
	IncludePrintSettingsAttr *bool
	// Include Hidden Rows & Columns
	IncludeHiddenRowColAttr *bool
	// Maximized
	MaximizedAttr *bool
	// Minimized
	MinimizedAttr *bool
	// Show Horizontal Scroll
	ShowHorizontalScrollAttr *bool
	// Show Vertical Scroll
	ShowVerticalScrollAttr *bool
	// Show Sheet Tabs
	ShowSheetTabsAttr *bool
	// Top Left Corner (X Coordinate)
	XWindowAttr *int32
	// Top Left Corner (Y Coordinate)
	YWindowAttr *int32
	// Window Width
	WindowWidthAttr uint32
	// Window Height
	WindowHeightAttr uint32
	// Sheet Tab Ratio
	TabRatioAttr *uint32
	// Active Sheet in Book View
	ActiveSheetIdAttr uint32
	// Show Formula Bar
	ShowFormulaBarAttr *bool
	// Show Status Bar
	ShowStatusbarAttr *bool
	// Show Comments
	ShowCommentsAttr ST_Comments
	// Show Objects
	ShowObjectsAttr ST_Objects
	ExtLst          *CT_ExtensionList
}

func NewCT_CustomWorkbookView ¶ 

func NewCT_CustomWorkbookView() *CT_CustomWorkbookView

func (*CT_CustomWorkbookView) MarshalXML ¶ 

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

func (*CT_CustomWorkbookView) UnmarshalXML ¶ 

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

func (*CT_CustomWorkbookView) Validate ¶ 

func (m *CT_CustomWorkbookView) Validate() error

Validate validates the CT_CustomWorkbookView and its children

func (*CT_CustomWorkbookView) ValidateWithPath ¶ 

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

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

type CT_CustomWorkbookViews ¶ 

type CT_CustomWorkbookViews struct {
	// Custom Workbook View
	CustomWorkbookView []*CT_CustomWorkbookView
}

func NewCT_CustomWorkbookViews ¶ 

func NewCT_CustomWorkbookViews() *CT_CustomWorkbookViews

func (*CT_CustomWorkbookViews) MarshalXML ¶ 

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

func (*CT_CustomWorkbookViews) UnmarshalXML ¶ 

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

func (*CT_CustomWorkbookViews) Validate ¶ 

func (m *CT_CustomWorkbookViews) Validate() error

Validate validates the CT_CustomWorkbookViews and its children

func (*CT_CustomWorkbookViews) ValidateWithPath ¶ 

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

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

type CT_DataBar ¶ 

type CT_DataBar struct {
	// Minimum Length
	MinLengthAttr *uint32
	// Maximum Length
	MaxLengthAttr *uint32
	// Show Values
	ShowValueAttr *bool
	// Conditional Format Value Object
	Cfvo []*CT_Cfvo
	// Data Bar Color
	Color *CT_Color
}

func NewCT_DataBar ¶ 

func NewCT_DataBar() *CT_DataBar

func (*CT_DataBar) MarshalXML ¶ 

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

func (*CT_DataBar) UnmarshalXML ¶ 

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

func (*CT_DataBar) Validate ¶ 

func (m *CT_DataBar) Validate() error

Validate validates the CT_DataBar and its children

func (*CT_DataBar) ValidateWithPath ¶ 

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

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

type CT_DataBinding ¶ 

type CT_DataBinding struct {
	// Unique Identifer
	DataBindingNameAttr *string
	// Binding to External File
	FileBindingAttr *bool
	// Reference to Connection ID
	ConnectionIDAttr *uint32
	// File Binding Name
	FileBindingNameAttr *string
	// XML Data Loading Behavior
	DataBindingLoadModeAttr uint32
	Any                     gooxml.Any
}

func NewCT_DataBinding ¶ 

func NewCT_DataBinding() *CT_DataBinding

func (*CT_DataBinding) MarshalXML ¶ 

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

func (*CT_DataBinding) UnmarshalXML ¶ 

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

func (*CT_DataBinding) Validate ¶ 

func (m *CT_DataBinding) Validate() error

Validate validates the CT_DataBinding and its children

func (*CT_DataBinding) ValidateWithPath ¶ 

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

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

type CT_DataConsolidate ¶ 

type CT_DataConsolidate struct {
	// Function Index
	FunctionAttr ST_DataConsolidateFunction
	// Use Starting Column Labels
	StartLabelsAttr *bool
	// Starting Column Labels
	LeftLabelsAttr *bool
	// Labels In Top Row
	TopLabelsAttr *bool
	// Link
	LinkAttr *bool
	// Data Consolidation References
	DataRefs *CT_DataRefs
}

func NewCT_DataConsolidate ¶ 

func NewCT_DataConsolidate() *CT_DataConsolidate

func (*CT_DataConsolidate) MarshalXML ¶ 

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

func (*CT_DataConsolidate) UnmarshalXML ¶ 

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

func (*CT_DataConsolidate) Validate ¶ 

func (m *CT_DataConsolidate) Validate() error

Validate validates the CT_DataConsolidate and its children

func (*CT_DataConsolidate) ValidateWithPath ¶ 

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

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

type CT_DataField ¶ 

type CT_DataField struct {
	// Data Field Name
	NameAttr *string
	// Field
	FldAttr uint32
	// Subtotal
	SubtotalAttr ST_DataConsolidateFunction
	// Show Data As Display Format
	ShowDataAsAttr ST_ShowDataAs
	// 'Show Data As' Base Field
	BaseFieldAttr *int32
	// 'Show Data As' Base Setting
	BaseItemAttr *uint32
	// Number Format Id
	NumFmtIdAttr *uint32
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_DataField ¶ 

func NewCT_DataField() *CT_DataField

func (*CT_DataField) MarshalXML ¶ 

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

func (*CT_DataField) UnmarshalXML ¶ 

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

func (*CT_DataField) Validate ¶ 

func (m *CT_DataField) Validate() error

Validate validates the CT_DataField and its children

func (*CT_DataField) ValidateWithPath ¶ 

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

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

type CT_DataFields ¶ 

type CT_DataFields struct {
	// Data Items Count
	CountAttr *uint32
	// Data Field Item
	DataField []*CT_DataField
}

func NewCT_DataFields ¶ 

func NewCT_DataFields() *CT_DataFields

func (*CT_DataFields) MarshalXML ¶ 

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

func (*CT_DataFields) UnmarshalXML ¶ 

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

func (*CT_DataFields) Validate ¶ 

func (m *CT_DataFields) Validate() error

Validate validates the CT_DataFields and its children

func (*CT_DataFields) ValidateWithPath ¶ 

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

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

type CT_DataRef ¶ 

type CT_DataRef struct {
	// Reference
	RefAttr *string
	// Named Range
	NameAttr *string
	// Sheet Name
	SheetAttr *string
	IdAttr    *string
}

func NewCT_DataRef ¶ 

func NewCT_DataRef() *CT_DataRef

func (*CT_DataRef) MarshalXML ¶ 

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

func (*CT_DataRef) UnmarshalXML ¶ 

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

func (*CT_DataRef) Validate ¶ 

func (m *CT_DataRef) Validate() error

Validate validates the CT_DataRef and its children

func (*CT_DataRef) ValidateWithPath ¶ 

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

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

type CT_DataRefs ¶ 

type CT_DataRefs struct {
	// Data Consolidation Reference Count
	CountAttr *uint32
	// Data Consolidation Reference
	DataRef []*CT_DataRef
}

func NewCT_DataRefs ¶ 

func NewCT_DataRefs() *CT_DataRefs

func (*CT_DataRefs) MarshalXML ¶ 

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

func (*CT_DataRefs) UnmarshalXML ¶ 

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

func (*CT_DataRefs) Validate ¶ 

func (m *CT_DataRefs) Validate() error

Validate validates the CT_DataRefs and its children

func (*CT_DataRefs) ValidateWithPath ¶ 

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

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

type CT_DataValidation ¶ 

type CT_DataValidation struct {
	// Data Validation Type
	TypeAttr ST_DataValidationType
	// Data Validation Error Style
	ErrorStyleAttr ST_DataValidationErrorStyle
	// IME Mode Enforced
	ImeModeAttr ST_DataValidationImeMode
	// Operator
	OperatorAttr ST_DataValidationOperator
	// Allow Blank
	AllowBlankAttr *bool
	// Show Drop Down
	ShowDropDownAttr *bool
	// Show Input Message
	ShowInputMessageAttr *bool
	// Show Error Message
	ShowErrorMessageAttr *bool
	// Error Alert Text
	ErrorTitleAttr *string
	// Error Message
	ErrorAttr *string
	// Prompt Title
	PromptTitleAttr *string
	// Input Prompt
	PromptAttr *string
	// Sequence of References
	SqrefAttr ST_Sqref
	// Formula 1
	Formula1 *string
	// Formula 2
	Formula2 *string
}

func NewCT_DataValidation ¶ 

func NewCT_DataValidation() *CT_DataValidation

func (*CT_DataValidation) MarshalXML ¶ 

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

func (*CT_DataValidation) UnmarshalXML ¶ 

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

func (*CT_DataValidation) Validate ¶ 

func (m *CT_DataValidation) Validate() error

Validate validates the CT_DataValidation and its children

func (*CT_DataValidation) ValidateWithPath ¶ 

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

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

type CT_DataValidations ¶ 

type CT_DataValidations struct {
	// Disable Prompts
	DisablePromptsAttr *bool
	// Top Left Corner (X Coodrinate)
	XWindowAttr *uint32
	// Top Left Corner (Y Coordinate)
	YWindowAttr *uint32
	// Data Validation Item Count
	CountAttr *uint32
	// Data Validation
	DataValidation []*CT_DataValidation
}

func NewCT_DataValidations ¶ 

func NewCT_DataValidations() *CT_DataValidations

func (*CT_DataValidations) MarshalXML ¶ 

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

func (*CT_DataValidations) UnmarshalXML ¶ 

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

func (*CT_DataValidations) Validate ¶ 

func (m *CT_DataValidations) Validate() error

Validate validates the CT_DataValidations and its children

func (*CT_DataValidations) ValidateWithPath ¶ 

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

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

type CT_DateGroupItem ¶ 

type CT_DateGroupItem struct {
	// Year
	YearAttr uint16
	// Month
	MonthAttr *uint16
	// Day
	DayAttr *uint16
	// Hour
	HourAttr *uint16
	// Minute
	MinuteAttr *uint16
	// Second
	SecondAttr *uint16
	// Date Time Grouping
	DateTimeGroupingAttr ST_DateTimeGrouping
}

func NewCT_DateGroupItem ¶ 

func NewCT_DateGroupItem() *CT_DateGroupItem

func (*CT_DateGroupItem) MarshalXML ¶ 

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

func (*CT_DateGroupItem) UnmarshalXML ¶ 

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

func (*CT_DateGroupItem) Validate ¶ 

func (m *CT_DateGroupItem) Validate() error

Validate validates the CT_DateGroupItem and its children

func (*CT_DateGroupItem) ValidateWithPath ¶ 

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

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

type CT_DateTime ¶ 

type CT_DateTime struct {
	// Value
	VAttr time.Time
	// Unused Item
	UAttr *bool
	// Calculated Item Value
	FAttr *bool
	// Caption
	CAttr *string
	// Member Property Count
	CpAttr *uint32
	// Member Property Index
	X []*CT_X
}

func NewCT_DateTime ¶ 

func NewCT_DateTime() *CT_DateTime

func (*CT_DateTime) MarshalXML ¶ 

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

func (*CT_DateTime) UnmarshalXML ¶ 

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

func (*CT_DateTime) Validate ¶ 

func (m *CT_DateTime) Validate() error

Validate validates the CT_DateTime and its children

func (*CT_DateTime) ValidateWithPath ¶ 

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

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

type CT_DbPr ¶ 

type CT_DbPr struct {
	// Connection String
	ConnectionAttr string
	// Command Text
	CommandAttr *string
	// Command Text
	ServerCommandAttr *string
	// OLE DB Command Type
	CommandTypeAttr *uint32
}

func NewCT_DbPr ¶ 

func NewCT_DbPr() *CT_DbPr

func (*CT_DbPr) MarshalXML ¶ 

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

func (*CT_DbPr) UnmarshalXML ¶ 

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

func (*CT_DbPr) Validate ¶ 

func (m *CT_DbPr) Validate() error

Validate validates the CT_DbPr and its children

func (*CT_DbPr) ValidateWithPath ¶ 

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

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

type CT_DdeItem ¶ 

type CT_DdeItem struct {
	// DDE Name
	NameAttr *string
	// Object Linking TechnologyE
	OleAttr *bool
	// Advise
	AdviseAttr *bool
	// Data is an Image
	PreferPicAttr *bool
	// DDE Name Values
	Values *CT_DdeValues
}

func NewCT_DdeItem ¶ 

func NewCT_DdeItem() *CT_DdeItem

func (*CT_DdeItem) MarshalXML ¶ 

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

func (*CT_DdeItem) UnmarshalXML ¶ 

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

func (*CT_DdeItem) Validate ¶ 

func (m *CT_DdeItem) Validate() error

Validate validates the CT_DdeItem and its children

func (*CT_DdeItem) ValidateWithPath ¶ 

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

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

type CT_DdeItems ¶ 

type CT_DdeItems struct {
	// DDE Item definition
	DdeItem []*CT_DdeItem
}

func NewCT_DdeItems ¶ 

func NewCT_DdeItems() *CT_DdeItems

func (*CT_DdeItems) MarshalXML ¶ 

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

func (*CT_DdeItems) UnmarshalXML ¶ 

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

func (*CT_DdeItems) Validate ¶ 

func (m *CT_DdeItems) Validate() error

Validate validates the CT_DdeItems and its children

func (*CT_DdeItems) ValidateWithPath ¶ 

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

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

type CT_DdeLink struct {
	// Service name
	DdeServiceAttr string
	// Topic for DDE server
	DdeTopicAttr string
	// DDE Items Collection
	DdeItems *CT_DdeItems
}
func NewCT_DdeLink() *CT_DdeLink

func (*CT_DdeLink) MarshalXML ¶ 

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

func (*CT_DdeLink) UnmarshalXML ¶ 

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

func (*CT_DdeLink) Validate ¶ 

func (m *CT_DdeLink) Validate() error

Validate validates the CT_DdeLink and its children

func (*CT_DdeLink) ValidateWithPath ¶ 

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

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

type CT_DdeValue ¶ 

type CT_DdeValue struct {
	// DDE Value Type
	TAttr ST_DdeValueType
	// DDE Link Value
	Val string
}

func NewCT_DdeValue ¶ 

func NewCT_DdeValue() *CT_DdeValue

func (*CT_DdeValue) MarshalXML ¶ 

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

func (*CT_DdeValue) UnmarshalXML ¶ 

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

func (*CT_DdeValue) Validate ¶ 

func (m *CT_DdeValue) Validate() error

Validate validates the CT_DdeValue and its children

func (*CT_DdeValue) ValidateWithPath ¶ 

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

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

type CT_DdeValues ¶ 

type CT_DdeValues struct {
	// Rows
	RowsAttr *uint32
	// Columns
	ColsAttr *uint32
	// Value
	Value []*CT_DdeValue
}

func NewCT_DdeValues ¶ 

func NewCT_DdeValues() *CT_DdeValues

func (*CT_DdeValues) MarshalXML ¶ 

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

func (*CT_DdeValues) UnmarshalXML ¶ 

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

func (*CT_DdeValues) Validate ¶ 

func (m *CT_DdeValues) Validate() error

Validate validates the CT_DdeValues and its children

func (*CT_DdeValues) ValidateWithPath ¶ 

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

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

type CT_DefinedName ¶ 

type CT_DefinedName struct {
	NameAttr              string
	CommentAttr           *string
	CustomMenuAttr        *string
	DescriptionAttr       *string
	HelpAttr              *string
	StatusBarAttr         *string
	LocalSheetIdAttr      *uint32
	HiddenAttr            *bool
	FunctionAttr          *bool
	VbProcedureAttr       *bool
	XlmAttr               *bool
	FunctionGroupIdAttr   *uint32
	ShortcutKeyAttr       *string
	PublishToServerAttr   *bool
	WorkbookParameterAttr *bool
	Content               string
}

func NewCT_DefinedName ¶ 

func NewCT_DefinedName() *CT_DefinedName

func (*CT_DefinedName) MarshalXML ¶ 

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

func (*CT_DefinedName) UnmarshalXML ¶ 

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

func (*CT_DefinedName) Validate ¶ 

func (m *CT_DefinedName) Validate() error

Validate validates the CT_DefinedName and its children

func (*CT_DefinedName) ValidateWithPath ¶ 

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

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

type CT_DefinedNames ¶ 

type CT_DefinedNames struct {
	// Defined Name
	DefinedName []*CT_DefinedName
}

func NewCT_DefinedNames ¶ 

func NewCT_DefinedNames() *CT_DefinedNames

func (*CT_DefinedNames) MarshalXML ¶ 

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

func (*CT_DefinedNames) UnmarshalXML ¶ 

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

func (*CT_DefinedNames) Validate ¶ 

func (m *CT_DefinedNames) Validate() error

Validate validates the CT_DefinedNames and its children

func (*CT_DefinedNames) ValidateWithPath ¶ 

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

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

type CT_DeletedField ¶ 

type CT_DeletedField struct {
	// Deleted Fields Name
	NameAttr string
}

func NewCT_DeletedField ¶ 

func NewCT_DeletedField() *CT_DeletedField

func (*CT_DeletedField) MarshalXML ¶ 

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

func (*CT_DeletedField) UnmarshalXML ¶ 

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

func (*CT_DeletedField) Validate ¶ 

func (m *CT_DeletedField) Validate() error

Validate validates the CT_DeletedField and its children

func (*CT_DeletedField) ValidateWithPath ¶ 

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

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

type CT_Dialogsheet ¶ 

type CT_Dialogsheet struct {
	// Sheet Properties
	SheetPr *CT_SheetPr
	// Dialog Sheet Views
	SheetViews *CT_SheetViews
	// Dialog Sheet Format Properties
	SheetFormatPr *CT_SheetFormatPr
	// Sheet Protection
	SheetProtection *CT_SheetProtection
	// Custom Sheet Views
	CustomSheetViews *CT_CustomSheetViews
	// Print Options
	PrintOptions *CT_PrintOptions
	// Page Margins
	PageMargins *CT_PageMargins
	// Page Setup Settings
	PageSetup *CT_PageSetup
	// Header & Footer Settings
	HeaderFooter *CT_HeaderFooter
	// Drawing
	Drawing *CT_Drawing
	// Legacy Drawing
	LegacyDrawing *CT_LegacyDrawing
	// Legacy Drawing Header Footer
	LegacyDrawingHF *CT_LegacyDrawing
	DrawingHF       *CT_DrawingHF
	OleObjects      *CT_OleObjects
	Controls        *CT_Controls
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_Dialogsheet ¶ 

func NewCT_Dialogsheet() *CT_Dialogsheet

func (*CT_Dialogsheet) MarshalXML ¶ 

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

func (*CT_Dialogsheet) UnmarshalXML ¶ 

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

func (*CT_Dialogsheet) Validate ¶ 

func (m *CT_Dialogsheet) Validate() error

Validate validates the CT_Dialogsheet and its children

func (*CT_Dialogsheet) ValidateWithPath ¶ 

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

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

type CT_Dimensions ¶ 

type CT_Dimensions struct {
	// OLAP Dimensions Count
	CountAttr *uint32
	// OLAP Dimension
	Dimension []*CT_PivotDimension
}

func NewCT_Dimensions ¶ 

func NewCT_Dimensions() *CT_Dimensions

func (*CT_Dimensions) MarshalXML ¶ 

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

func (*CT_Dimensions) UnmarshalXML ¶ 

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

func (*CT_Dimensions) Validate ¶ 

func (m *CT_Dimensions) Validate() error

Validate validates the CT_Dimensions and its children

func (*CT_Dimensions) ValidateWithPath ¶ 

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

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

type CT_DiscretePr ¶ 

type CT_DiscretePr struct {
	// Mapping Index Count
	CountAttr *uint32
	// Element Group
	X []*CT_Index
}

func NewCT_DiscretePr ¶ 

func NewCT_DiscretePr() *CT_DiscretePr

func (*CT_DiscretePr) MarshalXML ¶ 

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

func (*CT_DiscretePr) UnmarshalXML ¶ 

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

func (*CT_DiscretePr) Validate ¶ 

func (m *CT_DiscretePr) Validate() error

Validate validates the CT_DiscretePr and its children

func (*CT_DiscretePr) ValidateWithPath ¶ 

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

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

type CT_Drawing ¶ 

type CT_Drawing struct {
	IdAttr string
}

func NewCT_Drawing ¶ 

func NewCT_Drawing() *CT_Drawing

func (*CT_Drawing) MarshalXML ¶ 

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

func (*CT_Drawing) UnmarshalXML ¶ 

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

func (*CT_Drawing) Validate ¶ 

func (m *CT_Drawing) Validate() error

Validate validates the CT_Drawing and its children

func (*CT_Drawing) ValidateWithPath ¶ 

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

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

type CT_DrawingHF ¶ 

type CT_DrawingHF struct {
	IdAttr string
	// Left Header for Odd Pages
	LhoAttr *uint32
	// Left Header for Even Pages
	LheAttr *uint32
	// Left Header for First Page
	LhfAttr *uint32
	// Center Header for Odd Pages
	ChoAttr *uint32
	// Center Header for Even Pages
	CheAttr *uint32
	// Center Header for First Page
	ChfAttr *uint32
	// Right Header for Odd Pages
	RhoAttr *uint32
	// Right Header for Even Pages
	RheAttr *uint32
	// Right Header for First Page
	RhfAttr *uint32
	// Left Footer for Odd Pages
	LfoAttr *uint32
	// Left Footer for Even Pages
	LfeAttr *uint32
	// Left Footer for First Page
	LffAttr *uint32
	// Center Footer for Odd Pages
	CfoAttr *uint32
	// Center Footer for Even Pages
	CfeAttr *uint32
	// Center Footer for First Page
	CffAttr *uint32
	// Right Footer for Odd Pages
	RfoAttr *uint32
	// Right Footer for Even Pages
	RfeAttr *uint32
	// Right Footer for First Page
	RffAttr *uint32
}

func NewCT_DrawingHF ¶ 

func NewCT_DrawingHF() *CT_DrawingHF

func (*CT_DrawingHF) MarshalXML ¶ 

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

func (*CT_DrawingHF) UnmarshalXML ¶ 

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

func (*CT_DrawingHF) Validate ¶ 

func (m *CT_DrawingHF) Validate() error

Validate validates the CT_DrawingHF and its children

func (*CT_DrawingHF) ValidateWithPath ¶ 

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

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

type CT_Dxf ¶ 

type CT_Dxf struct {
	// Font Properties
	Font *CT_Font
	// Number Format
	NumFmt *CT_NumFmt
	// Fill
	Fill *CT_Fill
	// Alignment
	Alignment *CT_CellAlignment
	// Border Properties
	Border *CT_Border
	// Protection Properties
	Protection *CT_CellProtection
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_Dxf ¶ 

func NewCT_Dxf() *CT_Dxf

func (*CT_Dxf) MarshalXML ¶ 

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

func (*CT_Dxf) UnmarshalXML ¶ 

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

func (*CT_Dxf) Validate ¶ 

func (m *CT_Dxf) Validate() error

Validate validates the CT_Dxf and its children

func (*CT_Dxf) ValidateWithPath ¶ 

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

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

type CT_Dxfs ¶ 

type CT_Dxfs struct {
	// Format Count
	CountAttr *uint32
	// Formatting
	Dxf []*CT_Dxf
}

func NewCT_Dxfs ¶ 

func NewCT_Dxfs() *CT_Dxfs

func (*CT_Dxfs) MarshalXML ¶ 

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

func (*CT_Dxfs) UnmarshalXML ¶ 

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

func (*CT_Dxfs) Validate ¶ 

func (m *CT_Dxfs) Validate() error

Validate validates the CT_Dxfs and its children

func (*CT_Dxfs) ValidateWithPath ¶ 

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

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

type CT_DynamicFilter ¶ 

type CT_DynamicFilter struct {
	// Dynamic filter type
	TypeAttr ST_DynamicFilterType
	// Value
	ValAttr *float64
	// ISO Value
	ValIsoAttr *time.Time
	// Max Value
	MaxValAttr *float64
	// Max ISO Value
	MaxValIsoAttr *time.Time
}

func NewCT_DynamicFilter ¶ 

func NewCT_DynamicFilter() *CT_DynamicFilter

func (*CT_DynamicFilter) MarshalXML ¶ 

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

func (*CT_DynamicFilter) UnmarshalXML ¶ 

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

func (*CT_DynamicFilter) Validate ¶ 

func (m *CT_DynamicFilter) Validate() error

Validate validates the CT_DynamicFilter and its children

func (*CT_DynamicFilter) ValidateWithPath ¶ 

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

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

type CT_Error ¶ 

type CT_Error struct {
	// Value
	VAttr string
	// Unused Item
	UAttr *bool
	// Calculated Item
	FAttr *bool
	// Item Caption
	CAttr *string
	// Member Property Count
	CpAttr *uint32
	// Format Index
	InAttr *uint32
	// background Color
	BcAttr *string
	// Foreground Color
	FcAttr *string
	// Italic
	IAttr *bool
	// Underline
	UnAttr *bool
	// Strikethrough
	StAttr *bool
	// Bold
	BAttr *bool
	// Tuples
	Tpls *CT_Tuples
	// Member Property Indexes
	X []*CT_X
}

func NewCT_Error ¶ 

func NewCT_Error() *CT_Error

func (*CT_Error) MarshalXML ¶ 

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

func (*CT_Error) UnmarshalXML ¶ 

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

func (*CT_Error) Validate ¶ 

func (m *CT_Error) Validate() error

Validate validates the CT_Error and its children

func (*CT_Error) ValidateWithPath ¶ 

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

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

type CT_Extension ¶ 

type CT_Extension struct {
	// URI
	UriAttr *string
	Any     gooxml.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_ExternalBook ¶ 

type CT_ExternalBook struct {
	IdAttr string
	// Supporting Workbook Sheet Names
	SheetNames *CT_ExternalSheetNames
	// Named Links
	DefinedNames *CT_ExternalDefinedNames
	// Cached Worksheet Data
	SheetDataSet *CT_ExternalSheetDataSet
}

func NewCT_ExternalBook ¶ 

func NewCT_ExternalBook() *CT_ExternalBook

func (*CT_ExternalBook) MarshalXML ¶ 

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

func (*CT_ExternalBook) UnmarshalXML ¶ 

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

func (*CT_ExternalBook) Validate ¶ 

func (m *CT_ExternalBook) Validate() error

Validate validates the CT_ExternalBook and its children

func (*CT_ExternalBook) ValidateWithPath ¶ 

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

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

type CT_ExternalCell ¶ 

type CT_ExternalCell struct {
	// Reference
	RAttr *string
	// Type
	TAttr ST_CellType
	// Value Metadata
	VmAttr *uint32
	// Value
	V *string
}

func NewCT_ExternalCell ¶ 

func NewCT_ExternalCell() *CT_ExternalCell

func (*CT_ExternalCell) MarshalXML ¶ 

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

func (*CT_ExternalCell) UnmarshalXML ¶ 

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

func (*CT_ExternalCell) Validate ¶ 

func (m *CT_ExternalCell) Validate() error

Validate validates the CT_ExternalCell and its children

func (*CT_ExternalCell) ValidateWithPath ¶ 

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

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

type CT_ExternalDefinedName ¶ 

type CT_ExternalDefinedName struct {
	// Defined Name
	NameAttr string
	// Refers To
	RefersToAttr *string
	// Sheet Id
	SheetIdAttr *uint32
}

func NewCT_ExternalDefinedName ¶ 

func NewCT_ExternalDefinedName() *CT_ExternalDefinedName

func (*CT_ExternalDefinedName) MarshalXML ¶ 

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

func (*CT_ExternalDefinedName) UnmarshalXML ¶ 

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

func (*CT_ExternalDefinedName) Validate ¶ 

func (m *CT_ExternalDefinedName) Validate() error

Validate validates the CT_ExternalDefinedName and its children

func (*CT_ExternalDefinedName) ValidateWithPath ¶ 

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

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

type CT_ExternalDefinedNames ¶ 

type CT_ExternalDefinedNames struct {
	// Defined Name
	DefinedName []*CT_ExternalDefinedName
}

func NewCT_ExternalDefinedNames ¶ 

func NewCT_ExternalDefinedNames() *CT_ExternalDefinedNames

func (*CT_ExternalDefinedNames) MarshalXML ¶ 

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

func (*CT_ExternalDefinedNames) UnmarshalXML ¶ 

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

func (*CT_ExternalDefinedNames) Validate ¶ 

func (m *CT_ExternalDefinedNames) Validate() error

Validate validates the CT_ExternalDefinedNames and its children

func (*CT_ExternalDefinedNames) ValidateWithPath ¶ 

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

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

type CT_ExternalLink struct {
	Choice *CT_ExternalLinkChoice
	ExtLst *CT_ExtensionList
}
func NewCT_ExternalLink() *CT_ExternalLink

func (*CT_ExternalLink) MarshalXML ¶ 

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

func (*CT_ExternalLink) UnmarshalXML ¶ 

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

func (*CT_ExternalLink) Validate ¶ 

func (m *CT_ExternalLink) Validate() error

Validate validates the CT_ExternalLink and its children

func (*CT_ExternalLink) ValidateWithPath ¶ 

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

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

type CT_ExternalLinkChoice ¶ 

type CT_ExternalLinkChoice struct {
	ExternalBook *CT_ExternalBook
	DdeLink      *CT_DdeLink
	OleLink      *CT_OleLink
}

func NewCT_ExternalLinkChoice ¶ 

func NewCT_ExternalLinkChoice() *CT_ExternalLinkChoice

func (*CT_ExternalLinkChoice) MarshalXML ¶ 

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

func (*CT_ExternalLinkChoice) UnmarshalXML ¶ 

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

func (*CT_ExternalLinkChoice) Validate ¶ 

func (m *CT_ExternalLinkChoice) Validate() error

Validate validates the CT_ExternalLinkChoice and its children

func (*CT_ExternalLinkChoice) ValidateWithPath ¶ 

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

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

type CT_ExternalReference ¶ 

type CT_ExternalReference struct {
	IdAttr string
}

func NewCT_ExternalReference ¶ 

func NewCT_ExternalReference() *CT_ExternalReference

func (*CT_ExternalReference) MarshalXML ¶ 

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

func (*CT_ExternalReference) UnmarshalXML ¶ 

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

func (*CT_ExternalReference) Validate ¶ 

func (m *CT_ExternalReference) Validate() error

Validate validates the CT_ExternalReference and its children

func (*CT_ExternalReference) ValidateWithPath ¶ 

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

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

type CT_ExternalReferences ¶ 

type CT_ExternalReferences struct {
	// External Reference
	ExternalReference []*CT_ExternalReference
}

func NewCT_ExternalReferences ¶ 

func NewCT_ExternalReferences() *CT_ExternalReferences

func (*CT_ExternalReferences) MarshalXML ¶ 

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

func (*CT_ExternalReferences) UnmarshalXML ¶ 

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

func (*CT_ExternalReferences) Validate ¶ 

func (m *CT_ExternalReferences) Validate() error

Validate validates the CT_ExternalReferences and its children

func (*CT_ExternalReferences) ValidateWithPath ¶ 

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

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

type CT_ExternalRow ¶ 

type CT_ExternalRow struct {
	// Row
	RAttr uint32
	// External Cell Data
	Cell []*CT_ExternalCell
}

func NewCT_ExternalRow ¶ 

func NewCT_ExternalRow() *CT_ExternalRow

func (*CT_ExternalRow) MarshalXML ¶ 

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

func (*CT_ExternalRow) UnmarshalXML ¶ 

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

func (*CT_ExternalRow) Validate ¶ 

func (m *CT_ExternalRow) Validate() error

Validate validates the CT_ExternalRow and its children

func (*CT_ExternalRow) ValidateWithPath ¶ 

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

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

type CT_ExternalSheetData ¶ 

type CT_ExternalSheetData struct {
	// Sheet Id
	SheetIdAttr uint32
	// Last Refresh Resulted in Error
	RefreshErrorAttr *bool
	// Row
	Row []*CT_ExternalRow
}

func NewCT_ExternalSheetData ¶ 

func NewCT_ExternalSheetData() *CT_ExternalSheetData

func (*CT_ExternalSheetData) MarshalXML ¶ 

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

func (*CT_ExternalSheetData) UnmarshalXML ¶ 

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

func (*CT_ExternalSheetData) Validate ¶ 

func (m *CT_ExternalSheetData) Validate() error

Validate validates the CT_ExternalSheetData and its children

func (*CT_ExternalSheetData) ValidateWithPath ¶ 

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

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

type CT_ExternalSheetDataSet ¶ 

type CT_ExternalSheetDataSet struct {
	// External Sheet Data Set
	SheetData []*CT_ExternalSheetData
}

func NewCT_ExternalSheetDataSet ¶ 

func NewCT_ExternalSheetDataSet() *CT_ExternalSheetDataSet

func (*CT_ExternalSheetDataSet) MarshalXML ¶ 

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

func (*CT_ExternalSheetDataSet) UnmarshalXML ¶ 

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

func (*CT_ExternalSheetDataSet) Validate ¶ 

func (m *CT_ExternalSheetDataSet) Validate() error

Validate validates the CT_ExternalSheetDataSet and its children

func (*CT_ExternalSheetDataSet) ValidateWithPath ¶ 

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

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

type CT_ExternalSheetName ¶ 

type CT_ExternalSheetName struct {
	// Sheet Name Value
	ValAttr *string
}

func NewCT_ExternalSheetName ¶ 

func NewCT_ExternalSheetName() *CT_ExternalSheetName

func (*CT_ExternalSheetName) MarshalXML ¶ 

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

func (*CT_ExternalSheetName) UnmarshalXML ¶ 

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

func (*CT_ExternalSheetName) Validate ¶ 

func (m *CT_ExternalSheetName) Validate() error

Validate validates the CT_ExternalSheetName and its children

func (*CT_ExternalSheetName) ValidateWithPath ¶ 

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

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

type CT_ExternalSheetNames ¶ 

type CT_ExternalSheetNames struct {
	// Sheet Name
	SheetName []*CT_ExternalSheetName
}

func NewCT_ExternalSheetNames ¶ 

func NewCT_ExternalSheetNames() *CT_ExternalSheetNames

func (*CT_ExternalSheetNames) MarshalXML ¶ 

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

func (*CT_ExternalSheetNames) UnmarshalXML ¶ 

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

func (*CT_ExternalSheetNames) Validate ¶ 

func (m *CT_ExternalSheetNames) Validate() error

Validate validates the CT_ExternalSheetNames and its children

func (*CT_ExternalSheetNames) ValidateWithPath ¶ 

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

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

type CT_Field ¶ 

type CT_Field struct {
	// Field Index
	XAttr int32
}

func NewCT_Field ¶ 

func NewCT_Field() *CT_Field

func (*CT_Field) MarshalXML ¶ 

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

func (*CT_Field) UnmarshalXML ¶ 

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

func (*CT_Field) Validate ¶ 

func (m *CT_Field) Validate() error

Validate validates the CT_Field and its children

func (*CT_Field) ValidateWithPath ¶ 

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

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

type CT_FieldGroup ¶ 

type CT_FieldGroup struct {
	// Parent
	ParAttr *uint32
	// Field Base
	BaseAttr *uint32
	// Range Grouping Properties
	RangePr *CT_RangePr
	// Discrete Grouping Properties
	DiscretePr *CT_DiscretePr
	// OLAP Group Items
	GroupItems *CT_GroupItems
}

func NewCT_FieldGroup ¶ 

func NewCT_FieldGroup() *CT_FieldGroup

func (*CT_FieldGroup) MarshalXML ¶ 

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

func (*CT_FieldGroup) UnmarshalXML ¶ 

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

func (*CT_FieldGroup) Validate ¶ 

func (m *CT_FieldGroup) Validate() error

Validate validates the CT_FieldGroup and its children

func (*CT_FieldGroup) ValidateWithPath ¶ 

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

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

type CT_FieldUsage ¶ 

type CT_FieldUsage struct {
	// Field Index
	XAttr int32
}

func NewCT_FieldUsage ¶ 

func NewCT_FieldUsage() *CT_FieldUsage

func (*CT_FieldUsage) MarshalXML ¶ 

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

func (*CT_FieldUsage) UnmarshalXML ¶ 

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

func (*CT_FieldUsage) Validate ¶ 

func (m *CT_FieldUsage) Validate() error

Validate validates the CT_FieldUsage and its children

func (*CT_FieldUsage) ValidateWithPath ¶ 

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

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

type CT_FieldsUsage ¶ 

type CT_FieldsUsage struct {
	// Field Count
	CountAttr *uint32
	// PivotCache Field Id
	FieldUsage []*CT_FieldUsage
}

func NewCT_FieldsUsage ¶ 

func NewCT_FieldsUsage() *CT_FieldsUsage

func (*CT_FieldsUsage) MarshalXML ¶ 

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

func (*CT_FieldsUsage) UnmarshalXML ¶ 

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

func (*CT_FieldsUsage) Validate ¶ 

func (m *CT_FieldsUsage) Validate() error

Validate validates the CT_FieldsUsage and its children

func (*CT_FieldsUsage) ValidateWithPath ¶ 

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

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

type CT_FileRecoveryPr ¶ 

type CT_FileRecoveryPr struct {
	// Auto Recover
	AutoRecoverAttr *bool
	// Crash Save
	CrashSaveAttr *bool
	// Data Extract Load
	DataExtractLoadAttr *bool
	// Repair Load
	RepairLoadAttr *bool
}

func NewCT_FileRecoveryPr ¶ 

func NewCT_FileRecoveryPr() *CT_FileRecoveryPr

func (*CT_FileRecoveryPr) MarshalXML ¶ 

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

func (*CT_FileRecoveryPr) UnmarshalXML ¶ 

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

func (*CT_FileRecoveryPr) Validate ¶ 

func (m *CT_FileRecoveryPr) Validate() error

Validate validates the CT_FileRecoveryPr and its children

func (*CT_FileRecoveryPr) ValidateWithPath ¶ 

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

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

type CT_FileSharing ¶ 

type CT_FileSharing struct {
	// Read Only Recommended
	ReadOnlyRecommendedAttr *bool
	// User Name
	UserNameAttr *string
	// Write Reservation Password
	ReservationPasswordAttr *string
	// Cryptographic Algorithm Name
	AlgorithmNameAttr *string
	// Password Hash Value
	HashValueAttr *string
	// Salt Value for Password Verifier
	SaltValueAttr *string
	// Iterations to Run Hashing Algorithm
	SpinCountAttr *uint32
}

func NewCT_FileSharing ¶ 

func NewCT_FileSharing() *CT_FileSharing

func (*CT_FileSharing) MarshalXML ¶ 

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

func (*CT_FileSharing) UnmarshalXML ¶ 

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

func (*CT_FileSharing) Validate ¶ 

func (m *CT_FileSharing) Validate() error

Validate validates the CT_FileSharing and its children

func (*CT_FileSharing) ValidateWithPath ¶ 

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

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

type CT_FileVersion ¶ 

type CT_FileVersion struct {
	// Application Name
	AppNameAttr *string
	// Last Edited Version
	LastEditedAttr *string
	// Lowest Edited Version
	LowestEditedAttr *string
	// Build Version
	RupBuildAttr *string
	// Code Name
	CodeNameAttr *string
}

func NewCT_FileVersion ¶ 

func NewCT_FileVersion() *CT_FileVersion

func (*CT_FileVersion) MarshalXML ¶ 

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

func (*CT_FileVersion) UnmarshalXML ¶ 

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

func (*CT_FileVersion) Validate ¶ 

func (m *CT_FileVersion) Validate() error

Validate validates the CT_FileVersion and its children

func (*CT_FileVersion) ValidateWithPath ¶ 

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

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

type CT_Fill ¶ 

type CT_Fill struct {
	// Pattern
	PatternFill *CT_PatternFill
	// Gradient
	GradientFill *CT_GradientFill
}

func NewCT_Fill ¶ 

func NewCT_Fill() *CT_Fill

func (*CT_Fill) MarshalXML ¶ 

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

func (*CT_Fill) UnmarshalXML ¶ 

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

func (*CT_Fill) Validate ¶ 

func (m *CT_Fill) Validate() error

Validate validates the CT_Fill and its children

func (*CT_Fill) ValidateWithPath ¶ 

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

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

type CT_Fills ¶ 

type CT_Fills struct {
	// Fill Count
	CountAttr *uint32
	// Fill
	Fill []*CT_Fill
}

func NewCT_Fills ¶ 

func NewCT_Fills() *CT_Fills

func (*CT_Fills) MarshalXML ¶ 

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

func (*CT_Fills) UnmarshalXML ¶ 

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

func (*CT_Fills) Validate ¶ 

func (m *CT_Fills) Validate() error

Validate validates the CT_Fills and its children

func (*CT_Fills) ValidateWithPath ¶ 

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

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

type CT_Filter ¶ 

type CT_Filter struct {
	// Filter Value
	ValAttr *string
}

func NewCT_Filter ¶ 

func NewCT_Filter() *CT_Filter

func (*CT_Filter) MarshalXML ¶ 

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

func (*CT_Filter) UnmarshalXML ¶ 

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

func (*CT_Filter) Validate ¶ 

func (m *CT_Filter) Validate() error

Validate validates the CT_Filter and its children

func (*CT_Filter) ValidateWithPath ¶ 

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

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

type CT_FilterColumn ¶ 

type CT_FilterColumn struct {
	// Filter Column Data
	ColIdAttr uint32
	// Hidden AutoFilter Button
	HiddenButtonAttr *bool
	// Show Filter Button
	ShowButtonAttr *bool
	// Filter Criteria
	Filters *CT_Filters
	// Top 10
	Top10 *CT_Top10
	// Custom Filters
	CustomFilters *CT_CustomFilters
	// Dynamic Filter
	DynamicFilter *CT_DynamicFilter
	// Color Filter Criteria
	ColorFilter *CT_ColorFilter
	// Icon Filter
	IconFilter *CT_IconFilter
	ExtLst     *CT_ExtensionList
}

func NewCT_FilterColumn ¶ 

func NewCT_FilterColumn() *CT_FilterColumn

func (*CT_FilterColumn) MarshalXML ¶ 

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

func (*CT_FilterColumn) UnmarshalXML ¶ 

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

func (*CT_FilterColumn) Validate ¶ 

func (m *CT_FilterColumn) Validate() error

Validate validates the CT_FilterColumn and its children

func (*CT_FilterColumn) ValidateWithPath ¶ 

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

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

type CT_Filters ¶ 

type CT_Filters struct {
	// Filter by Blank
	BlankAttr *bool
	// Calendar Type
	CalendarTypeAttr sharedTypes.ST_CalendarType
	// Filter
	Filter []*CT_Filter
	// Date Grouping
	DateGroupItem []*CT_DateGroupItem
}

func NewCT_Filters ¶ 

func NewCT_Filters() *CT_Filters

func (*CT_Filters) MarshalXML ¶ 

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

func (*CT_Filters) UnmarshalXML ¶ 

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

func (*CT_Filters) Validate ¶ 

func (m *CT_Filters) Validate() error

Validate validates the CT_Filters and its children

func (*CT_Filters) ValidateWithPath ¶ 

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

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

type CT_Font ¶ 

type CT_Font struct {
	// Font Name
	Name []*CT_FontName
	// Character Set
	Charset []*CT_IntProperty
	// Font Family
	Family []*CT_FontFamily
	// Bold
	B []*CT_BooleanProperty
	// Italic
	I []*CT_BooleanProperty
	// Strike Through
	Strike []*CT_BooleanProperty
	// Outline
	Outline []*CT_BooleanProperty
	// Shadow
	Shadow []*CT_BooleanProperty
	// Condense
	Condense []*CT_BooleanProperty
	// Extend
	Extend []*CT_BooleanProperty
	// Text Color
	Color []*CT_Color
	// Font Size
	Sz []*CT_FontSize
	// Underline
	U []*CT_UnderlineProperty
	// Text Vertical Alignment
	VertAlign []*CT_VerticalAlignFontProperty
	// Scheme
	Scheme []*CT_FontScheme
}

func NewCT_Font ¶ 

func NewCT_Font() *CT_Font

func (*CT_Font) MarshalXML ¶ 

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

func (*CT_Font) UnmarshalXML ¶ 

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

func (*CT_Font) Validate ¶ 

func (m *CT_Font) Validate() error

Validate validates the CT_Font and its children

func (*CT_Font) ValidateWithPath ¶ 

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

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

type CT_FontFamily ¶ 

type CT_FontFamily struct {
	ValAttr int64
}

func NewCT_FontFamily ¶ 

func NewCT_FontFamily() *CT_FontFamily

func (*CT_FontFamily) MarshalXML ¶ 

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

func (*CT_FontFamily) UnmarshalXML ¶ 

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

func (*CT_FontFamily) Validate ¶ 

func (m *CT_FontFamily) Validate() error

Validate validates the CT_FontFamily and its children

func (*CT_FontFamily) ValidateWithPath ¶ 

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

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

type CT_FontName ¶ 

type CT_FontName struct {
	// String Value
	ValAttr string
}

func NewCT_FontName ¶ 

func NewCT_FontName() *CT_FontName

func (*CT_FontName) MarshalXML ¶ 

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

func (*CT_FontName) UnmarshalXML ¶ 

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

func (*CT_FontName) Validate ¶ 

func (m *CT_FontName) Validate() error

Validate validates the CT_FontName and its children

func (*CT_FontName) ValidateWithPath ¶ 

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

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

type CT_FontScheme ¶ 

type CT_FontScheme struct {
	// Font Scheme
	ValAttr ST_FontScheme
}

func NewCT_FontScheme ¶ 

func NewCT_FontScheme() *CT_FontScheme

func (*CT_FontScheme) MarshalXML ¶ 

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

func (*CT_FontScheme) UnmarshalXML ¶ 

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

func (*CT_FontScheme) Validate ¶ 

func (m *CT_FontScheme) Validate() error

Validate validates the CT_FontScheme and its children

func (*CT_FontScheme) ValidateWithPath ¶ 

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

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

type CT_FontSize ¶ 

type CT_FontSize struct {
	// Value
	ValAttr float64
}

func NewCT_FontSize ¶ 

func NewCT_FontSize() *CT_FontSize

func (*CT_FontSize) MarshalXML ¶ 

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

func (*CT_FontSize) UnmarshalXML ¶ 

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

func (*CT_FontSize) Validate ¶ 

func (m *CT_FontSize) Validate() error

Validate validates the CT_FontSize and its children

func (*CT_FontSize) ValidateWithPath ¶ 

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

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

type CT_Fonts ¶ 

type CT_Fonts struct {
	// Font Count
	CountAttr *uint32
	// Font
	Font []*CT_Font
}

func NewCT_Fonts ¶ 

func NewCT_Fonts() *CT_Fonts

func (*CT_Fonts) MarshalXML ¶ 

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

func (*CT_Fonts) UnmarshalXML ¶ 

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

func (*CT_Fonts) Validate ¶ 

func (m *CT_Fonts) Validate() error

Validate validates the CT_Fonts and its children

func (*CT_Fonts) ValidateWithPath ¶ 

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

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

type CT_Format ¶ 

type CT_Format struct {
	// Format Action
	ActionAttr ST_FormatAction
	// Format Id
	DxfIdAttr *uint32
	// Pivot Table Location
	PivotArea *CT_PivotArea
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_Format ¶ 

func NewCT_Format() *CT_Format

func (*CT_Format) MarshalXML ¶ 

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

func (*CT_Format) UnmarshalXML ¶ 

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

func (*CT_Format) Validate ¶ 

func (m *CT_Format) Validate() error

Validate validates the CT_Format and its children

func (*CT_Format) ValidateWithPath ¶ 

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

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

type CT_Formats ¶ 

type CT_Formats struct {
	// Formats Count
	CountAttr *uint32
	// PivotTable Format
	Format []*CT_Format
}

func NewCT_Formats ¶ 

func NewCT_Formats() *CT_Formats

func (*CT_Formats) MarshalXML ¶ 

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

func (*CT_Formats) UnmarshalXML ¶ 

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

func (*CT_Formats) Validate ¶ 

func (m *CT_Formats) Validate() error

Validate validates the CT_Formats and its children

func (*CT_Formats) ValidateWithPath ¶ 

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

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

type CT_FunctionGroup ¶ 

type CT_FunctionGroup struct {
	// Name
	NameAttr *string
}

func NewCT_FunctionGroup ¶ 

func NewCT_FunctionGroup() *CT_FunctionGroup

func (*CT_FunctionGroup) MarshalXML ¶ 

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

func (*CT_FunctionGroup) UnmarshalXML ¶ 

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

func (*CT_FunctionGroup) Validate ¶ 

func (m *CT_FunctionGroup) Validate() error

Validate validates the CT_FunctionGroup and its children

func (*CT_FunctionGroup) ValidateWithPath ¶ 

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

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

type CT_FunctionGroups ¶ 

type CT_FunctionGroups struct {
	// Built-in Function Group Count
	BuiltInGroupCountAttr *uint32
	// Function Group
	FunctionGroup []*CT_FunctionGroup
}

func NewCT_FunctionGroups ¶ 

func NewCT_FunctionGroups() *CT_FunctionGroups

func (*CT_FunctionGroups) MarshalXML ¶ 

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

func (*CT_FunctionGroups) UnmarshalXML ¶ 

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

func (*CT_FunctionGroups) Validate ¶ 

func (m *CT_FunctionGroups) Validate() error

Validate validates the CT_FunctionGroups and its children

func (*CT_FunctionGroups) ValidateWithPath ¶ 

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

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

type CT_FutureMetadata ¶ 

type CT_FutureMetadata struct {
	// Metadata Type Name
	NameAttr string
	// Future Metadata Block Count
	CountAttr *uint32
	// Future Metadata Block
	Bk []*CT_FutureMetadataBlock
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_FutureMetadata ¶ 

func NewCT_FutureMetadata() *CT_FutureMetadata

func (*CT_FutureMetadata) MarshalXML ¶ 

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

func (*CT_FutureMetadata) UnmarshalXML ¶ 

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

func (*CT_FutureMetadata) Validate ¶ 

func (m *CT_FutureMetadata) Validate() error

Validate validates the CT_FutureMetadata and its children

func (*CT_FutureMetadata) ValidateWithPath ¶ 

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

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

type CT_FutureMetadataBlock ¶ 

type CT_FutureMetadataBlock struct {
	// Future Feature Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_FutureMetadataBlock ¶ 

func NewCT_FutureMetadataBlock() *CT_FutureMetadataBlock

func (*CT_FutureMetadataBlock) MarshalXML ¶ 

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

func (*CT_FutureMetadataBlock) UnmarshalXML ¶ 

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

func (*CT_FutureMetadataBlock) Validate ¶ 

func (m *CT_FutureMetadataBlock) Validate() error

Validate validates the CT_FutureMetadataBlock and its children

func (*CT_FutureMetadataBlock) ValidateWithPath ¶ 

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

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

type CT_GradientFill ¶ 

type CT_GradientFill struct {
	// Gradient Fill Type
	TypeAttr ST_GradientType
	// Linear Gradient Degree
	DegreeAttr *float64
	// Left Convergence
	LeftAttr *float64
	// Right Convergence
	RightAttr *float64
	// Top Gradient Convergence
	TopAttr *float64
	// Bottom Convergence
	BottomAttr *float64
	// Gradient Stop
	Stop []*CT_GradientStop
}

func NewCT_GradientFill ¶ 

func NewCT_GradientFill() *CT_GradientFill

func (*CT_GradientFill) MarshalXML ¶ 

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

func (*CT_GradientFill) UnmarshalXML ¶ 

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

func (*CT_GradientFill) Validate ¶ 

func (m *CT_GradientFill) Validate() error

Validate validates the CT_GradientFill and its children

func (*CT_GradientFill) ValidateWithPath ¶ 

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

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

type CT_GradientStop ¶ 

type CT_GradientStop struct {
	// Gradient Stop Position
	PositionAttr float64
	// Color
	Color *CT_Color
}

func NewCT_GradientStop ¶ 

func NewCT_GradientStop() *CT_GradientStop

func (*CT_GradientStop) MarshalXML ¶ 

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

func (*CT_GradientStop) UnmarshalXML ¶ 

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

func (*CT_GradientStop) Validate ¶ 

func (m *CT_GradientStop) Validate() error

Validate validates the CT_GradientStop and its children

func (*CT_GradientStop) ValidateWithPath ¶ 

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

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

type CT_GroupItems ¶ 

type CT_GroupItems struct {
	// Items Created Count
	CountAttr *uint32
	// No Value
	M []*CT_Missing
	// Numeric Value
	N []*CT_Number
	// Boolean
	B []*CT_Boolean
	// Error Value
	E []*CT_Error
	// Character Value
	S []*CT_String
	// Date Time
	D []*CT_DateTime
}

func NewCT_GroupItems ¶ 

func NewCT_GroupItems() *CT_GroupItems

func (*CT_GroupItems) MarshalXML ¶ 

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

func (*CT_GroupItems) UnmarshalXML ¶ 

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

func (*CT_GroupItems) Validate ¶ 

func (m *CT_GroupItems) Validate() error

Validate validates the CT_GroupItems and its children

func (*CT_GroupItems) ValidateWithPath ¶ 

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

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

type CT_GroupLevel ¶ 

type CT_GroupLevel struct {
	// Unique Name
	UniqueNameAttr string
	// Grouping Level Display Name
	CaptionAttr string
	// User-Defined Group Level
	UserAttr *bool
	// Custom Roll Up
	CustomRollUpAttr *bool
	// OLAP Level Groups
	Groups *CT_Groups
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_GroupLevel ¶ 

func NewCT_GroupLevel() *CT_GroupLevel

func (*CT_GroupLevel) MarshalXML ¶ 

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

func (*CT_GroupLevel) UnmarshalXML ¶ 

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

func (*CT_GroupLevel) Validate ¶ 

func (m *CT_GroupLevel) Validate() error

Validate validates the CT_GroupLevel and its children

func (*CT_GroupLevel) ValidateWithPath ¶ 

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

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

type CT_GroupLevels ¶ 

type CT_GroupLevels struct {
	// Grouping Level Count
	CountAttr *uint32
	// OLAP Grouping Levels
	GroupLevel []*CT_GroupLevel
}

func NewCT_GroupLevels ¶ 

func NewCT_GroupLevels() *CT_GroupLevels

func (*CT_GroupLevels) MarshalXML ¶ 

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

func (*CT_GroupLevels) UnmarshalXML ¶ 

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

func (*CT_GroupLevels) Validate ¶ 

func (m *CT_GroupLevels) Validate() error

Validate validates the CT_GroupLevels and its children

func (*CT_GroupLevels) ValidateWithPath ¶ 

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

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

type CT_GroupMember ¶ 

type CT_GroupMember struct {
	// Group Member Unique Name
	UniqueNameAttr string
	// Group
	GroupAttr *bool
}

func NewCT_GroupMember ¶ 

func NewCT_GroupMember() *CT_GroupMember

func (*CT_GroupMember) MarshalXML ¶ 

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

func (*CT_GroupMember) UnmarshalXML ¶ 

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

func (*CT_GroupMember) Validate ¶ 

func (m *CT_GroupMember) Validate() error

Validate validates the CT_GroupMember and its children

func (*CT_GroupMember) ValidateWithPath ¶ 

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

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

type CT_GroupMembers ¶ 

type CT_GroupMembers struct {
	// Group Member Count
	CountAttr *uint32
	// OLAP Group Member
	GroupMember []*CT_GroupMember
}

func NewCT_GroupMembers ¶ 

func NewCT_GroupMembers() *CT_GroupMembers

func (*CT_GroupMembers) MarshalXML ¶ 

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

func (*CT_GroupMembers) UnmarshalXML ¶ 

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

func (*CT_GroupMembers) Validate ¶ 

func (m *CT_GroupMembers) Validate() error

Validate validates the CT_GroupMembers and its children

func (*CT_GroupMembers) ValidateWithPath ¶ 

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

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

type CT_Groups ¶ 

type CT_Groups struct {
	// Level Group Count
	CountAttr *uint32
	// OLAP Group
	Group []*CT_LevelGroup
}

func NewCT_Groups ¶ 

func NewCT_Groups() *CT_Groups

func (*CT_Groups) MarshalXML ¶ 

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

func (*CT_Groups) UnmarshalXML ¶ 

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

func (*CT_Groups) Validate ¶ 

func (m *CT_Groups) Validate() error

Validate validates the CT_Groups and its children

func (*CT_Groups) ValidateWithPath ¶ 

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

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

type CT_HeaderFooter ¶ 

type CT_HeaderFooter struct {
	// Different Odd Even Header Footer
	DifferentOddEvenAttr *bool
	// Different First Page
	DifferentFirstAttr *bool
	// Scale Header & Footer With Document
	ScaleWithDocAttr *bool
	// Align Margins
	AlignWithMarginsAttr *bool
	// Odd Header
	OddHeader *string
	// Odd Page Footer
	OddFooter *string
	// Even Page Header
	EvenHeader *string
	// Even Page Footer
	EvenFooter *string
	// First Page Header
	FirstHeader *string
	// First Page 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_HierarchyUsage ¶ 

type CT_HierarchyUsage struct {
	// Hierarchy Usage
	HierarchyUsageAttr int32
}

func NewCT_HierarchyUsage ¶ 

func NewCT_HierarchyUsage() *CT_HierarchyUsage

func (*CT_HierarchyUsage) MarshalXML ¶ 

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

func (*CT_HierarchyUsage) UnmarshalXML ¶ 

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

func (*CT_HierarchyUsage) Validate ¶ 

func (m *CT_HierarchyUsage) Validate() error

Validate validates the CT_HierarchyUsage and its children

func (*CT_HierarchyUsage) ValidateWithPath ¶ 

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

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

type CT_Hyperlink struct {
	// Reference
	RefAttr string
	IdAttr  *string
	// Location
	LocationAttr *string
	// Tool Tip
	TooltipAttr *string
	// Display String
	DisplayAttr *string
}
func NewCT_Hyperlink() *CT_Hyperlink

func (*CT_Hyperlink) MarshalXML ¶ 

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

func (*CT_Hyperlink) UnmarshalXML ¶ 

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

func (*CT_Hyperlink) Validate ¶ 

func (m *CT_Hyperlink) Validate() error

Validate validates the CT_Hyperlink and its children

func (*CT_Hyperlink) ValidateWithPath ¶ 

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

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

type CT_Hyperlinks struct {
	// Hyperlink
	Hyperlink []*CT_Hyperlink
}
func NewCT_Hyperlinks() *CT_Hyperlinks

func (*CT_Hyperlinks) MarshalXML ¶ 

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

func (*CT_Hyperlinks) UnmarshalXML ¶ 

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

func (*CT_Hyperlinks) Validate ¶ 

func (m *CT_Hyperlinks) Validate() error

Validate validates the CT_Hyperlinks and its children

func (*CT_Hyperlinks) ValidateWithPath ¶ 

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

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

type CT_I ¶ 

type CT_I struct {
	// Item Type
	TAttr ST_ItemType
	// Repeated Items Count
	RAttr *uint32
	// Data Field Index
	IAttr *uint32
	// Row / Column Item Index
	X []*CT_X
}

func NewCT_I ¶ 

func NewCT_I() *CT_I

func (*CT_I) MarshalXML ¶ 

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

func (*CT_I) UnmarshalXML ¶ 

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

func (*CT_I) Validate ¶ 

func (m *CT_I) Validate() error

Validate validates the CT_I and its children

func (*CT_I) ValidateWithPath ¶ 

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

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

type CT_IconFilter ¶ 

type CT_IconFilter struct {
	// Icon Set
	IconSetAttr ST_IconSetType
	// Icon Id
	IconIdAttr *uint32
}

func NewCT_IconFilter ¶ 

func NewCT_IconFilter() *CT_IconFilter

func (*CT_IconFilter) MarshalXML ¶ 

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

func (*CT_IconFilter) UnmarshalXML ¶ 

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

func (*CT_IconFilter) Validate ¶ 

func (m *CT_IconFilter) Validate() error

Validate validates the CT_IconFilter and its children

func (*CT_IconFilter) ValidateWithPath ¶ 

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

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

type CT_IconSet ¶ 

type CT_IconSet struct {
	// Icon Set
	IconSetAttr ST_IconSetType
	// Show Value
	ShowValueAttr *bool
	// Percent
	PercentAttr *bool
	// Reverse Icons
	ReverseAttr *bool
	// Conditional Formatting Object
	Cfvo []*CT_Cfvo
}

func NewCT_IconSet ¶ 

func NewCT_IconSet() *CT_IconSet

func (*CT_IconSet) MarshalXML ¶ 

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

func (*CT_IconSet) UnmarshalXML ¶ 

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

func (*CT_IconSet) Validate ¶ 

func (m *CT_IconSet) Validate() error

Validate validates the CT_IconSet and its children

func (*CT_IconSet) ValidateWithPath ¶ 

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

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

type CT_IgnoredError ¶ 

type CT_IgnoredError struct {
	// Sequence of References
	SqrefAttr ST_Sqref
	// Evaluation Error
	EvalErrorAttr *bool
	// Two Digit Text Year
	TwoDigitTextYearAttr *bool
	// Number Stored As Text
	NumberStoredAsTextAttr *bool
	// Formula
	FormulaAttr *bool
	// Formula Range
	FormulaRangeAttr *bool
	// Unlocked Formula
	UnlockedFormulaAttr *bool
	// Empty Cell Reference
	EmptyCellReferenceAttr *bool
	// List Data Validation
	ListDataValidationAttr *bool
	// Calculated Column
	CalculatedColumnAttr *bool
}

func NewCT_IgnoredError ¶ 

func NewCT_IgnoredError() *CT_IgnoredError

func (*CT_IgnoredError) MarshalXML ¶ 

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

func (*CT_IgnoredError) UnmarshalXML ¶ 

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

func (*CT_IgnoredError) Validate ¶ 

func (m *CT_IgnoredError) Validate() error

Validate validates the CT_IgnoredError and its children

func (*CT_IgnoredError) ValidateWithPath ¶ 

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

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

type CT_IgnoredErrors ¶ 

type CT_IgnoredErrors struct {
	// Ignored Error
	IgnoredError []*CT_IgnoredError
	ExtLst       *CT_ExtensionList
}

func NewCT_IgnoredErrors ¶ 

func NewCT_IgnoredErrors() *CT_IgnoredErrors

func (*CT_IgnoredErrors) MarshalXML ¶ 

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

func (*CT_IgnoredErrors) UnmarshalXML ¶ 

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

func (*CT_IgnoredErrors) Validate ¶ 

func (m *CT_IgnoredErrors) Validate() error

Validate validates the CT_IgnoredErrors and its children

func (*CT_IgnoredErrors) ValidateWithPath ¶ 

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

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

type CT_Index ¶ 

type CT_Index struct {
	// Shared Items Index
	VAttr uint32
}

func NewCT_Index ¶ 

func NewCT_Index() *CT_Index

func (*CT_Index) MarshalXML ¶ 

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

func (*CT_Index) UnmarshalXML ¶ 

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

func (*CT_Index) Validate ¶ 

func (m *CT_Index) Validate() error

Validate validates the CT_Index and its children

func (*CT_Index) ValidateWithPath ¶ 

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

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

type CT_IndexedColors ¶ 

type CT_IndexedColors struct {
	// RGB Color
	RgbColor []*CT_RgbColor
}

func NewCT_IndexedColors ¶ 

func NewCT_IndexedColors() *CT_IndexedColors

func (*CT_IndexedColors) MarshalXML ¶ 

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

func (*CT_IndexedColors) UnmarshalXML ¶ 

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

func (*CT_IndexedColors) Validate ¶ 

func (m *CT_IndexedColors) Validate() error

Validate validates the CT_IndexedColors and its children

func (*CT_IndexedColors) ValidateWithPath ¶ 

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

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

type CT_InputCells ¶ 

type CT_InputCells struct {
	// Reference
	RAttr string
	// Deleted
	DeletedAttr *bool
	// Undone
	UndoneAttr *bool
	// Value
	ValAttr string
	// Number Format Id
	NumFmtIdAttr *uint32
}

func NewCT_InputCells ¶ 

func NewCT_InputCells() *CT_InputCells

func (*CT_InputCells) MarshalXML ¶ 

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

func (*CT_InputCells) UnmarshalXML ¶ 

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

func (*CT_InputCells) Validate ¶ 

func (m *CT_InputCells) Validate() error

Validate validates the CT_InputCells and its children

func (*CT_InputCells) ValidateWithPath ¶ 

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

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

type CT_IntProperty ¶ 

type CT_IntProperty struct {
	// Value
	ValAttr int32
}

func NewCT_IntProperty ¶ 

func NewCT_IntProperty() *CT_IntProperty

func (*CT_IntProperty) MarshalXML ¶ 

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

func (*CT_IntProperty) UnmarshalXML ¶ 

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

func (*CT_IntProperty) Validate ¶ 

func (m *CT_IntProperty) Validate() error

Validate validates the CT_IntProperty and its children

func (*CT_IntProperty) ValidateWithPath ¶ 

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

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

type CT_Item ¶ 

type CT_Item struct {
	// Item User Caption
	NAttr *string
	// Item Type
	TAttr ST_ItemType
	// Hidden
	HAttr *bool
	// Character
	SAttr *bool
	// Hide Details
	SdAttr *bool
	// Calculated Member
	FAttr *bool
	// Missing
	MAttr *bool
	// Child Items
	CAttr *bool
	// Item Index
	XAttr *uint32
	// Expanded
	DAttr *bool
	// Drill Across Attributes
	EAttr *bool
}

func NewCT_Item ¶ 

func NewCT_Item() *CT_Item

func (*CT_Item) MarshalXML ¶ 

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

func (*CT_Item) UnmarshalXML ¶ 

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

func (*CT_Item) Validate ¶ 

func (m *CT_Item) Validate() error

Validate validates the CT_Item and its children

func (*CT_Item) ValidateWithPath ¶ 

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

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

type CT_Items ¶ 

type CT_Items struct {
	// Field Count
	CountAttr *uint32
	// PivotTable Field Item
	Item []*CT_Item
}

func NewCT_Items ¶ 

func NewCT_Items() *CT_Items

func (*CT_Items) MarshalXML ¶ 

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

func (*CT_Items) UnmarshalXML ¶ 

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

func (*CT_Items) Validate ¶ 

func (m *CT_Items) Validate() error

Validate validates the CT_Items and its children

func (*CT_Items) ValidateWithPath ¶ 

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

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

type CT_LegacyDrawing ¶ 

type CT_LegacyDrawing struct {
	IdAttr string
}

func NewCT_LegacyDrawing ¶ 

func NewCT_LegacyDrawing() *CT_LegacyDrawing

func (*CT_LegacyDrawing) MarshalXML ¶ 

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

func (*CT_LegacyDrawing) UnmarshalXML ¶ 

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

func (*CT_LegacyDrawing) Validate ¶ 

func (m *CT_LegacyDrawing) Validate() error

Validate validates the CT_LegacyDrawing and its children

func (*CT_LegacyDrawing) ValidateWithPath ¶ 

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

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

type CT_LevelGroup ¶ 

type CT_LevelGroup struct {
	// Group Name
	NameAttr string
	// Unique Group Name
	UniqueNameAttr string
	// Group Caption
	CaptionAttr string
	// Parent Unique Name
	UniqueParentAttr *string
	// Group Id
	IdAttr *int32
	// OLAP Group Members
	GroupMembers *CT_GroupMembers
}

func NewCT_LevelGroup ¶ 

func NewCT_LevelGroup() *CT_LevelGroup

func (*CT_LevelGroup) MarshalXML ¶ 

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

func (*CT_LevelGroup) UnmarshalXML ¶ 

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

func (*CT_LevelGroup) Validate ¶ 

func (m *CT_LevelGroup) Validate() error

Validate validates the CT_LevelGroup and its children

func (*CT_LevelGroup) ValidateWithPath ¶ 

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

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

type CT_Location ¶ 

type CT_Location struct {
	// Reference
	RefAttr string
	// First Header Row
	FirstHeaderRowAttr uint32
	// PivotTable Data First Row
	FirstDataRowAttr uint32
	// First Data Column
	FirstDataColAttr uint32
	// Rows Per Page Count
	RowPageCountAttr *uint32
	// Columns Per Page
	ColPageCountAttr *uint32
}

func NewCT_Location ¶ 

func NewCT_Location() *CT_Location

func (*CT_Location) MarshalXML ¶ 

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

func (*CT_Location) UnmarshalXML ¶ 

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

func (*CT_Location) Validate ¶ 

func (m *CT_Location) Validate() error

Validate validates the CT_Location and its children

func (*CT_Location) ValidateWithPath ¶ 

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

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

type CT_MRUColors ¶ 

type CT_MRUColors struct {
	// Color
	Color []*CT_Color
}

func NewCT_MRUColors ¶ 

func NewCT_MRUColors() *CT_MRUColors

func (*CT_MRUColors) MarshalXML ¶ 

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

func (*CT_MRUColors) UnmarshalXML ¶ 

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

func (*CT_MRUColors) Validate ¶ 

func (m *CT_MRUColors) Validate() error

Validate validates the CT_MRUColors and its children

func (*CT_MRUColors) ValidateWithPath ¶ 

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

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

type CT_Macrosheet ¶ 

type CT_Macrosheet struct {
	// Sheet Properties
	SheetPr *CT_SheetPr
	// Macro Sheet Dimensions
	Dimension *CT_SheetDimension
	// Macro Sheet Views
	SheetViews *CT_SheetViews
	// Sheet Format Properties
	SheetFormatPr *CT_SheetFormatPr
	// Column Information
	Cols []*CT_Cols
	// Sheet Data
	SheetData *CT_SheetData
	// Sheet Protection Options
	SheetProtection *CT_SheetProtection
	// AutoFilter
	AutoFilter *CT_AutoFilter
	// Sort State
	SortState *CT_SortState
	// Data Consolidation
	DataConsolidate *CT_DataConsolidate
	// Custom Sheet Views
	CustomSheetViews *CT_CustomSheetViews
	// Phonetic Properties
	PhoneticPr *CT_PhoneticPr
	// Conditional Formatting
	ConditionalFormatting []*CT_ConditionalFormatting
	// Print Options
	PrintOptions *CT_PrintOptions
	// Page Margins
	PageMargins *CT_PageMargins
	// Page Setup Settings
	PageSetup *CT_PageSetup
	// Header Footer Settings
	HeaderFooter *CT_HeaderFooter
	// Horizontal Page Breaks (Row)
	RowBreaks *CT_PageBreak
	// Vertical Page Breaks
	ColBreaks *CT_PageBreak
	// Custom Properties
	CustomProperties *CT_CustomProperties
	// Drawing
	Drawing *CT_Drawing
	// Legacy Drawing Reference
	LegacyDrawing *CT_LegacyDrawing
	// Legacy Drawing Header Footer
	LegacyDrawingHF *CT_LegacyDrawing
	DrawingHF       *CT_DrawingHF
	// Background Image
	Picture *CT_SheetBackgroundPicture
	// Embedded Objects
	OleObjects *CT_OleObjects
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_Macrosheet ¶ 

func NewCT_Macrosheet() *CT_Macrosheet

func (*CT_Macrosheet) MarshalXML ¶ 

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

func (*CT_Macrosheet) UnmarshalXML ¶ 

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

func (*CT_Macrosheet) Validate ¶ 

func (m *CT_Macrosheet) Validate() error

Validate validates the CT_Macrosheet and its children

func (*CT_Macrosheet) ValidateWithPath ¶ 

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

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

type CT_Map ¶ 

type CT_Map struct {
	// XML Mapping ID
	IDAttr uint32
	// XML Mapping Name
	NameAttr string
	// Root Element Name
	RootElementAttr string
	// Schema Name
	SchemaIDAttr string
	// Show Validation Errors
	ShowImportExportValidationErrorsAttr bool
	// AutoFit Table on Refresh
	AutoFitAttr bool
	// Append Data to Table
	AppendAttr bool
	// Preserve AutoFilter State
	PreserveSortAFLayoutAttr bool
	// Preserve Cell Formatting
	PreserveFormatAttr bool
	// XML Mapping
	DataBinding *CT_DataBinding
}

func NewCT_Map ¶ 

func NewCT_Map() *CT_Map

func (*CT_Map) MarshalXML ¶ 

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

func (*CT_Map) UnmarshalXML ¶ 

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

func (*CT_Map) Validate ¶ 

func (m *CT_Map) Validate() error

Validate validates the CT_Map and its children

func (*CT_Map) ValidateWithPath ¶ 

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

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

type CT_MapInfo ¶ 

type CT_MapInfo struct {
	// Prefix Mappings for XPath Expressions
	SelectionNamespacesAttr string
	// XML Schema
	Schema []*CT_Schema
	// XML Mapping Properties
	Map []*CT_Map
}

func NewCT_MapInfo ¶ 

func NewCT_MapInfo() *CT_MapInfo

func (*CT_MapInfo) MarshalXML ¶ 

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

func (*CT_MapInfo) UnmarshalXML ¶ 

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

func (*CT_MapInfo) Validate ¶ 

func (m *CT_MapInfo) Validate() error

Validate validates the CT_MapInfo and its children

func (*CT_MapInfo) ValidateWithPath ¶ 

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

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

type CT_Mdx ¶ 

type CT_Mdx struct {
	// Connection Name Index
	NAttr uint32
	// Cube Function Tag
	FAttr ST_MdxFunctionType
	// Tuple MDX Metadata
	T *CT_MdxTuple
	// Set MDX Metadata
	Ms *CT_MdxSet
	// Member Property MDX Metadata
	P *CT_MdxMemeberProp
	// KPI MDX Metadata
	K *CT_MdxKPI
}

func NewCT_Mdx ¶ 

func NewCT_Mdx() *CT_Mdx

func (*CT_Mdx) MarshalXML ¶ 

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

func (*CT_Mdx) UnmarshalXML ¶ 

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

func (*CT_Mdx) Validate ¶ 

func (m *CT_Mdx) Validate() error

Validate validates the CT_Mdx and its children

func (*CT_Mdx) ValidateWithPath ¶ 

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

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

type CT_MdxKPI ¶ 

type CT_MdxKPI struct {
	// Member Unique Name Index
	NAttr uint32
	// KPI Index
	NpAttr uint32
	// KPI Property
	PAttr ST_MdxKPIProperty
}

func NewCT_MdxKPI ¶ 

func NewCT_MdxKPI() *CT_MdxKPI

func (*CT_MdxKPI) MarshalXML ¶ 

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

func (*CT_MdxKPI) UnmarshalXML ¶ 

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

func (*CT_MdxKPI) Validate ¶ 

func (m *CT_MdxKPI) Validate() error

Validate validates the CT_MdxKPI and its children

func (*CT_MdxKPI) ValidateWithPath ¶ 

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

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

type CT_MdxMemeberProp ¶ 

type CT_MdxMemeberProp struct {
	// Member Unique Name Index
	NAttr uint32
	// Property Name Index
	NpAttr uint32
}

func NewCT_MdxMemeberProp ¶ 

func NewCT_MdxMemeberProp() *CT_MdxMemeberProp

func (*CT_MdxMemeberProp) MarshalXML ¶ 

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

func (*CT_MdxMemeberProp) UnmarshalXML ¶ 

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

func (*CT_MdxMemeberProp) Validate ¶ 

func (m *CT_MdxMemeberProp) Validate() error

Validate validates the CT_MdxMemeberProp and its children

func (*CT_MdxMemeberProp) ValidateWithPath ¶ 

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

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

type CT_MdxMetadata ¶ 

type CT_MdxMetadata struct {
	// MDX Metadata Record Count
	CountAttr *uint32
	// MDX Metadata Record
	Mdx []*CT_Mdx
}

func NewCT_MdxMetadata ¶ 

func NewCT_MdxMetadata() *CT_MdxMetadata

func (*CT_MdxMetadata) MarshalXML ¶ 

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

func (*CT_MdxMetadata) UnmarshalXML ¶ 

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

func (*CT_MdxMetadata) Validate ¶ 

func (m *CT_MdxMetadata) Validate() error

Validate validates the CT_MdxMetadata and its children

func (*CT_MdxMetadata) ValidateWithPath ¶ 

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

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

type CT_MdxSet ¶ 

type CT_MdxSet struct {
	// Set Definition Index
	NsAttr uint32
	// Sort By Member Index Count
	CAttr *uint32
	// Set Sort Order
	OAttr ST_MdxSetOrder
	// Member Unique Name Index
	N []*CT_MetadataStringIndex
}

func NewCT_MdxSet ¶ 

func NewCT_MdxSet() *CT_MdxSet

func (*CT_MdxSet) MarshalXML ¶ 

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

func (*CT_MdxSet) UnmarshalXML ¶ 

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

func (*CT_MdxSet) Validate ¶ 

func (m *CT_MdxSet) Validate() error

Validate validates the CT_MdxSet and its children

func (*CT_MdxSet) ValidateWithPath ¶ 

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

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

type CT_MdxTuple ¶ 

type CT_MdxTuple struct {
	// Member Index Count
	CAttr *uint32
	// Server Formatting Culture Currency
	CtAttr *string
	// Server Formatting String Index
	SiAttr *uint32
	// Server Formatting Built-In Number Format Index
	FiAttr *uint32
	// Server Formatting Background Color
	BcAttr *string
	// Server Formatting Foreground Color
	FcAttr *string
	// Server Formatting Italic Font
	IAttr *bool
	// Server Formatting Underline Font
	UAttr *bool
	// Server Formatting Strikethrough Font
	StAttr *bool
	// Server Formatting Bold Font
	BAttr *bool
	// Member Unique Name Index
	N []*CT_MetadataStringIndex
}

func NewCT_MdxTuple ¶ 

func NewCT_MdxTuple() *CT_MdxTuple

func (*CT_MdxTuple) MarshalXML ¶ 

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

func (*CT_MdxTuple) UnmarshalXML ¶ 

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

func (*CT_MdxTuple) Validate ¶ 

func (m *CT_MdxTuple) Validate() error

Validate validates the CT_MdxTuple and its children

func (*CT_MdxTuple) ValidateWithPath ¶ 

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

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

type CT_MeasureDimensionMap ¶ 

type CT_MeasureDimensionMap struct {
	// Measure Group Id
	MeasureGroupAttr *uint32
	// Dimension Id
	DimensionAttr *uint32
}

func NewCT_MeasureDimensionMap ¶ 

func NewCT_MeasureDimensionMap() *CT_MeasureDimensionMap

func (*CT_MeasureDimensionMap) MarshalXML ¶ 

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

func (*CT_MeasureDimensionMap) UnmarshalXML ¶ 

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

func (*CT_MeasureDimensionMap) Validate ¶ 

func (m *CT_MeasureDimensionMap) Validate() error

Validate validates the CT_MeasureDimensionMap and its children

func (*CT_MeasureDimensionMap) ValidateWithPath ¶ 

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

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

type CT_MeasureDimensionMaps ¶ 

type CT_MeasureDimensionMaps struct {
	// Measure Group Count
	CountAttr *uint32
	// OLAP Measure Group
	Map []*CT_MeasureDimensionMap
}

func NewCT_MeasureDimensionMaps ¶ 

func NewCT_MeasureDimensionMaps() *CT_MeasureDimensionMaps

func (*CT_MeasureDimensionMaps) MarshalXML ¶ 

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

func (*CT_MeasureDimensionMaps) UnmarshalXML ¶ 

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

func (*CT_MeasureDimensionMaps) Validate ¶ 

func (m *CT_MeasureDimensionMaps) Validate() error

Validate validates the CT_MeasureDimensionMaps and its children

func (*CT_MeasureDimensionMaps) ValidateWithPath ¶ 

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

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

type CT_MeasureGroup ¶ 

type CT_MeasureGroup struct {
	// Measure Group Name
	NameAttr string
	// Measure Group Display Name
	CaptionAttr string
}

func NewCT_MeasureGroup ¶ 

func NewCT_MeasureGroup() *CT_MeasureGroup

func (*CT_MeasureGroup) MarshalXML ¶ 

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

func (*CT_MeasureGroup) UnmarshalXML ¶ 

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

func (*CT_MeasureGroup) Validate ¶ 

func (m *CT_MeasureGroup) Validate() error

Validate validates the CT_MeasureGroup and its children

func (*CT_MeasureGroup) ValidateWithPath ¶ 

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

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

type CT_MeasureGroups ¶ 

type CT_MeasureGroups struct {
	// Measure Group Count
	CountAttr *uint32
	// OLAP Measure Group
	MeasureGroup []*CT_MeasureGroup
}

func NewCT_MeasureGroups ¶ 

func NewCT_MeasureGroups() *CT_MeasureGroups

func (*CT_MeasureGroups) MarshalXML ¶ 

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

func (*CT_MeasureGroups) UnmarshalXML ¶ 

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

func (*CT_MeasureGroups) Validate ¶ 

func (m *CT_MeasureGroups) Validate() error

Validate validates the CT_MeasureGroups and its children

func (*CT_MeasureGroups) ValidateWithPath ¶ 

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

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

type CT_Member ¶ 

type CT_Member struct {
	// Hidden Item Name
	NameAttr string
}

func NewCT_Member ¶ 

func NewCT_Member() *CT_Member

func (*CT_Member) MarshalXML ¶ 

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

func (*CT_Member) UnmarshalXML ¶ 

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

func (*CT_Member) Validate ¶ 

func (m *CT_Member) Validate() error

Validate validates the CT_Member and its children

func (*CT_Member) ValidateWithPath ¶ 

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

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

type CT_MemberProperties ¶ 

type CT_MemberProperties struct {
	// OLAP Member Properties Count
	CountAttr *uint32
	// OLAP Member Property
	Mp []*CT_MemberProperty
}

func NewCT_MemberProperties ¶ 

func NewCT_MemberProperties() *CT_MemberProperties

func (*CT_MemberProperties) MarshalXML ¶ 

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

func (*CT_MemberProperties) UnmarshalXML ¶ 

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

func (*CT_MemberProperties) Validate ¶ 

func (m *CT_MemberProperties) Validate() error

Validate validates the CT_MemberProperties and its children

func (*CT_MemberProperties) ValidateWithPath ¶ 

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

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

type CT_MemberProperty ¶ 

type CT_MemberProperty struct {
	// OLAP Member Property Unique Name
	NameAttr *string
	// Show Cell
	ShowCellAttr *bool
	// Show Tooltip
	ShowTipAttr *bool
	// Show As Caption
	ShowAsCaptionAttr *bool
	// Name Length
	NameLenAttr *uint32
	// Property Name Character Index
	PPosAttr *uint32
	// Property Name Length
	PLenAttr *uint32
	// Level Index
	LevelAttr *uint32
	// Field Index
	FieldAttr uint32
}

func NewCT_MemberProperty ¶ 

func NewCT_MemberProperty() *CT_MemberProperty

func (*CT_MemberProperty) MarshalXML ¶ 

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

func (*CT_MemberProperty) UnmarshalXML ¶ 

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

func (*CT_MemberProperty) Validate ¶ 

func (m *CT_MemberProperty) Validate() error

Validate validates the CT_MemberProperty and its children

func (*CT_MemberProperty) ValidateWithPath ¶ 

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

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

type CT_Members ¶ 

type CT_Members struct {
	// Item Count
	CountAttr *uint32
	// Hierarchy Level
	LevelAttr *uint32
	// Member
	Member []*CT_Member
}

func NewCT_Members ¶ 

func NewCT_Members() *CT_Members

func (*CT_Members) MarshalXML ¶ 

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

func (*CT_Members) UnmarshalXML ¶ 

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

func (*CT_Members) Validate ¶ 

func (m *CT_Members) Validate() error

Validate validates the CT_Members and its children

func (*CT_Members) ValidateWithPath ¶ 

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

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

type CT_MergeCell ¶ 

type CT_MergeCell struct {
	// Reference
	RefAttr string
}

func NewCT_MergeCell ¶ 

func NewCT_MergeCell() *CT_MergeCell

func (*CT_MergeCell) MarshalXML ¶ 

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

func (*CT_MergeCell) UnmarshalXML ¶ 

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

func (*CT_MergeCell) Validate ¶ 

func (m *CT_MergeCell) Validate() error

Validate validates the CT_MergeCell and its children

func (*CT_MergeCell) ValidateWithPath ¶ 

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

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

type CT_MergeCells ¶ 

type CT_MergeCells struct {
	// Count
	CountAttr *uint32
	// Merged Cell
	MergeCell []*CT_MergeCell
}

func NewCT_MergeCells ¶ 

func NewCT_MergeCells() *CT_MergeCells

func (*CT_MergeCells) MarshalXML ¶ 

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

func (*CT_MergeCells) UnmarshalXML ¶ 

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

func (*CT_MergeCells) Validate ¶ 

func (m *CT_MergeCells) Validate() error

Validate validates the CT_MergeCells and its children

func (*CT_MergeCells) ValidateWithPath ¶ 

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

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

type CT_Metadata ¶ 

type CT_Metadata struct {
	// Metadata Types Collection
	MetadataTypes *CT_MetadataTypes
	// Metadata String Store
	MetadataStrings *CT_MetadataStrings
	// MDX Metadata Information
	MdxMetadata *CT_MdxMetadata
	// Future Metadata
	FutureMetadata []*CT_FutureMetadata
	// Cell Metadata
	CellMetadata *CT_MetadataBlocks
	// Value Metadata
	ValueMetadata *CT_MetadataBlocks
	// Future Feature Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_Metadata ¶ 

func NewCT_Metadata() *CT_Metadata

func (*CT_Metadata) MarshalXML ¶ 

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

func (*CT_Metadata) UnmarshalXML ¶ 

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

func (*CT_Metadata) Validate ¶ 

func (m *CT_Metadata) Validate() error

Validate validates the CT_Metadata and its children

func (*CT_Metadata) ValidateWithPath ¶ 

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

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

type CT_MetadataBlock ¶ 

type CT_MetadataBlock struct {
	// Metadata Record
	Rc []*CT_MetadataRecord
}

func NewCT_MetadataBlock ¶ 

func NewCT_MetadataBlock() *CT_MetadataBlock

func (*CT_MetadataBlock) MarshalXML ¶ 

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

func (*CT_MetadataBlock) UnmarshalXML ¶ 

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

func (*CT_MetadataBlock) Validate ¶ 

func (m *CT_MetadataBlock) Validate() error

Validate validates the CT_MetadataBlock and its children

func (*CT_MetadataBlock) ValidateWithPath ¶ 

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

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

type CT_MetadataBlocks ¶ 

type CT_MetadataBlocks struct {
	// Metadata Block Count
	CountAttr *uint32
	// Metadata Block
	Bk []*CT_MetadataBlock
}

func NewCT_MetadataBlocks ¶ 

func NewCT_MetadataBlocks() *CT_MetadataBlocks

func (*CT_MetadataBlocks) MarshalXML ¶ 

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

func (*CT_MetadataBlocks) UnmarshalXML ¶ 

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

func (*CT_MetadataBlocks) Validate ¶ 

func (m *CT_MetadataBlocks) Validate() error

Validate validates the CT_MetadataBlocks and its children

func (*CT_MetadataBlocks) ValidateWithPath ¶ 

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

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

type CT_MetadataRecord ¶ 

type CT_MetadataRecord struct {
	// Metadata Record Type Index
	TAttr uint32
	// Metadata Record Value Index
	VAttr uint32
}

func NewCT_MetadataRecord ¶ 

func NewCT_MetadataRecord() *CT_MetadataRecord

func (*CT_MetadataRecord) MarshalXML ¶ 

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

func (*CT_MetadataRecord) UnmarshalXML ¶ 

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

func (*CT_MetadataRecord) Validate ¶ 

func (m *CT_MetadataRecord) Validate() error

Validate validates the CT_MetadataRecord and its children

func (*CT_MetadataRecord) ValidateWithPath ¶ 

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

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

type CT_MetadataStringIndex ¶ 

type CT_MetadataStringIndex struct {
	// Index Value
	XAttr uint32
	// String is a Set
	SAttr *bool
}

func NewCT_MetadataStringIndex ¶ 

func NewCT_MetadataStringIndex() *CT_MetadataStringIndex

func (*CT_MetadataStringIndex) MarshalXML ¶ 

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

func (*CT_MetadataStringIndex) UnmarshalXML ¶ 

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

func (*CT_MetadataStringIndex) Validate ¶ 

func (m *CT_MetadataStringIndex) Validate() error

Validate validates the CT_MetadataStringIndex and its children

func (*CT_MetadataStringIndex) ValidateWithPath ¶ 

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

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

type CT_MetadataStrings ¶ 

type CT_MetadataStrings struct {
	// MDX Metadata String Count
	CountAttr *uint32
	// MDX Metadata String
	S []*CT_XStringElement
}

func NewCT_MetadataStrings ¶ 

func NewCT_MetadataStrings() *CT_MetadataStrings

func (*CT_MetadataStrings) MarshalXML ¶ 

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

func (*CT_MetadataStrings) UnmarshalXML ¶ 

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

func (*CT_MetadataStrings) Validate ¶ 

func (m *CT_MetadataStrings) Validate() error

Validate validates the CT_MetadataStrings and its children

func (*CT_MetadataStrings) ValidateWithPath ¶ 

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

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

type CT_MetadataType ¶ 

type CT_MetadataType struct {
	// Metadata Type Name
	NameAttr string
	// Minimum Supported Version
	MinSupportedVersionAttr uint32
	// Metadata Ghost Row
	GhostRowAttr *bool
	// Metadata Ghost Column
	GhostColAttr *bool
	// Metadata Edit
	EditAttr *bool
	// Metadata Cell Value Delete
	DeleteAttr *bool
	// Metadata Copy
	CopyAttr *bool
	// Metadata Paste All
	PasteAllAttr *bool
	// Metadata Paste Formulas
	PasteFormulasAttr *bool
	// Metadata Paste Special Values
	PasteValuesAttr *bool
	// Metadata Paste Formats
	PasteFormatsAttr *bool
	// Metadata Paste Comments
	PasteCommentsAttr *bool
	// Metadata Paste Data Validation
	PasteDataValidationAttr *bool
	// Metadata Paste Borders
	PasteBordersAttr *bool
	// Metadata Paste Column Widths
	PasteColWidthsAttr *bool
	// Metadata Paste Number Formats
	PasteNumberFormatsAttr *bool
	// Metadata Merge
	MergeAttr *bool
	// Meatadata Split First
	SplitFirstAttr *bool
	// Metadata Split All
	SplitAllAttr *bool
	// Metadata Insert Delete
	RowColShiftAttr *bool
	// Metadata Clear All
	ClearAllAttr *bool
	// Metadata Clear Formats
	ClearFormatsAttr *bool
	// Metadata Clear Contents
	ClearContentsAttr *bool
	// Metadata Clear Comments
	ClearCommentsAttr *bool
	// Metadata Formula Assignment
	AssignAttr *bool
	// Metadata Coercion
	CoerceAttr *bool
	// Adjust Metadata
	AdjustAttr *bool
	// Cell Metadata
	CellMetaAttr *bool
}

func NewCT_MetadataType ¶ 

func NewCT_MetadataType() *CT_MetadataType

func (*CT_MetadataType) MarshalXML ¶ 

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

func (*CT_MetadataType) UnmarshalXML ¶ 

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

func (*CT_MetadataType) Validate ¶ 

func (m *CT_MetadataType) Validate() error

Validate validates the CT_MetadataType and its children

func (*CT_MetadataType) ValidateWithPath ¶ 

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

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

type CT_MetadataTypes ¶ 

type CT_MetadataTypes struct {
	// Metadata Type Count
	CountAttr *uint32
	// Metadata Type Information
	MetadataType []*CT_MetadataType
}

func NewCT_MetadataTypes ¶ 

func NewCT_MetadataTypes() *CT_MetadataTypes

func (*CT_MetadataTypes) MarshalXML ¶ 

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

func (*CT_MetadataTypes) UnmarshalXML ¶ 

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

func (*CT_MetadataTypes) Validate ¶ 

func (m *CT_MetadataTypes) Validate() error

Validate validates the CT_MetadataTypes and its children

func (*CT_MetadataTypes) ValidateWithPath ¶ 

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

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

type CT_Missing ¶ 

type CT_Missing struct {
	// Unused Item
	UAttr *bool
	// Calculated Item
	FAttr *bool
	// Caption
	CAttr *string
	// Member Property Count
	CpAttr *uint32
	// Format Index
	InAttr *uint32
	// background Color
	BcAttr *string
	// Foreground Color
	FcAttr *string
	// Italic
	IAttr *bool
	// Underline
	UnAttr *bool
	// Strikethrough
	StAttr *bool
	// Bold
	BAttr *bool
	// Tuples
	Tpls []*CT_Tuples
	// Member Property Indexes
	X []*CT_X
}

func NewCT_Missing ¶ 

func NewCT_Missing() *CT_Missing

func (*CT_Missing) MarshalXML ¶ 

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

func (*CT_Missing) UnmarshalXML ¶ 

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

func (*CT_Missing) Validate ¶ 

func (m *CT_Missing) Validate() error

Validate validates the CT_Missing and its children

func (*CT_Missing) ValidateWithPath ¶ 

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

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

type CT_NumFmt ¶ 

type CT_NumFmt struct {
	// Number Format Id
	NumFmtIdAttr uint32
	// Number Format Code
	FormatCodeAttr string
}

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_NumFmts ¶ 

type CT_NumFmts struct {
	// Number Format Count
	CountAttr *uint32
	// Number Formats
	NumFmt []*CT_NumFmt
}

func NewCT_NumFmts ¶ 

func NewCT_NumFmts() *CT_NumFmts

func (*CT_NumFmts) MarshalXML ¶ 

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

func (*CT_NumFmts) UnmarshalXML ¶ 

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

func (*CT_NumFmts) Validate ¶ 

func (m *CT_NumFmts) Validate() error

Validate validates the CT_NumFmts and its children

func (*CT_NumFmts) ValidateWithPath ¶ 

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

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

type CT_Number ¶ 

type CT_Number struct {
	// Value
	VAttr float64
	// Unused Item
	UAttr *bool
	// Calculated Item
	FAttr *bool
	// Caption
	CAttr *string
	// Member Property Count
	CpAttr *uint32
	// Format Index
	InAttr *uint32
	// Background Color
	BcAttr *string
	// Foreground Color
	FcAttr *string
	// Italic
	IAttr *bool
	// Underline
	UnAttr *bool
	// Strikethrough
	StAttr *bool
	// Bold
	BAttr *bool
	// OLAP Members
	Tpls []*CT_Tuples
	// Member Property Index
	X []*CT_X
}

func NewCT_Number ¶ 

func NewCT_Number() *CT_Number

func (*CT_Number) MarshalXML ¶ 

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

func (*CT_Number) UnmarshalXML ¶ 

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

func (*CT_Number) Validate ¶ 

func (m *CT_Number) Validate() error

Validate validates the CT_Number and its children

func (*CT_Number) ValidateWithPath ¶ 

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

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

type CT_ObjectAnchor ¶ 

type CT_ObjectAnchor struct {
	// Move With Cells
	MoveWithCellsAttr *bool
	// Size With Cells
	SizeWithCellsAttr *bool
	From              *spreadsheetDrawing.From
	To                *spreadsheetDrawing.To
}

func NewCT_ObjectAnchor ¶ 

func NewCT_ObjectAnchor() *CT_ObjectAnchor

func (*CT_ObjectAnchor) MarshalXML ¶ 

func (m *CT_ObjectAnchor) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_ObjectAnchor) UnmarshalXML ¶ 

func (m *CT_ObjectAnchor) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_ObjectAnchor) Validate ¶ 

func (m *CT_ObjectAnchor) Validate() error

Validate validates the CT_ObjectAnchor and its children

func (*CT_ObjectAnchor) ValidateWithPath ¶ 

func (m *CT_ObjectAnchor) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ObjectAnchor and its children, prefixing error messages with path

type CT_ObjectPr ¶ 

type CT_ObjectPr struct {
	// Locked Flag
	LockedAttr *bool
	// Default Size Flag
	DefaultSizeAttr *bool
	// Print Flag
	PrintAttr *bool
	// Disabled Flag
	DisabledAttr *bool
	// UI Object Flag
	UiObjectAttr *bool
	// Automatic Fill Flag
	AutoFillAttr *bool
	// Automatic Line Flag
	AutoLineAttr *bool
	// Automatic Size Flag
	AutoPictAttr *bool
	// Custom Function
	MacroAttr *string
	// Alternative Text
	AltTextAttr *string
	// Dynamic Data Exchange Flag
	DdeAttr *bool
	IdAttr  *string
	Anchor  *CT_ObjectAnchor
}

func NewCT_ObjectPr ¶ 

func NewCT_ObjectPr() *CT_ObjectPr

func (*CT_ObjectPr) MarshalXML ¶ 

func (m *CT_ObjectPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_ObjectPr) UnmarshalXML ¶ 

func (m *CT_ObjectPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_ObjectPr) Validate ¶ 

func (m *CT_ObjectPr) Validate() error

Validate validates the CT_ObjectPr and its children

func (*CT_ObjectPr) ValidateWithPath ¶ 

func (m *CT_ObjectPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ObjectPr and its children, prefixing error messages with path

type CT_OlapPr ¶ 

type CT_OlapPr struct {
	// Local Cube
	LocalAttr *bool
	// Local Cube Connection
	LocalConnectionAttr *string
	// Local Refresh
	LocalRefreshAttr *bool
	// Send Locale to OLAP
	SendLocaleAttr *bool
	// Drill Through Count
	RowDrillCountAttr *uint32
	// OLAP Fill Formatting
	ServerFillAttr *bool
	// OLAP Number Format
	ServerNumberFormatAttr *bool
	// OLAP Server Font
	ServerFontAttr *bool
	// OLAP Font Formatting
	ServerFontColorAttr *bool
}

func NewCT_OlapPr ¶ 

func NewCT_OlapPr() *CT_OlapPr

func (*CT_OlapPr) MarshalXML ¶ 

func (m *CT_OlapPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_OlapPr) UnmarshalXML ¶ 

func (m *CT_OlapPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_OlapPr) Validate ¶ 

func (m *CT_OlapPr) Validate() error

Validate validates the CT_OlapPr and its children

func (*CT_OlapPr) ValidateWithPath ¶ 

func (m *CT_OlapPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_OlapPr and its children, prefixing error messages with path

type CT_OleItem ¶ 

type CT_OleItem struct {
	// Object Name
	NameAttr string
	// Icon
	IconAttr *bool
	// Advise
	AdviseAttr *bool
	// Object is an Image
	PreferPicAttr *bool
}

func NewCT_OleItem ¶ 

func NewCT_OleItem() *CT_OleItem

func (*CT_OleItem) MarshalXML ¶ 

func (m *CT_OleItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_OleItem) UnmarshalXML ¶ 

func (m *CT_OleItem) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_OleItem) Validate ¶ 

func (m *CT_OleItem) Validate() error

Validate validates the CT_OleItem and its children

func (*CT_OleItem) ValidateWithPath ¶ 

func (m *CT_OleItem) ValidateWithPath(path string) error

ValidateWithPath validates the CT_OleItem and its children, prefixing error messages with path

type CT_OleItems ¶ 

type CT_OleItems struct {
	// Object Link Item
	OleItem []*CT_OleItem
}

func NewCT_OleItems ¶ 

func NewCT_OleItems() *CT_OleItems

func (*CT_OleItems) MarshalXML ¶ 

func (m *CT_OleItems) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_OleItems) UnmarshalXML ¶ 

func (m *CT_OleItems) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_OleItems) Validate ¶ 

func (m *CT_OleItems) Validate() error

Validate validates the CT_OleItems and its children

func (*CT_OleItems) ValidateWithPath ¶ 

func (m *CT_OleItems) ValidateWithPath(path string) error

ValidateWithPath validates the CT_OleItems and its children, prefixing error messages with path 

type CT_OleLink struct {
	IdAttr string
	// Object Link Identifier
	ProgIdAttr string
	// Object Link Items
	OleItems *CT_OleItems
}
func NewCT_OleLink() *CT_OleLink

func (*CT_OleLink) MarshalXML ¶ 

func (m *CT_OleLink) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_OleLink) UnmarshalXML ¶ 

func (m *CT_OleLink) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_OleLink) Validate ¶ 

func (m *CT_OleLink) Validate() error

Validate validates the CT_OleLink and its children

func (*CT_OleLink) ValidateWithPath ¶ 

func (m *CT_OleLink) ValidateWithPath(path string) error

ValidateWithPath validates the CT_OleLink and its children, prefixing error messages with path

type CT_OleObject ¶ 

type CT_OleObject struct {
	// Embedded Object ProgId
	ProgIdAttr *string
	// Data or View Aspect
	DvAspectAttr ST_DvAspect
	// Embedded Object's Link Moniker
	LinkAttr *string
	// Linked Embedded Object Update
	OleUpdateAttr ST_OleUpdate
	// Auto Load
	AutoLoadAttr *bool
	// Shape Id
	ShapeIdAttr uint32
	IdAttr      *string
	// Embedded Object Properties
	ObjectPr *CT_ObjectPr
}

func NewCT_OleObject ¶ 

func NewCT_OleObject() *CT_OleObject

func (*CT_OleObject) MarshalXML ¶ 

func (m *CT_OleObject) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_OleObject) UnmarshalXML ¶ 

func (m *CT_OleObject) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_OleObject) Validate ¶ 

func (m *CT_OleObject) Validate() error

Validate validates the CT_OleObject and its children

func (*CT_OleObject) ValidateWithPath ¶ 

func (m *CT_OleObject) ValidateWithPath(path string) error

ValidateWithPath validates the CT_OleObject and its children, prefixing error messages with path

type CT_OleObjects ¶ 

type CT_OleObjects struct {
	// Embedded Object
	OleObject []*CT_OleObject
}

func NewCT_OleObjects ¶ 

func NewCT_OleObjects() *CT_OleObjects

func (*CT_OleObjects) MarshalXML ¶ 

func (m *CT_OleObjects) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_OleObjects) UnmarshalXML ¶ 

func (m *CT_OleObjects) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_OleObjects) Validate ¶ 

func (m *CT_OleObjects) Validate() error

Validate validates the CT_OleObjects and its children

func (*CT_OleObjects) ValidateWithPath ¶ 

func (m *CT_OleObjects) ValidateWithPath(path string) error

ValidateWithPath validates the CT_OleObjects and its children, prefixing error messages with path

type CT_OleSize ¶ 

type CT_OleSize struct {
	// Reference
	RefAttr string
}

func NewCT_OleSize ¶ 

func NewCT_OleSize() *CT_OleSize

func (*CT_OleSize) MarshalXML ¶ 

func (m *CT_OleSize) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_OleSize) UnmarshalXML ¶ 

func (m *CT_OleSize) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_OleSize) Validate ¶ 

func (m *CT_OleSize) Validate() error

Validate validates the CT_OleSize and its children

func (*CT_OleSize) ValidateWithPath ¶ 

func (m *CT_OleSize) ValidateWithPath(path string) error

ValidateWithPath validates the CT_OleSize and its children, prefixing error messages with path

type CT_OutlinePr ¶ 

type CT_OutlinePr struct {
	// Apply Styles in Outline
	ApplyStylesAttr *bool
	// Summary Below
	SummaryBelowAttr *bool
	// Summary Right
	SummaryRightAttr *bool
	// Show Outline Symbols
	ShowOutlineSymbolsAttr *bool
}

func NewCT_OutlinePr ¶ 

func NewCT_OutlinePr() *CT_OutlinePr

func (*CT_OutlinePr) MarshalXML ¶ 

func (m *CT_OutlinePr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_OutlinePr) UnmarshalXML ¶ 

func (m *CT_OutlinePr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_OutlinePr) Validate ¶ 

func (m *CT_OutlinePr) Validate() error

Validate validates the CT_OutlinePr and its children

func (*CT_OutlinePr) ValidateWithPath ¶ 

func (m *CT_OutlinePr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_OutlinePr and its children, prefixing error messages with path

type CT_PCDKPI ¶ 

type CT_PCDKPI struct {
	// KPI Unique Name
	UniqueNameAttr string
	// KPI Display Name
	CaptionAttr *string
	// KPI Display Folder
	DisplayFolderAttr *string
	// KPI Measure Group Name
	MeasureGroupAttr *string
	// Parent KPI
	ParentAttr *string
	// KPI Value Unique Name
	ValueAttr string
	// KPI Goal Unique Name
	GoalAttr *string
	// KPI Status Unique Name
	StatusAttr *string
	// KPI Trend Unique Name
	TrendAttr *string
	// KPI Weight Unique Name
	WeightAttr *string
	// Time Member KPI Unique Name
	TimeAttr *string
}

func NewCT_PCDKPI ¶ 

func NewCT_PCDKPI() *CT_PCDKPI

func (*CT_PCDKPI) MarshalXML ¶ 

func (m *CT_PCDKPI) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PCDKPI) UnmarshalXML ¶ 

func (m *CT_PCDKPI) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PCDKPI) Validate ¶ 

func (m *CT_PCDKPI) Validate() error

Validate validates the CT_PCDKPI and its children

func (*CT_PCDKPI) ValidateWithPath ¶ 

func (m *CT_PCDKPI) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PCDKPI and its children, prefixing error messages with path

type CT_PCDKPIs ¶ 

type CT_PCDKPIs struct {
	// KPI Count
	CountAttr *uint32
	// OLAP KPI
	Kpi []*CT_PCDKPI
}

func NewCT_PCDKPIs ¶ 

func NewCT_PCDKPIs() *CT_PCDKPIs

func (*CT_PCDKPIs) MarshalXML ¶ 

func (m *CT_PCDKPIs) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PCDKPIs) UnmarshalXML ¶ 

func (m *CT_PCDKPIs) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PCDKPIs) Validate ¶ 

func (m *CT_PCDKPIs) Validate() error

Validate validates the CT_PCDKPIs and its children

func (*CT_PCDKPIs) ValidateWithPath ¶ 

func (m *CT_PCDKPIs) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PCDKPIs and its children, prefixing error messages with path

type CT_PCDSCPage ¶ 

type CT_PCDSCPage struct {
	// Page Item String Count
	CountAttr *uint32
	// Page Item
	PageItem []*CT_PageItem
}

func NewCT_PCDSCPage ¶ 

func NewCT_PCDSCPage() *CT_PCDSCPage

func (*CT_PCDSCPage) MarshalXML ¶ 

func (m *CT_PCDSCPage) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PCDSCPage) UnmarshalXML ¶ 

func (m *CT_PCDSCPage) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PCDSCPage) Validate ¶ 

func (m *CT_PCDSCPage) Validate() error

Validate validates the CT_PCDSCPage and its children

func (*CT_PCDSCPage) ValidateWithPath ¶ 

func (m *CT_PCDSCPage) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PCDSCPage and its children, prefixing error messages with path

type CT_PCDSDTCEntries ¶ 

type CT_PCDSDTCEntries struct {
	// Tuple Count
	CountAttr *uint32
	// No Value
	M []*CT_Missing
	// Numeric Value
	N []*CT_Number
	// Error Value
	E []*CT_Error
	// Character Value
	S []*CT_String
}

func NewCT_PCDSDTCEntries ¶ 

func NewCT_PCDSDTCEntries() *CT_PCDSDTCEntries

func (*CT_PCDSDTCEntries) MarshalXML ¶ 

func (m *CT_PCDSDTCEntries) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PCDSDTCEntries) UnmarshalXML ¶ 

func (m *CT_PCDSDTCEntries) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PCDSDTCEntries) Validate ¶ 

func (m *CT_PCDSDTCEntries) Validate() error

Validate validates the CT_PCDSDTCEntries and its children

func (*CT_PCDSDTCEntries) ValidateWithPath ¶ 

func (m *CT_PCDSDTCEntries) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PCDSDTCEntries and its children, prefixing error messages with path

type CT_PageBreak ¶ 

type CT_PageBreak struct {
	// Page Break Count
	CountAttr *uint32
	// Manual Break Count
	ManualBreakCountAttr *uint32
	// Break
	Brk []*CT_Break
}

func NewCT_PageBreak ¶ 

func NewCT_PageBreak() *CT_PageBreak

func (*CT_PageBreak) MarshalXML ¶ 

func (m *CT_PageBreak) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PageBreak) UnmarshalXML ¶ 

func (m *CT_PageBreak) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PageBreak) Validate ¶ 

func (m *CT_PageBreak) Validate() error

Validate validates the CT_PageBreak and its children

func (*CT_PageBreak) ValidateWithPath ¶ 

func (m *CT_PageBreak) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PageBreak and its children, prefixing error messages with path

type CT_PageField ¶ 

type CT_PageField struct {
	// Field
	FldAttr int32
	// Item Index
	ItemAttr *uint32
	// OLAP Hierarchy Index
	HierAttr *int32
	// Hierarchy Unique Name
	NameAttr *string
	// Hierarchy Display Name
	CapAttr *string
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_PageField ¶ 

func NewCT_PageField() *CT_PageField

func (*CT_PageField) MarshalXML ¶ 

func (m *CT_PageField) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PageField) UnmarshalXML ¶ 

func (m *CT_PageField) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PageField) Validate ¶ 

func (m *CT_PageField) Validate() error

Validate validates the CT_PageField and its children

func (*CT_PageField) ValidateWithPath ¶ 

func (m *CT_PageField) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PageField and its children, prefixing error messages with path

type CT_PageFields ¶ 

type CT_PageFields struct {
	// Page Item Count
	CountAttr *uint32
	// Page Field
	PageField []*CT_PageField
}

func NewCT_PageFields ¶ 

func NewCT_PageFields() *CT_PageFields

func (*CT_PageFields) MarshalXML ¶ 

func (m *CT_PageFields) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PageFields) UnmarshalXML ¶ 

func (m *CT_PageFields) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PageFields) Validate ¶ 

func (m *CT_PageFields) Validate() error

Validate validates the CT_PageFields and its children

func (*CT_PageFields) ValidateWithPath ¶ 

func (m *CT_PageFields) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PageFields and its children, prefixing error messages with path

type CT_PageItem ¶ 

type CT_PageItem struct {
	// Page Item Name
	NameAttr string
}

func NewCT_PageItem ¶ 

func NewCT_PageItem() *CT_PageItem

func (*CT_PageItem) MarshalXML ¶ 

func (m *CT_PageItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PageItem) UnmarshalXML ¶ 

func (m *CT_PageItem) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PageItem) Validate ¶ 

func (m *CT_PageItem) Validate() error

Validate validates the CT_PageItem and its children

func (*CT_PageItem) ValidateWithPath ¶ 

func (m *CT_PageItem) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PageItem and its children, prefixing error messages with path

type CT_PageMargins ¶ 

type CT_PageMargins struct {
	// Left Page Margin
	LeftAttr float64
	// Right Page Margin
	RightAttr float64
	// Top Page Margin
	TopAttr float64
	// Bottom Page Margin
	BottomAttr float64
	// Header Page Margin
	HeaderAttr float64
	// Footer Page Margin
	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_PageSetUpPr ¶ 

type CT_PageSetUpPr struct {
	// Show Auto Page Breaks
	AutoPageBreaksAttr *bool
	// Fit To Page
	FitToPageAttr *bool
}

func NewCT_PageSetUpPr ¶ 

func NewCT_PageSetUpPr() *CT_PageSetUpPr

func (*CT_PageSetUpPr) MarshalXML ¶ 

func (m *CT_PageSetUpPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PageSetUpPr) UnmarshalXML ¶ 

func (m *CT_PageSetUpPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PageSetUpPr) Validate ¶ 

func (m *CT_PageSetUpPr) Validate() error

Validate validates the CT_PageSetUpPr and its children

func (*CT_PageSetUpPr) ValidateWithPath ¶ 

func (m *CT_PageSetUpPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PageSetUpPr and its children, prefixing error messages with path

type CT_PageSetup ¶ 

type CT_PageSetup struct {
	// Paper Size
	PaperSizeAttr *uint32
	// Paper Height
	PaperHeightAttr *string
	// Paper Width
	PaperWidthAttr *string
	// Print Scale
	ScaleAttr *uint32
	// First Page Number
	FirstPageNumberAttr *uint32
	// Fit To Width
	FitToWidthAttr *uint32
	// Fit To Height
	FitToHeightAttr *uint32
	// Page Order
	PageOrderAttr ST_PageOrder
	// Orientation
	OrientationAttr ST_Orientation
	// Use Printer Defaults
	UsePrinterDefaultsAttr *bool
	// Black And White
	BlackAndWhiteAttr *bool
	// Draft
	DraftAttr *bool
	// Print Cell Comments
	CellCommentsAttr ST_CellComments
	// Use First Page Number
	UseFirstPageNumberAttr *bool
	// Print Error Handling
	ErrorsAttr ST_PrintError
	// Horizontal DPI
	HorizontalDpiAttr *uint32
	// Vertical DPI
	VerticalDpiAttr *uint32
	// Number Of Copies
	CopiesAttr *uint32
	IdAttr     *string
}

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_Pages ¶ 

type CT_Pages struct {
	// Page Item String Count
	CountAttr *uint32
	// Page Items
	Page []*CT_PCDSCPage
}

func NewCT_Pages ¶ 

func NewCT_Pages() *CT_Pages

func (*CT_Pages) MarshalXML ¶ 

func (m *CT_Pages) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Pages) UnmarshalXML ¶ 

func (m *CT_Pages) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Pages) Validate ¶ 

func (m *CT_Pages) Validate() error

Validate validates the CT_Pages and its children

func (*CT_Pages) ValidateWithPath ¶ 

func (m *CT_Pages) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Pages and its children, prefixing error messages with path

type CT_Pane ¶ 

type CT_Pane struct {
	// Horizontal Split Position
	XSplitAttr *float64
	// Vertical Split Position
	YSplitAttr *float64
	// Top Left Visible Cell
	TopLeftCellAttr *string
	// Active Pane
	ActivePaneAttr ST_Pane
	// Split State
	StateAttr ST_PaneState
}

func NewCT_Pane ¶ 

func NewCT_Pane() *CT_Pane

func (*CT_Pane) MarshalXML ¶ 

func (m *CT_Pane) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Pane) UnmarshalXML ¶ 

func (m *CT_Pane) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Pane) Validate ¶ 

func (m *CT_Pane) Validate() error

Validate validates the CT_Pane and its children

func (*CT_Pane) ValidateWithPath ¶ 

func (m *CT_Pane) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Pane and its children, prefixing error messages with path

type CT_Parameter ¶ 

type CT_Parameter struct {
	// Parameter Name
	NameAttr *string
	// SQL Data Type
	SqlTypeAttr *int32
	// Parameter Type
	ParameterTypeAttr ST_ParameterType
	// Refresh on Change
	RefreshOnChangeAttr *bool
	// Parameter Prompt String
	PromptAttr *string
	// Boolean
	BooleanAttr *bool
	// Double
	DoubleAttr *float64
	// Integer
	IntegerAttr *int32
	// String
	StringAttr *string
	// Cell Reference
	CellAttr *string
}

func NewCT_Parameter ¶ 

func NewCT_Parameter() *CT_Parameter

func (*CT_Parameter) MarshalXML ¶ 

func (m *CT_Parameter) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Parameter) UnmarshalXML ¶ 

func (m *CT_Parameter) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Parameter) Validate ¶ 

func (m *CT_Parameter) Validate() error

Validate validates the CT_Parameter and its children

func (*CT_Parameter) ValidateWithPath ¶ 

func (m *CT_Parameter) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Parameter and its children, prefixing error messages with path

type CT_Parameters ¶ 

type CT_Parameters struct {
	// Parameter Count
	CountAttr *uint32
	// Parameter Properties
	Parameter []*CT_Parameter
}

func NewCT_Parameters ¶ 

func NewCT_Parameters() *CT_Parameters

func (*CT_Parameters) MarshalXML ¶ 

func (m *CT_Parameters) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Parameters) UnmarshalXML ¶ 

func (m *CT_Parameters) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Parameters) Validate ¶ 

func (m *CT_Parameters) Validate() error

Validate validates the CT_Parameters and its children

func (*CT_Parameters) ValidateWithPath ¶ 

func (m *CT_Parameters) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Parameters and its children, prefixing error messages with path

type CT_PatternFill ¶ 

type CT_PatternFill struct {
	// Pattern Type
	PatternTypeAttr ST_PatternType
	// Foreground Color
	FgColor *CT_Color
	// Background Color
	BgColor *CT_Color
}

func NewCT_PatternFill ¶ 

func NewCT_PatternFill() *CT_PatternFill

func (*CT_PatternFill) MarshalXML ¶ 

func (m *CT_PatternFill) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PatternFill) UnmarshalXML ¶ 

func (m *CT_PatternFill) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PatternFill) Validate ¶ 

func (m *CT_PatternFill) Validate() error

Validate validates the CT_PatternFill and its children

func (*CT_PatternFill) ValidateWithPath ¶ 

func (m *CT_PatternFill) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PatternFill and its children, prefixing error messages with path

type CT_PhoneticPr ¶ 

type CT_PhoneticPr struct {
	// Font Id
	FontIdAttr uint32
	// Character Type
	TypeAttr ST_PhoneticType
	// Alignment
	AlignmentAttr ST_PhoneticAlignment
}

func NewCT_PhoneticPr ¶ 

func NewCT_PhoneticPr() *CT_PhoneticPr

func (*CT_PhoneticPr) MarshalXML ¶ 

func (m *CT_PhoneticPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PhoneticPr) UnmarshalXML ¶ 

func (m *CT_PhoneticPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PhoneticPr) Validate ¶ 

func (m *CT_PhoneticPr) Validate() error

Validate validates the CT_PhoneticPr and its children

func (*CT_PhoneticPr) ValidateWithPath ¶ 

func (m *CT_PhoneticPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PhoneticPr and its children, prefixing error messages with path

type CT_PhoneticRun ¶ 

type CT_PhoneticRun struct {
	// Base Text Start Index
	SbAttr uint32
	// Base Text End Index
	EbAttr uint32
	// Text
	T string
}

func NewCT_PhoneticRun ¶ 

func NewCT_PhoneticRun() *CT_PhoneticRun

func (*CT_PhoneticRun) MarshalXML ¶ 

func (m *CT_PhoneticRun) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PhoneticRun) UnmarshalXML ¶ 

func (m *CT_PhoneticRun) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PhoneticRun) Validate ¶ 

func (m *CT_PhoneticRun) Validate() error

Validate validates the CT_PhoneticRun and its children

func (*CT_PhoneticRun) ValidateWithPath ¶ 

func (m *CT_PhoneticRun) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PhoneticRun and its children, prefixing error messages with path

type CT_PivotArea ¶ 

type CT_PivotArea struct {
	// Field Index
	FieldAttr *int32
	// Rule Type
	TypeAttr ST_PivotAreaType
	// Data Only
	DataOnlyAttr *bool
	// Labels Only
	LabelOnlyAttr *bool
	// Include Row Grand Total
	GrandRowAttr *bool
	// Include Column Grand Total
	GrandColAttr *bool
	// Cache Index
	CacheIndexAttr *bool
	// Outline
	OutlineAttr *bool
	// Offset Reference
	OffsetAttr *string
	// Collapsed Levels Are Subtotals
	CollapsedLevelsAreSubtotalsAttr *bool
	// Axis
	AxisAttr ST_Axis
	// Field Position
	FieldPositionAttr *uint32
	// References
	References *CT_PivotAreaReferences
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_PivotArea ¶ 

func NewCT_PivotArea() *CT_PivotArea

func (*CT_PivotArea) MarshalXML ¶ 

func (m *CT_PivotArea) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PivotArea) UnmarshalXML ¶ 

func (m *CT_PivotArea) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PivotArea) Validate ¶ 

func (m *CT_PivotArea) Validate() error

Validate validates the CT_PivotArea and its children

func (*CT_PivotArea) ValidateWithPath ¶ 

func (m *CT_PivotArea) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotArea and its children, prefixing error messages with path

type CT_PivotAreaReference ¶ 

type CT_PivotAreaReference struct {
	// Field Index
	FieldAttr *uint32
	// Item Index Count
	CountAttr *uint32
	// Selected
	SelectedAttr *bool
	// Positional Reference
	ByPositionAttr *bool
	// Relative Reference
	RelativeAttr *bool
	// Include Default Filter
	DefaultSubtotalAttr *bool
	// Include Sum Filter
	SumSubtotalAttr *bool
	// Include CountA Filter
	CountASubtotalAttr *bool
	// Include Average Filter
	AvgSubtotalAttr *bool
	// Include Maximum Filter
	MaxSubtotalAttr *bool
	// Include Minimum Filter
	MinSubtotalAttr *bool
	// Include Product Filter
	ProductSubtotalAttr *bool
	// Include Count Subtotal
	CountSubtotalAttr *bool
	// Include StdDev Filter
	StdDevSubtotalAttr *bool
	// Include StdDevP Filter
	StdDevPSubtotalAttr *bool
	// Include Var Filter
	VarSubtotalAttr *bool
	// Include VarP Filter
	VarPSubtotalAttr *bool
	// Field Item
	X      []*CT_Index
	ExtLst *CT_ExtensionList
}

func NewCT_PivotAreaReference ¶ 

func NewCT_PivotAreaReference() *CT_PivotAreaReference

func (*CT_PivotAreaReference) MarshalXML ¶ 

func (m *CT_PivotAreaReference) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PivotAreaReference) UnmarshalXML ¶ 

func (m *CT_PivotAreaReference) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PivotAreaReference) Validate ¶ 

func (m *CT_PivotAreaReference) Validate() error

Validate validates the CT_PivotAreaReference and its children

func (*CT_PivotAreaReference) ValidateWithPath ¶ 

func (m *CT_PivotAreaReference) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotAreaReference and its children, prefixing error messages with path

type CT_PivotAreaReferences ¶ 

type CT_PivotAreaReferences struct {
	// Pivot Filter Count
	CountAttr *uint32
	// Reference
	Reference []*CT_PivotAreaReference
}

func NewCT_PivotAreaReferences ¶ 

func NewCT_PivotAreaReferences() *CT_PivotAreaReferences

func (*CT_PivotAreaReferences) MarshalXML ¶ 

func (m *CT_PivotAreaReferences) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PivotAreaReferences) UnmarshalXML ¶ 

func (m *CT_PivotAreaReferences) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PivotAreaReferences) Validate ¶ 

func (m *CT_PivotAreaReferences) Validate() error

Validate validates the CT_PivotAreaReferences and its children

func (*CT_PivotAreaReferences) ValidateWithPath ¶ 

func (m *CT_PivotAreaReferences) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotAreaReferences and its children, prefixing error messages with path

type CT_PivotAreas ¶ 

type CT_PivotAreas struct {
	// Pivot Area Count
	CountAttr *uint32
	// Pivot Area
	PivotArea []*CT_PivotArea
}

func NewCT_PivotAreas ¶ 

func NewCT_PivotAreas() *CT_PivotAreas

func (*CT_PivotAreas) MarshalXML ¶ 

func (m *CT_PivotAreas) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PivotAreas) UnmarshalXML ¶ 

func (m *CT_PivotAreas) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PivotAreas) Validate ¶ 

func (m *CT_PivotAreas) Validate() error

Validate validates the CT_PivotAreas and its children

func (*CT_PivotAreas) ValidateWithPath ¶ 

func (m *CT_PivotAreas) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotAreas and its children, prefixing error messages with path

type CT_PivotCache ¶ 

type CT_PivotCache struct {
	// PivotCache Id
	CacheIdAttr uint32
	IdAttr      string
}

func NewCT_PivotCache ¶ 

func NewCT_PivotCache() *CT_PivotCache

func (*CT_PivotCache) MarshalXML ¶ 

func (m *CT_PivotCache) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PivotCache) UnmarshalXML ¶ 

func (m *CT_PivotCache) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PivotCache) Validate ¶ 

func (m *CT_PivotCache) Validate() error

Validate validates the CT_PivotCache and its children

func (*CT_PivotCache) ValidateWithPath ¶ 

func (m *CT_PivotCache) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotCache and its children, prefixing error messages with path

type CT_PivotCacheDefinition ¶ 

type CT_PivotCacheDefinition struct {
	IdAttr *string
	// Invalid Cache
	InvalidAttr *bool
	// Save Pivot Records
	SaveDataAttr *bool
	// Refresh On Load
	RefreshOnLoadAttr *bool
	// Optimize Cache for Memory
	OptimizeMemoryAttr *bool
	// Enable PivotCache Refresh
	EnableRefreshAttr *bool
	// Last Refreshed By
	RefreshedByAttr *string
	// PivotCache Last Refreshed Date
	RefreshedDateAttr *float64
	// PivotCache Last Refreshed Date ISO
	RefreshedDateIsoAttr *time.Time
	// Background Query
	BackgroundQueryAttr *bool
	// Missing Items Limit
	MissingItemsLimitAttr *uint32
	// PivotCache Created Version
	CreatedVersionAttr *uint8
	// PivotCache Last Refreshed Version
	RefreshedVersionAttr *uint8
	// Minimum Version Required for Refresh
	MinRefreshableVersionAttr *uint8
	// PivotCache Record Count
	RecordCountAttr *uint32
	// Upgrade PivotCache on Refresh
	UpgradeOnRefreshAttr *bool
	// Tuple Cache
	TupleCacheAttr *bool
	// Supports Subqueries
	SupportSubqueryAttr *bool
	// Supports Attribute Drilldown
	SupportAdvancedDrillAttr *bool
	// PivotCache Source Description
	CacheSource *CT_CacheSource
	// PivotCache Fields
	CacheFields *CT_CacheFields
	// PivotCache Hierarchies
	CacheHierarchies *CT_CacheHierarchies
	// OLAP KPIs
	Kpis *CT_PCDKPIs
	// Tuple Cache
	TupleCache *CT_TupleCache
	// Calculated Items
	CalculatedItems *CT_CalculatedItems
	// Calculated Members
	CalculatedMembers *CT_CalculatedMembers
	// OLAP Dimensions
	Dimensions *CT_Dimensions
	// OLAP Measure Groups
	MeasureGroups *CT_MeasureGroups
	// OLAP Measure Group
	Maps *CT_MeasureDimensionMaps
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_PivotCacheDefinition ¶ 

func NewCT_PivotCacheDefinition() *CT_PivotCacheDefinition

func (*CT_PivotCacheDefinition) MarshalXML ¶ 

func (m *CT_PivotCacheDefinition) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PivotCacheDefinition) UnmarshalXML ¶ 

func (m *CT_PivotCacheDefinition) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PivotCacheDefinition) Validate ¶ 

func (m *CT_PivotCacheDefinition) Validate() error

Validate validates the CT_PivotCacheDefinition and its children

func (*CT_PivotCacheDefinition) ValidateWithPath ¶ 

func (m *CT_PivotCacheDefinition) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotCacheDefinition and its children, prefixing error messages with path

type CT_PivotCacheRecords ¶ 

type CT_PivotCacheRecords struct {
	// PivotCache Records Count
	CountAttr *uint32
	// PivotCache Record
	R []*CT_Record
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_PivotCacheRecords ¶ 

func NewCT_PivotCacheRecords() *CT_PivotCacheRecords

func (*CT_PivotCacheRecords) MarshalXML ¶ 

func (m *CT_PivotCacheRecords) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PivotCacheRecords) UnmarshalXML ¶ 

func (m *CT_PivotCacheRecords) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PivotCacheRecords) Validate ¶ 

func (m *CT_PivotCacheRecords) Validate() error

Validate validates the CT_PivotCacheRecords and its children

func (*CT_PivotCacheRecords) ValidateWithPath ¶ 

func (m *CT_PivotCacheRecords) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotCacheRecords and its children, prefixing error messages with path

type CT_PivotCaches ¶ 

type CT_PivotCaches struct {
	// PivotCache
	PivotCache []*CT_PivotCache
}

func NewCT_PivotCaches ¶ 

func NewCT_PivotCaches() *CT_PivotCaches

func (*CT_PivotCaches) MarshalXML ¶ 

func (m *CT_PivotCaches) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PivotCaches) UnmarshalXML ¶ 

func (m *CT_PivotCaches) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PivotCaches) Validate ¶ 

func (m *CT_PivotCaches) Validate() error

Validate validates the CT_PivotCaches and its children

func (*CT_PivotCaches) ValidateWithPath ¶ 

func (m *CT_PivotCaches) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotCaches and its children, prefixing error messages with path

type CT_PivotDimension ¶ 

type CT_PivotDimension struct {
	// Measure
	MeasureAttr *bool
	// Dimension Name
	NameAttr string
	// Dimension Unique Name
	UniqueNameAttr string
	// Dimension Display Name
	CaptionAttr string
}

func NewCT_PivotDimension ¶ 

func NewCT_PivotDimension() *CT_PivotDimension

func (*CT_PivotDimension) MarshalXML ¶ 

func (m *CT_PivotDimension) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PivotDimension) UnmarshalXML ¶ 

func (m *CT_PivotDimension) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PivotDimension) Validate ¶ 

func (m *CT_PivotDimension) Validate() error

Validate validates the CT_PivotDimension and its children

func (*CT_PivotDimension) ValidateWithPath ¶ 

func (m *CT_PivotDimension) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotDimension and its children, prefixing error messages with path

type CT_PivotField ¶ 

type CT_PivotField struct {
	// Field Name
	NameAttr *string
	// Axis
	AxisAttr ST_Axis
	// Data Field
	DataFieldAttr *bool
	// Custom Subtotal Caption
	SubtotalCaptionAttr *string
	// Show PivotField Header Drop Downs
	ShowDropDownsAttr *bool
	// Hidden Level
	HiddenLevelAttr *bool
	// Unique Member Property
	UniqueMemberPropertyAttr *string
	// Compact
	CompactAttr *bool
	// All Items Expanded
	AllDrilledAttr *bool
	// Number Format Id
	NumFmtIdAttr *uint32
	// Outline Items
	OutlineAttr *bool
	// Subtotals At Top
	SubtotalTopAttr *bool
	// Drag To Row
	DragToRowAttr *bool
	// Drag To Column
	DragToColAttr *bool
	// Multiple Field Filters
	MultipleItemSelectionAllowedAttr *bool
	// Drag Field to Page
	DragToPageAttr *bool
	// Field Can Drag to Data
	DragToDataAttr *bool
	// Drag Off
	DragOffAttr *bool
	// Show All Items
	ShowAllAttr *bool
	// Insert Blank Row
	InsertBlankRowAttr *bool
	// Server-based Page Field
	ServerFieldAttr *bool
	// Insert Item Page Break
	InsertPageBreakAttr *bool
	// Auto Show
	AutoShowAttr *bool
	// Top Auto Show
	TopAutoShowAttr *bool
	// Hide New Items
	HideNewItemsAttr *bool
	// Measure Filter
	MeasureFilterAttr *bool
	// Inclusive Manual Filter
	IncludeNewItemsInFilterAttr *bool
	// Items Per Page Count
	ItemPageCountAttr *uint32
	// Auto Sort Type
	SortTypeAttr ST_FieldSortType
	// Data Source Sort
	DataSourceSortAttr *bool
	// Auto Sort
	NonAutoSortDefaultAttr *bool
	// Auto Show Rank By
	RankByAttr *uint32
	// Show Default Subtotal
	DefaultSubtotalAttr *bool
	// Sum Subtotal
	SumSubtotalAttr *bool
	// CountA
	CountASubtotalAttr *bool
	// Average
	AvgSubtotalAttr *bool
	// Max Subtotal
	MaxSubtotalAttr *bool
	// Min Subtotal
	MinSubtotalAttr *bool
	// Product Subtotal
	ProductSubtotalAttr *bool
	// Count
	CountSubtotalAttr *bool
	// StdDev Subtotal
	StdDevSubtotalAttr *bool
	// StdDevP Subtotal
	StdDevPSubtotalAttr *bool
	// Variance Subtotal
	VarSubtotalAttr *bool
	// VarP Subtotal
	VarPSubtotalAttr *bool
	// Show Member Property in Cell
	ShowPropCellAttr *bool
	// Show Member Property ToolTip
	ShowPropTipAttr *bool
	// Show As Caption
	ShowPropAsCaptionAttr *bool
	// Drill State
	DefaultAttributeDrillStateAttr *bool
	// Field Items
	Items *CT_Items
	// AutoSort Scope
	AutoSortScope *CT_AutoSortScope
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_PivotField ¶ 

func NewCT_PivotField() *CT_PivotField

func (*CT_PivotField) MarshalXML ¶ 

func (m *CT_PivotField) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PivotField) UnmarshalXML ¶ 

func (m *CT_PivotField) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PivotField) Validate ¶ 

func (m *CT_PivotField) Validate() error

Validate validates the CT_PivotField and its children

func (*CT_PivotField) ValidateWithPath ¶ 

func (m *CT_PivotField) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotField and its children, prefixing error messages with path

type CT_PivotFields ¶ 

type CT_PivotFields struct {
	// Field Count
	CountAttr *uint32
	// PivotTable Field
	PivotField []*CT_PivotField
}

func NewCT_PivotFields ¶ 

func NewCT_PivotFields() *CT_PivotFields

func (*CT_PivotFields) MarshalXML ¶ 

func (m *CT_PivotFields) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PivotFields) UnmarshalXML ¶ 

func (m *CT_PivotFields) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PivotFields) Validate ¶ 

func (m *CT_PivotFields) Validate() error

Validate validates the CT_PivotFields and its children

func (*CT_PivotFields) ValidateWithPath ¶ 

func (m *CT_PivotFields) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotFields and its children, prefixing error messages with path

type CT_PivotFilter ¶ 

type CT_PivotFilter struct {
	// Field Index
	FldAttr uint32
	// Member Property Field Id
	MpFldAttr *uint32
	// Pivot Filter Type
	TypeAttr ST_PivotFilterType
	// Evaluation Order
	EvalOrderAttr *int32
	// Pivot Filter Id
	IdAttr uint32
	// Measure Index
	IMeasureHierAttr *uint32
	// Measure Field Index
	IMeasureFldAttr *uint32
	// Pivot Filter Name
	NameAttr *string
	// Pivot Filter Description
	DescriptionAttr *string
	// Label Pivot
	StringValue1Attr *string
	// Label Pivot Filter String Value 2
	StringValue2Attr *string
	// Auto Filter
	AutoFilter *CT_AutoFilter
	ExtLst     *CT_ExtensionList
}

func NewCT_PivotFilter ¶ 

func NewCT_PivotFilter() *CT_PivotFilter

func (*CT_PivotFilter) MarshalXML ¶ 

func (m *CT_PivotFilter) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PivotFilter) UnmarshalXML ¶ 

func (m *CT_PivotFilter) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PivotFilter) Validate ¶ 

func (m *CT_PivotFilter) Validate() error

Validate validates the CT_PivotFilter and its children

func (*CT_PivotFilter) ValidateWithPath ¶ 

func (m *CT_PivotFilter) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotFilter and its children, prefixing error messages with path

type CT_PivotFilters ¶ 

type CT_PivotFilters struct {
	// Pivot Filter Count
	CountAttr *uint32
	// PivotTable Advanced Filter
	Filter []*CT_PivotFilter
}

func NewCT_PivotFilters ¶ 

func NewCT_PivotFilters() *CT_PivotFilters

func (*CT_PivotFilters) MarshalXML ¶ 

func (m *CT_PivotFilters) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PivotFilters) UnmarshalXML ¶ 

func (m *CT_PivotFilters) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PivotFilters) Validate ¶ 

func (m *CT_PivotFilters) Validate() error

Validate validates the CT_PivotFilters and its children

func (*CT_PivotFilters) ValidateWithPath ¶ 

func (m *CT_PivotFilters) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotFilters and its children, prefixing error messages with path

type CT_PivotHierarchies ¶ 

type CT_PivotHierarchies struct {
	// OLAP Hierarchy Count
	CountAttr *uint32
	// OLAP Hierarchy
	PivotHierarchy []*CT_PivotHierarchy
}

func NewCT_PivotHierarchies ¶ 

func NewCT_PivotHierarchies() *CT_PivotHierarchies

func (*CT_PivotHierarchies) MarshalXML ¶ 

func (m *CT_PivotHierarchies) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PivotHierarchies) UnmarshalXML ¶ 

func (m *CT_PivotHierarchies) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PivotHierarchies) Validate ¶ 

func (m *CT_PivotHierarchies) Validate() error

Validate validates the CT_PivotHierarchies and its children

func (*CT_PivotHierarchies) ValidateWithPath ¶ 

func (m *CT_PivotHierarchies) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotHierarchies and its children, prefixing error messages with path

type CT_PivotHierarchy ¶ 

type CT_PivotHierarchy struct {
	// Outline New Levels
	OutlineAttr *bool
	// Multiple Field Filters
	MultipleItemSelectionAllowedAttr *bool
	// New Levels Subtotals At Top
	SubtotalTopAttr *bool
	// Show In Field List
	ShowInFieldListAttr *bool
	// Drag To Row
	DragToRowAttr *bool
	// Drag To Column
	DragToColAttr *bool
	// Drag to Page
	DragToPageAttr *bool
	// Drag To Data
	DragToDataAttr *bool
	// Drag Off
	DragOffAttr *bool
	// Inclusive Manual Filter
	IncludeNewItemsInFilterAttr *bool
	// Hierarchy Caption
	CaptionAttr *string
	// OLAP Member Properties
	Mps *CT_MemberProperties
	// Members
	Members []*CT_Members
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_PivotHierarchy ¶ 

func NewCT_PivotHierarchy() *CT_PivotHierarchy

func (*CT_PivotHierarchy) MarshalXML ¶ 

func (m *CT_PivotHierarchy) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PivotHierarchy) UnmarshalXML ¶ 

func (m *CT_PivotHierarchy) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PivotHierarchy) Validate ¶ 

func (m *CT_PivotHierarchy) Validate() error

Validate validates the CT_PivotHierarchy and its children

func (*CT_PivotHierarchy) ValidateWithPath ¶ 

func (m *CT_PivotHierarchy) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotHierarchy and its children, prefixing error messages with path

type CT_PivotSelection ¶ 

type CT_PivotSelection struct {
	// Pane
	PaneAttr ST_Pane
	// Show Header
	ShowHeaderAttr *bool
	// Label
	LabelAttr *bool
	// Data Selection
	DataAttr *bool
	// Extendable
	ExtendableAttr *bool
	// Selection Count
	CountAttr *uint32
	// Axis
	AxisAttr ST_Axis
	// Dimension
	DimensionAttr *uint32
	// Start
	StartAttr *uint32
	// Minimum
	MinAttr *uint32
	// Maximum
	MaxAttr *uint32
	// Active Row
	ActiveRowAttr *uint32
	// Active Column
	ActiveColAttr *uint32
	// Previous Row
	PreviousRowAttr *uint32
	// Previous Column Selection
	PreviousColAttr *uint32
	// Click Count
	ClickAttr *uint32
	IdAttr    *string
	// Pivot Area
	PivotArea *CT_PivotArea
}

func NewCT_PivotSelection ¶ 

func NewCT_PivotSelection() *CT_PivotSelection

func (*CT_PivotSelection) MarshalXML ¶ 

func (m *CT_PivotSelection) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PivotSelection) UnmarshalXML ¶ 

func (m *CT_PivotSelection) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PivotSelection) Validate ¶ 

func (m *CT_PivotSelection) Validate() error

Validate validates the CT_PivotSelection and its children

func (*CT_PivotSelection) ValidateWithPath ¶ 

func (m *CT_PivotSelection) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotSelection and its children, prefixing error messages with path

type CT_PivotTableStyle ¶ 

type CT_PivotTableStyle struct {
	// Table Style Name
	NameAttr *string
	// Show Row Header Formatting
	ShowRowHeadersAttr *bool
	// Show Table Style Column Header Formatting
	ShowColHeadersAttr *bool
	// Show Row Stripes
	ShowRowStripesAttr *bool
	// Show Column Stripes
	ShowColStripesAttr *bool
	// Show Last Column
	ShowLastColumnAttr *bool
}

func NewCT_PivotTableStyle ¶ 

func NewCT_PivotTableStyle() *CT_PivotTableStyle

func (*CT_PivotTableStyle) MarshalXML ¶ 

func (m *CT_PivotTableStyle) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PivotTableStyle) UnmarshalXML ¶ 

func (m *CT_PivotTableStyle) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PivotTableStyle) Validate ¶ 

func (m *CT_PivotTableStyle) Validate() error

Validate validates the CT_PivotTableStyle and its children

func (*CT_PivotTableStyle) ValidateWithPath ¶ 

func (m *CT_PivotTableStyle) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PivotTableStyle and its children, prefixing error messages with path

type CT_PrintOptions ¶ 

type CT_PrintOptions struct {
	// Horizontal Centered
	HorizontalCenteredAttr *bool
	// Vertical Centered
	VerticalCenteredAttr *bool
	// Print Headings
	HeadingsAttr *bool
	// Print Grid Lines
	GridLinesAttr *bool
	// Grid Lines Set
	GridLinesSetAttr *bool
}

func NewCT_PrintOptions ¶ 

func NewCT_PrintOptions() *CT_PrintOptions

func (*CT_PrintOptions) MarshalXML ¶ 

func (m *CT_PrintOptions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_PrintOptions) UnmarshalXML ¶ 

func (m *CT_PrintOptions) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_PrintOptions) Validate ¶ 

func (m *CT_PrintOptions) Validate() error

Validate validates the CT_PrintOptions and its children

func (*CT_PrintOptions) ValidateWithPath ¶ 

func (m *CT_PrintOptions) ValidateWithPath(path string) error

ValidateWithPath validates the CT_PrintOptions and its children, prefixing error messages with path

type CT_ProtectedRange ¶ 

type CT_ProtectedRange struct {
	// Legacy Password
	PasswordAttr *string
	// Sequence of References
	SqrefAttr ST_Sqref
	// Name
	NameAttr string
	// Security Descriptor
	SecurityDescriptorAttr *string
	// Cryptographic Algorithm Name
	AlgorithmNameAttr *string
	// Password Hash Value
	HashValueAttr *string
	// Salt Value for Password Verifier
	SaltValueAttr *string
	// Iterations to Run Hashing Algorithm
	SpinCountAttr *uint32
	// Security Descriptor
	SecurityDescriptor []string
}

func NewCT_ProtectedRange ¶ 

func NewCT_ProtectedRange() *CT_ProtectedRange

func (*CT_ProtectedRange) MarshalXML ¶ 

func (m *CT_ProtectedRange) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_ProtectedRange) UnmarshalXML ¶ 

func (m *CT_ProtectedRange) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_ProtectedRange) Validate ¶ 

func (m *CT_ProtectedRange) Validate() error

Validate validates the CT_ProtectedRange and its children

func (*CT_ProtectedRange) ValidateWithPath ¶ 

func (m *CT_ProtectedRange) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ProtectedRange and its children, prefixing error messages with path

type CT_ProtectedRanges ¶ 

type CT_ProtectedRanges struct {
	// Protected Range
	ProtectedRange []*CT_ProtectedRange
}

func NewCT_ProtectedRanges ¶ 

func NewCT_ProtectedRanges() *CT_ProtectedRanges

func (*CT_ProtectedRanges) MarshalXML ¶ 

func (m *CT_ProtectedRanges) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_ProtectedRanges) UnmarshalXML ¶ 

func (m *CT_ProtectedRanges) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_ProtectedRanges) Validate ¶ 

func (m *CT_ProtectedRanges) Validate() error

Validate validates the CT_ProtectedRanges and its children

func (*CT_ProtectedRanges) ValidateWithPath ¶ 

func (m *CT_ProtectedRanges) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ProtectedRanges and its children, prefixing error messages with path

type CT_Query ¶ 

type CT_Query struct {
	// MDX Query String
	MdxAttr string
	// Tuples
	Tpls *CT_Tuples
}

func NewCT_Query ¶ 

func NewCT_Query() *CT_Query

func (*CT_Query) MarshalXML ¶ 

func (m *CT_Query) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Query) UnmarshalXML ¶ 

func (m *CT_Query) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Query) Validate ¶ 

func (m *CT_Query) Validate() error

Validate validates the CT_Query and its children

func (*CT_Query) ValidateWithPath ¶ 

func (m *CT_Query) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Query and its children, prefixing error messages with path

type CT_QueryCache ¶ 

type CT_QueryCache struct {
	// Cached Query Count
	CountAttr *uint32
	// Query
	Query []*CT_Query
}

func NewCT_QueryCache ¶ 

func NewCT_QueryCache() *CT_QueryCache

func (*CT_QueryCache) MarshalXML ¶ 

func (m *CT_QueryCache) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_QueryCache) UnmarshalXML ¶ 

func (m *CT_QueryCache) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_QueryCache) Validate ¶ 

func (m *CT_QueryCache) Validate() error

Validate validates the CT_QueryCache and its children

func (*CT_QueryCache) ValidateWithPath ¶ 

func (m *CT_QueryCache) ValidateWithPath(path string) error

ValidateWithPath validates the CT_QueryCache and its children, prefixing error messages with path

type CT_QueryTable ¶ 

type CT_QueryTable struct {
	// QueryTable Name
	NameAttr string
	// First Row Column Titles
	HeadersAttr *bool
	// Row Numbers
	RowNumbersAttr *bool
	// Disable Refresh
	DisableRefreshAttr *bool
	// Background Refresh
	BackgroundRefreshAttr *bool
	// First Background Refresh
	FirstBackgroundRefreshAttr *bool
	// Refresh On Load
	RefreshOnLoadAttr *bool
	// Grow Shrink Type
	GrowShrinkTypeAttr ST_GrowShrinkType
	// Fill Adjacent Formulas
	FillFormulasAttr *bool
	// Remove Data On Save
	RemoveDataOnSaveAttr *bool
	// Disable Edit
	DisableEditAttr *bool
	// Preserve Formatting On Refresh
	PreserveFormattingAttr *bool
	// Adjust Column Width On Refresh
	AdjustColumnWidthAttr *bool
	// Intermediate
	IntermediateAttr *bool
	// Connection Id
	ConnectionIdAttr uint32
	// QueryTable Refresh Information
	QueryTableRefresh *CT_QueryTableRefresh
	// Future Feature Data Storage Area
	ExtLst                      *CT_ExtensionList
	AutoFormatIdAttr            *uint32
	ApplyNumberFormatsAttr      *bool
	ApplyBorderFormatsAttr      *bool
	ApplyFontFormatsAttr        *bool
	ApplyPatternFormatsAttr     *bool
	ApplyAlignmentFormatsAttr   *bool
	ApplyWidthHeightFormatsAttr *bool
}

func NewCT_QueryTable ¶ 

func NewCT_QueryTable() *CT_QueryTable

func (*CT_QueryTable) MarshalXML ¶ 

func (m *CT_QueryTable) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_QueryTable) UnmarshalXML ¶ 

func (m *CT_QueryTable) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_QueryTable) Validate ¶ 

func (m *CT_QueryTable) Validate() error

Validate validates the CT_QueryTable and its children

func (*CT_QueryTable) ValidateWithPath ¶ 

func (m *CT_QueryTable) ValidateWithPath(path string) error

ValidateWithPath validates the CT_QueryTable and its children, prefixing error messages with path

type CT_QueryTableDeletedFields ¶ 

type CT_QueryTableDeletedFields struct {
	// Deleted Fields Count
	CountAttr *uint32
	// Deleted Field
	DeletedField []*CT_DeletedField
}

func NewCT_QueryTableDeletedFields ¶ 

func NewCT_QueryTableDeletedFields() *CT_QueryTableDeletedFields

func (*CT_QueryTableDeletedFields) MarshalXML ¶ 

func (m *CT_QueryTableDeletedFields) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_QueryTableDeletedFields) UnmarshalXML ¶ 

func (m *CT_QueryTableDeletedFields) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_QueryTableDeletedFields) Validate ¶ 

func (m *CT_QueryTableDeletedFields) Validate() error

Validate validates the CT_QueryTableDeletedFields and its children

func (*CT_QueryTableDeletedFields) ValidateWithPath ¶ 

func (m *CT_QueryTableDeletedFields) ValidateWithPath(path string) error

ValidateWithPath validates the CT_QueryTableDeletedFields and its children, prefixing error messages with path

type CT_QueryTableField ¶ 

type CT_QueryTableField struct {
	// Field Id
	IdAttr uint32
	// Name
	NameAttr *string
	// Data Bound Column
	DataBoundAttr *bool
	// Row Numbers
	RowNumbersAttr *bool
	// Fill This Formula On Refresh
	FillFormulasAttr *bool
	// Clipped Column
	ClippedAttr *bool
	// Table Column Id
	TableColumnIdAttr *uint32
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_QueryTableField ¶ 

func NewCT_QueryTableField() *CT_QueryTableField

func (*CT_QueryTableField) MarshalXML ¶ 

func (m *CT_QueryTableField) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_QueryTableField) UnmarshalXML ¶ 

func (m *CT_QueryTableField) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_QueryTableField) Validate ¶ 

func (m *CT_QueryTableField) Validate() error

Validate validates the CT_QueryTableField and its children

func (*CT_QueryTableField) ValidateWithPath ¶ 

func (m *CT_QueryTableField) ValidateWithPath(path string) error

ValidateWithPath validates the CT_QueryTableField and its children, prefixing error messages with path

type CT_QueryTableFields ¶ 

type CT_QueryTableFields struct {
	// Column Count
	CountAttr *uint32
	// QueryTable Field
	QueryTableField []*CT_QueryTableField
}

func NewCT_QueryTableFields ¶ 

func NewCT_QueryTableFields() *CT_QueryTableFields

func (*CT_QueryTableFields) MarshalXML ¶ 

func (m *CT_QueryTableFields) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_QueryTableFields) UnmarshalXML ¶ 

func (m *CT_QueryTableFields) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_QueryTableFields) Validate ¶ 

func (m *CT_QueryTableFields) Validate() error

Validate validates the CT_QueryTableFields and its children

func (*CT_QueryTableFields) ValidateWithPath ¶ 

func (m *CT_QueryTableFields) ValidateWithPath(path string) error

ValidateWithPath validates the CT_QueryTableFields and its children, prefixing error messages with path

type CT_QueryTableRefresh ¶ 

type CT_QueryTableRefresh struct {
	// Preserve Sort & Filter Layout
	PreserveSortFilterLayoutAttr *bool
	// Next Field Id Wrapped
	FieldIdWrappedAttr *bool
	// Headers In Last Refresh
	HeadersInLastRefreshAttr *bool
	// Minimum Refresh Version
	MinimumVersionAttr *uint8
	// Next field id
	NextIdAttr *uint32
	// Columns Left
	UnboundColumnsLeftAttr *uint32
	// Columns Right
	UnboundColumnsRightAttr *uint32
	// Query table fields
	QueryTableFields *CT_QueryTableFields
	// Deleted Fields
	QueryTableDeletedFields *CT_QueryTableDeletedFields
	// Sort State
	SortState *CT_SortState
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_QueryTableRefresh ¶ 

func NewCT_QueryTableRefresh() *CT_QueryTableRefresh

func (*CT_QueryTableRefresh) MarshalXML ¶ 

func (m *CT_QueryTableRefresh) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_QueryTableRefresh) UnmarshalXML ¶ 

func (m *CT_QueryTableRefresh) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_QueryTableRefresh) Validate ¶ 

func (m *CT_QueryTableRefresh) Validate() error

Validate validates the CT_QueryTableRefresh and its children

func (*CT_QueryTableRefresh) ValidateWithPath ¶ 

func (m *CT_QueryTableRefresh) ValidateWithPath(path string) error

ValidateWithPath validates the CT_QueryTableRefresh and its children, prefixing error messages with path

type CT_RElt ¶ 

type CT_RElt struct {
	// Run Properties
	RPr *CT_RPrElt
	// Text
	T string
}

func NewCT_RElt ¶ 

func NewCT_RElt() *CT_RElt

func (*CT_RElt) MarshalXML ¶ 

func (m *CT_RElt) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RElt) UnmarshalXML ¶ 

func (m *CT_RElt) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RElt) Validate ¶ 

func (m *CT_RElt) Validate() error

Validate validates the CT_RElt and its children

func (*CT_RElt) ValidateWithPath ¶ 

func (m *CT_RElt) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RElt and its children, prefixing error messages with path

type CT_RPrElt ¶ 

type CT_RPrElt struct {
	// Font
	RFont []*CT_FontName
	// Character Set
	Charset []*CT_IntProperty
	// Font Family
	Family []*CT_IntProperty
	// Bold
	B []*CT_BooleanProperty
	// Italic
	I []*CT_BooleanProperty
	// Strike Through
	Strike []*CT_BooleanProperty
	// Outline
	Outline []*CT_BooleanProperty
	// Shadow
	Shadow []*CT_BooleanProperty
	// Condense
	Condense []*CT_BooleanProperty
	// Extend
	Extend []*CT_BooleanProperty
	// Text Color
	Color []*CT_Color
	// Font Size
	Sz []*CT_FontSize
	// Underline
	U []*CT_UnderlineProperty
	// Vertical Alignment
	VertAlign []*CT_VerticalAlignFontProperty
	// Font Scheme
	Scheme []*CT_FontScheme
}

func NewCT_RPrElt ¶ 

func NewCT_RPrElt() *CT_RPrElt

func (*CT_RPrElt) MarshalXML ¶ 

func (m *CT_RPrElt) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RPrElt) UnmarshalXML ¶ 

func (m *CT_RPrElt) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RPrElt) Validate ¶ 

func (m *CT_RPrElt) Validate() error

Validate validates the CT_RPrElt and its children

func (*CT_RPrElt) ValidateWithPath ¶ 

func (m *CT_RPrElt) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RPrElt and its children, prefixing error messages with path

type CT_RangePr ¶ 

type CT_RangePr struct {
	// Source Data Set Beginning Range
	AutoStartAttr *bool
	// Source Data Ending Range
	AutoEndAttr *bool
	// Group By
	GroupByAttr ST_GroupBy
	// Numeric Grouping Start Value
	StartNumAttr *float64
	// Numeric Grouping End Value
	EndNumAttr *float64
	// Date Grouping Start Value
	StartDateAttr *time.Time
	// Date Grouping End Value
	EndDateAttr *time.Time
	// Grouping Interval
	GroupIntervalAttr *float64
}

func NewCT_RangePr ¶ 

func NewCT_RangePr() *CT_RangePr

func (*CT_RangePr) MarshalXML ¶ 

func (m *CT_RangePr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RangePr) UnmarshalXML ¶ 

func (m *CT_RangePr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RangePr) Validate ¶ 

func (m *CT_RangePr) Validate() error

Validate validates the CT_RangePr and its children

func (*CT_RangePr) ValidateWithPath ¶ 

func (m *CT_RangePr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RangePr and its children, prefixing error messages with path

type CT_RangeSet ¶ 

type CT_RangeSet struct {
	// Field Item Index Page 1
	I1Attr *uint32
	// Field Item Index Page 2
	I2Attr *uint32
	// Field Item index Page 3
	I3Attr *uint32
	// Field Item Index Page 4
	I4Attr *uint32
	// Reference
	RefAttr *string
	// Named Range
	NameAttr *string
	// Sheet Name
	SheetAttr *string
	IdAttr    *string
}

func NewCT_RangeSet ¶ 

func NewCT_RangeSet() *CT_RangeSet

func (*CT_RangeSet) MarshalXML ¶ 

func (m *CT_RangeSet) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RangeSet) UnmarshalXML ¶ 

func (m *CT_RangeSet) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RangeSet) Validate ¶ 

func (m *CT_RangeSet) Validate() error

Validate validates the CT_RangeSet and its children

func (*CT_RangeSet) ValidateWithPath ¶ 

func (m *CT_RangeSet) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RangeSet and its children, prefixing error messages with path

type CT_RangeSets ¶ 

type CT_RangeSets struct {
	// Reference and Page Item Count
	CountAttr *uint32
	// Range Set
	RangeSet []*CT_RangeSet
}

func NewCT_RangeSets ¶ 

func NewCT_RangeSets() *CT_RangeSets

func (*CT_RangeSets) MarshalXML ¶ 

func (m *CT_RangeSets) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RangeSets) UnmarshalXML ¶ 

func (m *CT_RangeSets) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RangeSets) Validate ¶ 

func (m *CT_RangeSets) Validate() error

Validate validates the CT_RangeSets and its children

func (*CT_RangeSets) ValidateWithPath ¶ 

func (m *CT_RangeSets) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RangeSets and its children, prefixing error messages with path

type CT_Record ¶ 

type CT_Record struct {
	// No Value
	M []*CT_Missing
	// Numeric Value
	N []*CT_Number
	// Boolean
	B []*CT_Boolean
	// Error Value
	E []*CT_Error
	// Character Value
	S []*CT_String
	// Date Time
	D []*CT_DateTime
	// Shared Items Index
	X []*CT_Index
}

func NewCT_Record ¶ 

func NewCT_Record() *CT_Record

func (*CT_Record) MarshalXML ¶ 

func (m *CT_Record) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Record) UnmarshalXML ¶ 

func (m *CT_Record) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Record) Validate ¶ 

func (m *CT_Record) Validate() error

Validate validates the CT_Record and its children

func (*CT_Record) ValidateWithPath ¶ 

func (m *CT_Record) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Record and its children, prefixing error messages with path

type CT_Reviewed ¶ 

type CT_Reviewed struct {
	// revision Id
	RIdAttr uint32
}

func NewCT_Reviewed ¶ 

func NewCT_Reviewed() *CT_Reviewed

func (*CT_Reviewed) MarshalXML ¶ 

func (m *CT_Reviewed) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Reviewed) UnmarshalXML ¶ 

func (m *CT_Reviewed) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Reviewed) Validate ¶ 

func (m *CT_Reviewed) Validate() error

Validate validates the CT_Reviewed and its children

func (*CT_Reviewed) ValidateWithPath ¶ 

func (m *CT_Reviewed) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Reviewed and its children, prefixing error messages with path

type CT_ReviewedRevisions ¶ 

type CT_ReviewedRevisions struct {
	// Reviewed Revisions Count
	CountAttr *uint32
	// Reviewed
	Reviewed []*CT_Reviewed
}

func NewCT_ReviewedRevisions ¶ 

func NewCT_ReviewedRevisions() *CT_ReviewedRevisions

func (*CT_ReviewedRevisions) MarshalXML ¶ 

func (m *CT_ReviewedRevisions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_ReviewedRevisions) UnmarshalXML ¶ 

func (m *CT_ReviewedRevisions) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_ReviewedRevisions) Validate ¶ 

func (m *CT_ReviewedRevisions) Validate() error

Validate validates the CT_ReviewedRevisions and its children

func (*CT_ReviewedRevisions) ValidateWithPath ¶ 

func (m *CT_ReviewedRevisions) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ReviewedRevisions and its children, prefixing error messages with path

type CT_RevisionAutoFormatting ¶ 

type CT_RevisionAutoFormatting struct {
	// Sheet Id
	SheetIdAttr uint32
	// Reference
	RefAttr                     string
	AutoFormatIdAttr            *uint32
	ApplyNumberFormatsAttr      *bool
	ApplyBorderFormatsAttr      *bool
	ApplyFontFormatsAttr        *bool
	ApplyPatternFormatsAttr     *bool
	ApplyAlignmentFormatsAttr   *bool
	ApplyWidthHeightFormatsAttr *bool
}

func NewCT_RevisionAutoFormatting ¶ 

func NewCT_RevisionAutoFormatting() *CT_RevisionAutoFormatting

func (*CT_RevisionAutoFormatting) MarshalXML ¶ 

func (m *CT_RevisionAutoFormatting) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RevisionAutoFormatting) UnmarshalXML ¶ 

func (m *CT_RevisionAutoFormatting) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RevisionAutoFormatting) Validate ¶ 

func (m *CT_RevisionAutoFormatting) Validate() error

Validate validates the CT_RevisionAutoFormatting and its children

func (*CT_RevisionAutoFormatting) ValidateWithPath ¶ 

func (m *CT_RevisionAutoFormatting) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RevisionAutoFormatting and its children, prefixing error messages with path

type CT_RevisionCellChange ¶ 

type CT_RevisionCellChange struct {
	// Sheet Id
	SIdAttr uint32
	// Old Formatting Information
	OdxfAttr *bool
	// Row Column Formatting Change
	XfDxfAttr *bool
	// Style Revision
	SAttr *bool
	// Formatting
	DxfAttr *bool
	// Number Format Id
	NumFmtIdAttr *uint32
	// Quote Prefix
	QuotePrefixAttr *bool
	// Old Quote Prefix
	OldQuotePrefixAttr *bool
	// Phonetic Text
	PhAttr *bool
	// Old Phonetic Text
	OldPhAttr *bool
	// End of List Formula Update
	EndOfListFormulaUpdateAttr *bool
	// Old Cell Data
	Oc *CT_Cell
	// New Cell Data
	Nc *CT_Cell
	// Old Formatting Information
	Odxf *CT_Dxf
	// New Formatting Information
	Ndxf    *CT_Dxf
	ExtLst  *CT_ExtensionList
	RIdAttr *uint32
	UaAttr  *bool
	RaAttr  *bool
}

func NewCT_RevisionCellChange ¶ 

func NewCT_RevisionCellChange() *CT_RevisionCellChange

func (*CT_RevisionCellChange) MarshalXML ¶ 

func (m *CT_RevisionCellChange) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RevisionCellChange) UnmarshalXML ¶ 

func (m *CT_RevisionCellChange) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RevisionCellChange) Validate ¶ 

func (m *CT_RevisionCellChange) Validate() error

Validate validates the CT_RevisionCellChange and its children

func (*CT_RevisionCellChange) ValidateWithPath ¶ 

func (m *CT_RevisionCellChange) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RevisionCellChange and its children, prefixing error messages with path

type CT_RevisionComment ¶ 

type CT_RevisionComment struct {
	// Sheet Id
	SheetIdAttr uint32
	// Cell
	CellAttr string
	// GUID
	GuidAttr string
	// User Action
	ActionAttr ST_RevisionAction
	// Always Show Comment
	AlwaysShowAttr *bool
	// Old Comment
	OldAttr *bool
	// Comment In Hidden Row
	HiddenRowAttr *bool
	// Hidden Column
	HiddenColumnAttr *bool
	// Author
	AuthorAttr string
	// Original Comment Length
	OldLengthAttr *uint32
	// New Comment Length
	NewLengthAttr *uint32
}

func NewCT_RevisionComment ¶ 

func NewCT_RevisionComment() *CT_RevisionComment

func (*CT_RevisionComment) MarshalXML ¶ 

func (m *CT_RevisionComment) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RevisionComment) UnmarshalXML ¶ 

func (m *CT_RevisionComment) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RevisionComment) Validate ¶ 

func (m *CT_RevisionComment) Validate() error

Validate validates the CT_RevisionComment and its children

func (*CT_RevisionComment) ValidateWithPath ¶ 

func (m *CT_RevisionComment) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RevisionComment and its children, prefixing error messages with path

type CT_RevisionConflict ¶ 

type CT_RevisionConflict struct {
	// Sheet Id
	SheetIdAttr *uint32
	RIdAttr     *uint32
	UaAttr      *bool
	RaAttr      *bool
}

func NewCT_RevisionConflict ¶ 

func NewCT_RevisionConflict() *CT_RevisionConflict

func (*CT_RevisionConflict) MarshalXML ¶ 

func (m *CT_RevisionConflict) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RevisionConflict) UnmarshalXML ¶ 

func (m *CT_RevisionConflict) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RevisionConflict) Validate ¶ 

func (m *CT_RevisionConflict) Validate() error

Validate validates the CT_RevisionConflict and its children

func (*CT_RevisionConflict) ValidateWithPath ¶ 

func (m *CT_RevisionConflict) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RevisionConflict and its children, prefixing error messages with path

type CT_RevisionCustomView ¶ 

type CT_RevisionCustomView struct {
	// GUID
	GuidAttr string
	// User Action
	ActionAttr ST_RevisionAction
}

func NewCT_RevisionCustomView ¶ 

func NewCT_RevisionCustomView() *CT_RevisionCustomView

func (*CT_RevisionCustomView) MarshalXML ¶ 

func (m *CT_RevisionCustomView) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RevisionCustomView) UnmarshalXML ¶ 

func (m *CT_RevisionCustomView) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RevisionCustomView) Validate ¶ 

func (m *CT_RevisionCustomView) Validate() error

Validate validates the CT_RevisionCustomView and its children

func (*CT_RevisionCustomView) ValidateWithPath ¶ 

func (m *CT_RevisionCustomView) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RevisionCustomView and its children, prefixing error messages with path

type CT_RevisionDefinedName ¶ 

type CT_RevisionDefinedName struct {
	// Local Name Sheet Id
	LocalSheetIdAttr *uint32
	// Custom View
	CustomViewAttr *bool
	// Name
	NameAttr string
	// Function
	FunctionAttr *bool
	// Old Function
	OldFunctionAttr *bool
	// Function Group Id
	FunctionGroupIdAttr *uint8
	// Old Function Group Id
	OldFunctionGroupIdAttr *uint8
	// Shortcut Key
	ShortcutKeyAttr *uint8
	// Old Short Cut Key
	OldShortcutKeyAttr *uint8
	// Named Range Hidden
	HiddenAttr *bool
	// Old Hidden
	OldHiddenAttr *bool
	// New Custom Menu
	CustomMenuAttr *string
	// Old Custom Menu Text
	OldCustomMenuAttr *string
	// Description
	DescriptionAttr *string
	// Old Description
	OldDescriptionAttr *string
	// New Help Topic
	HelpAttr *string
	// Old Help Topic
	OldHelpAttr *string
	// Status Bar
	StatusBarAttr *string
	// Old Status Bar
	OldStatusBarAttr *string
	// Name Comment
	CommentAttr *string
	// Old Name Comment
	OldCommentAttr *string
	// Formula
	Formula *string
	// Old Formula
	OldFormula *string
	ExtLst     *CT_ExtensionList
	RIdAttr    *uint32
	UaAttr     *bool
	RaAttr     *bool
}

func NewCT_RevisionDefinedName ¶ 

func NewCT_RevisionDefinedName() *CT_RevisionDefinedName

func (*CT_RevisionDefinedName) MarshalXML ¶ 

func (m *CT_RevisionDefinedName) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RevisionDefinedName) UnmarshalXML ¶ 

func (m *CT_RevisionDefinedName) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RevisionDefinedName) Validate ¶ 

func (m *CT_RevisionDefinedName) Validate() error

Validate validates the CT_RevisionDefinedName and its children

func (*CT_RevisionDefinedName) ValidateWithPath ¶ 

func (m *CT_RevisionDefinedName) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RevisionDefinedName and its children, prefixing error messages with path

type CT_RevisionFormatting ¶ 

type CT_RevisionFormatting struct {
	// Sheet Id
	SheetIdAttr uint32
	// Row or Column Formatting Change
	XfDxfAttr *bool
	// Style
	SAttr *bool
	// Sequence Of References
	SqrefAttr ST_Sqref
	// Start index
	StartAttr *uint32
	// Length
	LengthAttr *uint32
	// Formatting
	Dxf    *CT_Dxf
	ExtLst *CT_ExtensionList
}

func NewCT_RevisionFormatting ¶ 

func NewCT_RevisionFormatting() *CT_RevisionFormatting

func (*CT_RevisionFormatting) MarshalXML ¶ 

func (m *CT_RevisionFormatting) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RevisionFormatting) UnmarshalXML ¶ 

func (m *CT_RevisionFormatting) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RevisionFormatting) Validate ¶ 

func (m *CT_RevisionFormatting) Validate() error

Validate validates the CT_RevisionFormatting and its children

func (*CT_RevisionFormatting) ValidateWithPath ¶ 

func (m *CT_RevisionFormatting) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RevisionFormatting and its children, prefixing error messages with path

type CT_RevisionHeader ¶ 

type CT_RevisionHeader struct {
	// GUID
	GuidAttr string
	// Date Time
	DateTimeAttr time.Time
	// Last Sheet Id
	MaxSheetIdAttr uint32
	// User Name
	UserNameAttr string
	IdAttr       string
	// Minimum Revision Id
	MinRIdAttr *uint32
	// Max Revision Id
	MaxRIdAttr *uint32
	// Sheet Id Map
	SheetIdMap *CT_SheetIdMap
	// Reviewed List
	ReviewedList *CT_ReviewedRevisions
	ExtLst       *CT_ExtensionList
}

func NewCT_RevisionHeader ¶ 

func NewCT_RevisionHeader() *CT_RevisionHeader

func (*CT_RevisionHeader) MarshalXML ¶ 

func (m *CT_RevisionHeader) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RevisionHeader) UnmarshalXML ¶ 

func (m *CT_RevisionHeader) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RevisionHeader) Validate ¶ 

func (m *CT_RevisionHeader) Validate() error

Validate validates the CT_RevisionHeader and its children

func (*CT_RevisionHeader) ValidateWithPath ¶ 

func (m *CT_RevisionHeader) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RevisionHeader and its children, prefixing error messages with path

type CT_RevisionHeaders ¶ 

type CT_RevisionHeaders struct {
	// Last Revision GUID
	GuidAttr string
	// Last GUID
	LastGuidAttr *string
	// Shared Workbook
	SharedAttr *bool
	// Disk Revisions
	DiskRevisionsAttr *bool
	// History
	HistoryAttr *bool
	// Track Revisions
	TrackRevisionsAttr *bool
	// Exclusive Mode
	ExclusiveAttr *bool
	// Revision Id
	RevisionIdAttr *uint32
	// Version
	VersionAttr *int32
	// Keep Change History
	KeepChangeHistoryAttr *bool
	// Protected
	ProtectedAttr *bool
	// Preserve History
	PreserveHistoryAttr *uint32
	// Header
	Header []*CT_RevisionHeader
}

func NewCT_RevisionHeaders ¶ 

func NewCT_RevisionHeaders() *CT_RevisionHeaders

func (*CT_RevisionHeaders) MarshalXML ¶ 

func (m *CT_RevisionHeaders) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RevisionHeaders) UnmarshalXML ¶ 

func (m *CT_RevisionHeaders) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RevisionHeaders) Validate ¶ 

func (m *CT_RevisionHeaders) Validate() error

Validate validates the CT_RevisionHeaders and its children

func (*CT_RevisionHeaders) ValidateWithPath ¶ 

func (m *CT_RevisionHeaders) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RevisionHeaders and its children, prefixing error messages with path

type CT_RevisionInsertSheet ¶ 

type CT_RevisionInsertSheet struct {
	// Sheet Id
	SheetIdAttr uint32
	// Sheet Name
	NameAttr string
	// Sheet Position
	SheetPositionAttr uint32
	RIdAttr           *uint32
	UaAttr            *bool
	RaAttr            *bool
}

func NewCT_RevisionInsertSheet ¶ 

func NewCT_RevisionInsertSheet() *CT_RevisionInsertSheet

func (*CT_RevisionInsertSheet) MarshalXML ¶ 

func (m *CT_RevisionInsertSheet) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RevisionInsertSheet) UnmarshalXML ¶ 

func (m *CT_RevisionInsertSheet) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RevisionInsertSheet) Validate ¶ 

func (m *CT_RevisionInsertSheet) Validate() error

Validate validates the CT_RevisionInsertSheet and its children

func (*CT_RevisionInsertSheet) ValidateWithPath ¶ 

func (m *CT_RevisionInsertSheet) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RevisionInsertSheet and its children, prefixing error messages with path

type CT_RevisionMove ¶ 

type CT_RevisionMove struct {
	// Sheet Id
	SheetIdAttr uint32
	// Source
	SourceAttr string
	// Destination
	DestinationAttr string
	// Source Sheet Id
	SourceSheetIdAttr *uint32
	// Undo
	Undo []*CT_UndoInfo
	// Revision Cell Change
	Rcc []*CT_RevisionCellChange
	// Revision Format
	Rfmt    []*CT_RevisionFormatting
	RIdAttr *uint32
	UaAttr  *bool
	RaAttr  *bool
}

func NewCT_RevisionMove ¶ 

func NewCT_RevisionMove() *CT_RevisionMove

func (*CT_RevisionMove) MarshalXML ¶ 

func (m *CT_RevisionMove) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RevisionMove) UnmarshalXML ¶ 

func (m *CT_RevisionMove) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RevisionMove) Validate ¶ 

func (m *CT_RevisionMove) Validate() error

Validate validates the CT_RevisionMove and its children

func (*CT_RevisionMove) ValidateWithPath ¶ 

func (m *CT_RevisionMove) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RevisionMove and its children, prefixing error messages with path

type CT_RevisionQueryTableField ¶ 

type CT_RevisionQueryTableField struct {
	// Sheet Id
	SheetIdAttr uint32
	// QueryTable Reference
	RefAttr string
	// Field Id
	FieldIdAttr uint32
}

func NewCT_RevisionQueryTableField ¶ 

func NewCT_RevisionQueryTableField() *CT_RevisionQueryTableField

func (*CT_RevisionQueryTableField) MarshalXML ¶ 

func (m *CT_RevisionQueryTableField) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RevisionQueryTableField) UnmarshalXML ¶ 

func (m *CT_RevisionQueryTableField) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RevisionQueryTableField) Validate ¶ 

func (m *CT_RevisionQueryTableField) Validate() error

Validate validates the CT_RevisionQueryTableField and its children

func (*CT_RevisionQueryTableField) ValidateWithPath ¶ 

func (m *CT_RevisionQueryTableField) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RevisionQueryTableField and its children, prefixing error messages with path

type CT_RevisionRowColumn ¶ 

type CT_RevisionRowColumn struct {
	// Sheet Id
	SIdAttr uint32
	// End Of List
	EolAttr *bool
	// Reference
	RefAttr string
	// User Action
	ActionAttr ST_rwColActionType
	// Edge Deleted
	EdgeAttr *bool
	// Undo
	Undo []*CT_UndoInfo
	// Revised Row Column
	Rcc []*CT_RevisionCellChange
	// Revision Format
	Rfmt    []*CT_RevisionFormatting
	RIdAttr *uint32
	UaAttr  *bool
	RaAttr  *bool
}

func NewCT_RevisionRowColumn ¶ 

func NewCT_RevisionRowColumn() *CT_RevisionRowColumn

func (*CT_RevisionRowColumn) MarshalXML ¶ 

func (m *CT_RevisionRowColumn) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RevisionRowColumn) UnmarshalXML ¶ 

func (m *CT_RevisionRowColumn) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RevisionRowColumn) Validate ¶ 

func (m *CT_RevisionRowColumn) Validate() error

Validate validates the CT_RevisionRowColumn and its children

func (*CT_RevisionRowColumn) ValidateWithPath ¶ 

func (m *CT_RevisionRowColumn) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RevisionRowColumn and its children, prefixing error messages with path

type CT_RevisionSheetRename ¶ 

type CT_RevisionSheetRename struct {
	// Sheet Id
	SheetIdAttr uint32
	// Old Sheet Name
	OldNameAttr string
	// New Sheet Name
	NewNameAttr string
	ExtLst      *CT_ExtensionList
	RIdAttr     *uint32
	UaAttr      *bool
	RaAttr      *bool
}

func NewCT_RevisionSheetRename ¶ 

func NewCT_RevisionSheetRename() *CT_RevisionSheetRename

func (*CT_RevisionSheetRename) MarshalXML ¶ 

func (m *CT_RevisionSheetRename) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RevisionSheetRename) UnmarshalXML ¶ 

func (m *CT_RevisionSheetRename) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RevisionSheetRename) Validate ¶ 

func (m *CT_RevisionSheetRename) Validate() error

Validate validates the CT_RevisionSheetRename and its children

func (*CT_RevisionSheetRename) ValidateWithPath ¶ 

func (m *CT_RevisionSheetRename) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RevisionSheetRename and its children, prefixing error messages with path

type CT_Revisions ¶ 

type CT_Revisions struct {
	// Revision Row Column Insert Delete
	Rrc []*CT_RevisionRowColumn
	// Revision Cell Move
	Rm []*CT_RevisionMove
	// Revision Custom View
	Rcv []*CT_RevisionCustomView
	// Revision Sheet Name
	Rsnm []*CT_RevisionSheetRename
	// Revision Insert Sheet
	Ris []*CT_RevisionInsertSheet
	// Revision Cell Change
	Rcc []*CT_RevisionCellChange
	// Revision Format
	Rfmt []*CT_RevisionFormatting
	// Revision AutoFormat
	Raf []*CT_RevisionAutoFormatting
	// Revision Defined Name
	Rdn []*CT_RevisionDefinedName
	// Revision Cell Comment
	Rcmt []*CT_RevisionComment
	// Revision Query Table
	Rqt []*CT_RevisionQueryTableField
	// Revision Merge Conflict
	Rcft []*CT_RevisionConflict
}

func NewCT_Revisions ¶ 

func NewCT_Revisions() *CT_Revisions

func (*CT_Revisions) MarshalXML ¶ 

func (m *CT_Revisions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Revisions) UnmarshalXML ¶ 

func (m *CT_Revisions) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Revisions) Validate ¶ 

func (m *CT_Revisions) Validate() error

Validate validates the CT_Revisions and its children

func (*CT_Revisions) ValidateWithPath ¶ 

func (m *CT_Revisions) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Revisions and its children, prefixing error messages with path

type CT_RgbColor ¶ 

type CT_RgbColor struct {
	// Alpha Red Green Blue
	RgbAttr *string
}

func NewCT_RgbColor ¶ 

func NewCT_RgbColor() *CT_RgbColor

func (*CT_RgbColor) MarshalXML ¶ 

func (m *CT_RgbColor) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RgbColor) UnmarshalXML ¶ 

func (m *CT_RgbColor) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RgbColor) Validate ¶ 

func (m *CT_RgbColor) Validate() error

Validate validates the CT_RgbColor and its children

func (*CT_RgbColor) ValidateWithPath ¶ 

func (m *CT_RgbColor) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RgbColor and its children, prefixing error messages with path

type CT_Row ¶ 

type CT_Row struct {
	// Row Index
	RAttr *uint32
	// Spans
	SpansAttr *ST_CellSpans
	// Style Index
	SAttr *uint32
	// Custom Format
	CustomFormatAttr *bool
	// Row Height
	HtAttr *float64
	// Hidden
	HiddenAttr *bool
	// Custom Height
	CustomHeightAttr *bool
	// Outline Level
	OutlineLevelAttr *uint8
	// Collapsed
	CollapsedAttr *bool
	// Thick Top Border
	ThickTopAttr *bool
	// Thick Bottom
	ThickBotAttr *bool
	// Show Phonetic
	PhAttr *bool
	// Cell
	C []*CT_Cell
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_Row ¶ 

func NewCT_Row() *CT_Row

func (*CT_Row) MarshalXML ¶ 

func (m *CT_Row) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Row) UnmarshalXML ¶ 

func (m *CT_Row) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Row) Validate ¶ 

func (m *CT_Row) Validate() error

Validate validates the CT_Row and its children

func (*CT_Row) ValidateWithPath ¶ 

func (m *CT_Row) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Row and its children, prefixing error messages with path

type CT_RowFields ¶ 

type CT_RowFields struct {
	// Repeated Items Count
	CountAttr *uint32
	// Row Items
	Field []*CT_Field
}

func NewCT_RowFields ¶ 

func NewCT_RowFields() *CT_RowFields

func (*CT_RowFields) MarshalXML ¶ 

func (m *CT_RowFields) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RowFields) UnmarshalXML ¶ 

func (m *CT_RowFields) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RowFields) Validate ¶ 

func (m *CT_RowFields) Validate() error

Validate validates the CT_RowFields and its children

func (*CT_RowFields) ValidateWithPath ¶ 

func (m *CT_RowFields) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RowFields and its children, prefixing error messages with path

type CT_RowHierarchiesUsage ¶ 

type CT_RowHierarchiesUsage struct {
	// Item Count
	CountAttr *uint32
	// Row OLAP Hierarchies
	RowHierarchyUsage []*CT_HierarchyUsage
}

func NewCT_RowHierarchiesUsage ¶ 

func NewCT_RowHierarchiesUsage() *CT_RowHierarchiesUsage

func (*CT_RowHierarchiesUsage) MarshalXML ¶ 

func (m *CT_RowHierarchiesUsage) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_RowHierarchiesUsage) UnmarshalXML ¶ 

func (m *CT_RowHierarchiesUsage) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_RowHierarchiesUsage) Validate ¶ 

func (m *CT_RowHierarchiesUsage) Validate() error

Validate validates the CT_RowHierarchiesUsage and its children

func (*CT_RowHierarchiesUsage) ValidateWithPath ¶ 

func (m *CT_RowHierarchiesUsage) ValidateWithPath(path string) error

ValidateWithPath validates the CT_RowHierarchiesUsage and its children, prefixing error messages with path

type CT_Rst ¶ 

type CT_Rst struct {
	// Text
	T *string
	// Rich Text Run
	R []*CT_RElt
	// Phonetic Run
	RPh []*CT_PhoneticRun
	// Phonetic Properties
	PhoneticPr *CT_PhoneticPr
}

func NewCT_Rst ¶ 

func NewCT_Rst() *CT_Rst

func (*CT_Rst) MarshalXML ¶ 

func (m *CT_Rst) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Rst) UnmarshalXML ¶ 

func (m *CT_Rst) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Rst) Validate ¶ 

func (m *CT_Rst) Validate() error

Validate validates the CT_Rst and its children

func (*CT_Rst) ValidateWithPath ¶ 

func (m *CT_Rst) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Rst and its children, prefixing error messages with path

type CT_Scenario ¶ 

type CT_Scenario struct {
	// Scenario Name
	NameAttr string
	// Scenario Locked
	LockedAttr *bool
	// Hidden Scenario
	HiddenAttr *bool
	// Changing Cell Count
	CountAttr *uint32
	// User Name
	UserAttr *string
	// Scenario Comment
	CommentAttr *string
	// Input Cells
	InputCells []*CT_InputCells
}

func NewCT_Scenario ¶ 

func NewCT_Scenario() *CT_Scenario

func (*CT_Scenario) MarshalXML ¶ 

func (m *CT_Scenario) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Scenario) UnmarshalXML ¶ 

func (m *CT_Scenario) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Scenario) Validate ¶ 

func (m *CT_Scenario) Validate() error

Validate validates the CT_Scenario and its children

func (*CT_Scenario) ValidateWithPath ¶ 

func (m *CT_Scenario) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Scenario and its children, prefixing error messages with path

type CT_Scenarios ¶ 

type CT_Scenarios struct {
	// Current Scenario
	CurrentAttr *uint32
	// Last Shown Scenario
	ShowAttr *uint32
	// Sequence of References
	SqrefAttr *ST_Sqref
	// Scenario
	Scenario []*CT_Scenario
}

func NewCT_Scenarios ¶ 

func NewCT_Scenarios() *CT_Scenarios

func (*CT_Scenarios) MarshalXML ¶ 

func (m *CT_Scenarios) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Scenarios) UnmarshalXML ¶ 

func (m *CT_Scenarios) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Scenarios) Validate ¶ 

func (m *CT_Scenarios) Validate() error

Validate validates the CT_Scenarios and its children

func (*CT_Scenarios) ValidateWithPath ¶ 

func (m *CT_Scenarios) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Scenarios and its children, prefixing error messages with path

type CT_Schema ¶ 

type CT_Schema struct {
	// Schema ID
	IDAttr string
	// Schema Reference
	SchemaRefAttr *string
	// Schema Root Namespace
	NamespaceAttr *string
	// Schema Language
	SchemaLanguageAttr *string
	Any                gooxml.Any
}

func NewCT_Schema ¶ 

func NewCT_Schema() *CT_Schema

func (*CT_Schema) MarshalXML ¶ 

func (m *CT_Schema) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Schema) UnmarshalXML ¶ 

func (m *CT_Schema) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Schema) Validate ¶ 

func (m *CT_Schema) Validate() error

Validate validates the CT_Schema and its children

func (*CT_Schema) ValidateWithPath ¶ 

func (m *CT_Schema) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Schema and its children, prefixing error messages with path

type CT_Selection ¶ 

type CT_Selection struct {
	// Pane
	PaneAttr ST_Pane
	// Active Cell Location
	ActiveCellAttr *string
	// Active Cell Index
	ActiveCellIdAttr *uint32
	// Sequence of References
	SqrefAttr *ST_Sqref
}

func NewCT_Selection ¶ 

func NewCT_Selection() *CT_Selection

func (*CT_Selection) MarshalXML ¶ 

func (m *CT_Selection) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Selection) UnmarshalXML ¶ 

func (m *CT_Selection) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Selection) Validate ¶ 

func (m *CT_Selection) Validate() error

Validate validates the CT_Selection and its children

func (*CT_Selection) ValidateWithPath ¶ 

func (m *CT_Selection) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Selection and its children, prefixing error messages with path

type CT_ServerFormat ¶ 

type CT_ServerFormat struct {
	// Culture
	CultureAttr *string
	// Format
	FormatAttr *string
}

func NewCT_ServerFormat ¶ 

func NewCT_ServerFormat() *CT_ServerFormat

func (*CT_ServerFormat) MarshalXML ¶ 

func (m *CT_ServerFormat) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_ServerFormat) UnmarshalXML ¶ 

func (m *CT_ServerFormat) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_ServerFormat) Validate ¶ 

func (m *CT_ServerFormat) Validate() error

Validate validates the CT_ServerFormat and its children

func (*CT_ServerFormat) ValidateWithPath ¶ 

func (m *CT_ServerFormat) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ServerFormat and its children, prefixing error messages with path

type CT_ServerFormats ¶ 

type CT_ServerFormats struct {
	// Format Count
	CountAttr *uint32
	// Server Format
	ServerFormat []*CT_ServerFormat
}

func NewCT_ServerFormats ¶ 

func NewCT_ServerFormats() *CT_ServerFormats

func (*CT_ServerFormats) MarshalXML ¶ 

func (m *CT_ServerFormats) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_ServerFormats) UnmarshalXML ¶ 

func (m *CT_ServerFormats) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_ServerFormats) Validate ¶ 

func (m *CT_ServerFormats) Validate() error

Validate validates the CT_ServerFormats and its children

func (*CT_ServerFormats) ValidateWithPath ¶ 

func (m *CT_ServerFormats) ValidateWithPath(path string) error

ValidateWithPath validates the CT_ServerFormats and its children, prefixing error messages with path

type CT_Set ¶ 

type CT_Set struct {
	// Number of Tuples
	CountAttr *uint32
	// Maximum Rank Requested
	MaxRankAttr int32
	// MDX Set Definition
	SetDefinitionAttr string
	// Set Sort Order
	SortTypeAttr ST_SortType
	// Query Failed
	QueryFailedAttr *bool
	// Tuples
	Tpls []*CT_Tuples
	// Sort By Tuple
	SortByTuple *CT_Tuples
}

func NewCT_Set ¶ 

func NewCT_Set() *CT_Set

func (*CT_Set) MarshalXML ¶ 

func (m *CT_Set) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Set) UnmarshalXML ¶ 

func (m *CT_Set) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Set) Validate ¶ 

func (m *CT_Set) Validate() error

Validate validates the CT_Set and its children

func (*CT_Set) ValidateWithPath ¶ 

func (m *CT_Set) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Set and its children, prefixing error messages with path

type CT_Sets ¶ 

type CT_Sets struct {
	// Tuple Set Count
	CountAttr *uint32
	// OLAP Set
	Set []*CT_Set
}

func NewCT_Sets ¶ 

func NewCT_Sets() *CT_Sets

func (*CT_Sets) MarshalXML ¶ 

func (m *CT_Sets) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Sets) UnmarshalXML ¶ 

func (m *CT_Sets) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Sets) Validate ¶ 

func (m *CT_Sets) Validate() error

Validate validates the CT_Sets and its children

func (*CT_Sets) ValidateWithPath ¶ 

func (m *CT_Sets) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Sets and its children, prefixing error messages with path

type CT_SharedItems ¶ 

type CT_SharedItems struct {
	// Contains Semi Mixed Data Types
	ContainsSemiMixedTypesAttr *bool
	// Contains Non Date
	ContainsNonDateAttr *bool
	// Contains Date
	ContainsDateAttr *bool
	// Contains String
	ContainsStringAttr *bool
	// Contains Blank
	ContainsBlankAttr *bool
	// Contains Mixed Data Types
	ContainsMixedTypesAttr *bool
	// Contains Numbers
	ContainsNumberAttr *bool
	// Contains Integer
	ContainsIntegerAttr *bool
	// Minimum Numeric Value
	MinValueAttr *float64
	// Maximum Numeric Value
	MaxValueAttr *float64
	// Minimum Date Time
	MinDateAttr *time.Time
	// Maximum Date Time Value
	MaxDateAttr *time.Time
	// Shared Items Count
	CountAttr *uint32
	// Long Text
	LongTextAttr *bool
	// No Value
	M []*CT_Missing
	// Numeric
	N []*CT_Number
	// Boolean
	B []*CT_Boolean
	// Error Value
	E []*CT_Error
	// Character Value
	S []*CT_String
	// Date Time
	D []*CT_DateTime
}

func NewCT_SharedItems ¶ 

func NewCT_SharedItems() *CT_SharedItems

func (*CT_SharedItems) MarshalXML ¶ 

func (m *CT_SharedItems) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SharedItems) UnmarshalXML ¶ 

func (m *CT_SharedItems) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SharedItems) Validate ¶ 

func (m *CT_SharedItems) Validate() error

Validate validates the CT_SharedItems and its children

func (*CT_SharedItems) ValidateWithPath ¶ 

func (m *CT_SharedItems) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SharedItems and its children, prefixing error messages with path

type CT_SharedUser ¶ 

type CT_SharedUser struct {
	// User Revisions GUID
	GuidAttr string
	// User Name
	NameAttr string
	// User Id
	IdAttr int32
	// Date Time
	DateTimeAttr time.Time
	ExtLst       *CT_ExtensionList
}

func NewCT_SharedUser ¶ 

func NewCT_SharedUser() *CT_SharedUser

func (*CT_SharedUser) MarshalXML ¶ 

func (m *CT_SharedUser) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SharedUser) UnmarshalXML ¶ 

func (m *CT_SharedUser) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SharedUser) Validate ¶ 

func (m *CT_SharedUser) Validate() error

Validate validates the CT_SharedUser and its children

func (*CT_SharedUser) ValidateWithPath ¶ 

func (m *CT_SharedUser) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SharedUser and its children, prefixing error messages with path

type CT_Sheet ¶ 

type CT_Sheet struct {
	// Sheet Name
	NameAttr string
	// Sheet Tab Id
	SheetIdAttr uint32
	// Visible State
	StateAttr ST_SheetState
	IdAttr    string
}

func NewCT_Sheet ¶ 

func NewCT_Sheet() *CT_Sheet

func (*CT_Sheet) MarshalXML ¶ 

func (m *CT_Sheet) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Sheet) UnmarshalXML ¶ 

func (m *CT_Sheet) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Sheet) Validate ¶ 

func (m *CT_Sheet) Validate() error

Validate validates the CT_Sheet and its children

func (*CT_Sheet) ValidateWithPath ¶ 

func (m *CT_Sheet) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Sheet and its children, prefixing error messages with path

type CT_SheetBackgroundPicture ¶ 

type CT_SheetBackgroundPicture struct {
	IdAttr string
}

func NewCT_SheetBackgroundPicture ¶ 

func NewCT_SheetBackgroundPicture() *CT_SheetBackgroundPicture

func (*CT_SheetBackgroundPicture) MarshalXML ¶ 

func (m *CT_SheetBackgroundPicture) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SheetBackgroundPicture) UnmarshalXML ¶ 

func (m *CT_SheetBackgroundPicture) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SheetBackgroundPicture) Validate ¶ 

func (m *CT_SheetBackgroundPicture) Validate() error

Validate validates the CT_SheetBackgroundPicture and its children

func (*CT_SheetBackgroundPicture) ValidateWithPath ¶ 

func (m *CT_SheetBackgroundPicture) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SheetBackgroundPicture and its children, prefixing error messages with path

type CT_SheetCalcPr ¶ 

type CT_SheetCalcPr struct {
	// Full Calculation On Load
	FullCalcOnLoadAttr *bool
}

func NewCT_SheetCalcPr ¶ 

func NewCT_SheetCalcPr() *CT_SheetCalcPr

func (*CT_SheetCalcPr) MarshalXML ¶ 

func (m *CT_SheetCalcPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SheetCalcPr) UnmarshalXML ¶ 

func (m *CT_SheetCalcPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SheetCalcPr) Validate ¶ 

func (m *CT_SheetCalcPr) Validate() error

Validate validates the CT_SheetCalcPr and its children

func (*CT_SheetCalcPr) ValidateWithPath ¶ 

func (m *CT_SheetCalcPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SheetCalcPr and its children, prefixing error messages with path

type CT_SheetData ¶ 

type CT_SheetData struct {
	// Row
	Row []*CT_Row
}

func NewCT_SheetData ¶ 

func NewCT_SheetData() *CT_SheetData

func (*CT_SheetData) MarshalXML ¶ 

func (m *CT_SheetData) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SheetData) UnmarshalXML ¶ 

func (m *CT_SheetData) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SheetData) Validate ¶ 

func (m *CT_SheetData) Validate() error

Validate validates the CT_SheetData and its children

func (*CT_SheetData) ValidateWithPath ¶ 

func (m *CT_SheetData) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SheetData and its children, prefixing error messages with path

type CT_SheetDimension ¶ 

type CT_SheetDimension struct {
	// Reference
	RefAttr string
}

func NewCT_SheetDimension ¶ 

func NewCT_SheetDimension() *CT_SheetDimension

func (*CT_SheetDimension) MarshalXML ¶ 

func (m *CT_SheetDimension) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SheetDimension) UnmarshalXML ¶ 

func (m *CT_SheetDimension) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SheetDimension) Validate ¶ 

func (m *CT_SheetDimension) Validate() error

Validate validates the CT_SheetDimension and its children

func (*CT_SheetDimension) ValidateWithPath ¶ 

func (m *CT_SheetDimension) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SheetDimension and its children, prefixing error messages with path

type CT_SheetFormatPr ¶ 

type CT_SheetFormatPr struct {
	// Base Column Width
	BaseColWidthAttr *uint32
	// Default Column Width
	DefaultColWidthAttr *float64
	// Default Row Height
	DefaultRowHeightAttr float64
	// Custom Height
	CustomHeightAttr *bool
	// Hidden By Default
	ZeroHeightAttr *bool
	// Thick Top Border
	ThickTopAttr *bool
	// Thick Bottom Border
	ThickBottomAttr *bool
	// Maximum Outline Row
	OutlineLevelRowAttr *uint8
	// Column Outline Level
	OutlineLevelColAttr *uint8
}

func NewCT_SheetFormatPr ¶ 

func NewCT_SheetFormatPr() *CT_SheetFormatPr

func (*CT_SheetFormatPr) MarshalXML ¶ 

func (m *CT_SheetFormatPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SheetFormatPr) UnmarshalXML ¶ 

func (m *CT_SheetFormatPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SheetFormatPr) Validate ¶ 

func (m *CT_SheetFormatPr) Validate() error

Validate validates the CT_SheetFormatPr and its children

func (*CT_SheetFormatPr) ValidateWithPath ¶ 

func (m *CT_SheetFormatPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SheetFormatPr and its children, prefixing error messages with path

type CT_SheetId ¶ 

type CT_SheetId struct {
	// Sheet Id
	ValAttr uint32
}

func NewCT_SheetId ¶ 

func NewCT_SheetId() *CT_SheetId

func (*CT_SheetId) MarshalXML ¶ 

func (m *CT_SheetId) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SheetId) UnmarshalXML ¶ 

func (m *CT_SheetId) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SheetId) Validate ¶ 

func (m *CT_SheetId) Validate() error

Validate validates the CT_SheetId and its children

func (*CT_SheetId) ValidateWithPath ¶ 

func (m *CT_SheetId) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SheetId and its children, prefixing error messages with path

type CT_SheetIdMap ¶ 

type CT_SheetIdMap struct {
	// Sheet Count
	CountAttr *uint32
	// Sheet Id
	SheetId []*CT_SheetId
}

func NewCT_SheetIdMap ¶ 

func NewCT_SheetIdMap() *CT_SheetIdMap

func (*CT_SheetIdMap) MarshalXML ¶ 

func (m *CT_SheetIdMap) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SheetIdMap) UnmarshalXML ¶ 

func (m *CT_SheetIdMap) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SheetIdMap) Validate ¶ 

func (m *CT_SheetIdMap) Validate() error

Validate validates the CT_SheetIdMap and its children

func (*CT_SheetIdMap) ValidateWithPath ¶ 

func (m *CT_SheetIdMap) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SheetIdMap and its children, prefixing error messages with path

type CT_SheetPr ¶ 

type CT_SheetPr struct {
	// Synch Horizontal
	SyncHorizontalAttr *bool
	// Synch Vertical
	SyncVerticalAttr *bool
	// Synch Reference
	SyncRefAttr *string
	// Transition Formula Evaluation
	TransitionEvaluationAttr *bool
	// Transition Formula Entry
	TransitionEntryAttr *bool
	// Published
	PublishedAttr *bool
	// Code Name
	CodeNameAttr *string
	// Filter Mode
	FilterModeAttr *bool
	// Enable Conditional Formatting Calculations
	EnableFormatConditionsCalculationAttr *bool
	// Sheet Tab Color
	TabColor *CT_Color
	// Outline Properties
	OutlinePr *CT_OutlinePr
	// Page Setup Properties
	PageSetUpPr *CT_PageSetUpPr
}

func NewCT_SheetPr ¶ 

func NewCT_SheetPr() *CT_SheetPr

func (*CT_SheetPr) MarshalXML ¶ 

func (m *CT_SheetPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SheetPr) UnmarshalXML ¶ 

func (m *CT_SheetPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SheetPr) Validate ¶ 

func (m *CT_SheetPr) Validate() error

Validate validates the CT_SheetPr and its children

func (*CT_SheetPr) ValidateWithPath ¶ 

func (m *CT_SheetPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SheetPr and its children, prefixing error messages with path

type CT_SheetProtection ¶ 

type CT_SheetProtection struct {
	// Legacy Password
	PasswordAttr *string
	// Cryptographic Algorithm Name
	AlgorithmNameAttr *string
	// Password Hash Value
	HashValueAttr *string
	// Salt Value for Password Verifier
	SaltValueAttr *string
	// Iterations to Run Hashing Algorithm
	SpinCountAttr *uint32
	// Sheet Locked
	SheetAttr *bool
	// Objects Locked
	ObjectsAttr *bool
	// Scenarios Locked
	ScenariosAttr *bool
	// Format Cells Locked
	FormatCellsAttr *bool
	// Format Columns Locked
	FormatColumnsAttr *bool
	// Format Rows Locked
	FormatRowsAttr *bool
	// Insert Columns Locked
	InsertColumnsAttr *bool
	// Insert Rows Locked
	InsertRowsAttr *bool
	// Insert Hyperlinks Locked
	InsertHyperlinksAttr *bool
	// Delete Columns Locked
	DeleteColumnsAttr *bool
	// Delete Rows Locked
	DeleteRowsAttr *bool
	// Select Locked Cells Locked
	SelectLockedCellsAttr *bool
	// Sort Locked
	SortAttr *bool
	// AutoFilter Locked
	AutoFilterAttr *bool
	// Pivot Tables Locked
	PivotTablesAttr *bool
	// Select Unlocked Cells Locked
	SelectUnlockedCellsAttr *bool
}

func NewCT_SheetProtection ¶ 

func NewCT_SheetProtection() *CT_SheetProtection

func (*CT_SheetProtection) MarshalXML ¶ 

func (m *CT_SheetProtection) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SheetProtection) UnmarshalXML ¶ 

func (m *CT_SheetProtection) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SheetProtection) Validate ¶ 

func (m *CT_SheetProtection) Validate() error

Validate validates the CT_SheetProtection and its children

func (*CT_SheetProtection) ValidateWithPath ¶ 

func (m *CT_SheetProtection) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SheetProtection and its children, prefixing error messages with path

type CT_SheetView ¶ 

type CT_SheetView struct {
	// Window Protection
	WindowProtectionAttr *bool
	// Show Formulas
	ShowFormulasAttr *bool
	// Show Grid Lines
	ShowGridLinesAttr *bool
	// Show Headers
	ShowRowColHeadersAttr *bool
	// Show Zero Values
	ShowZerosAttr *bool
	// Right To Left
	RightToLeftAttr *bool
	// Sheet Tab Selected
	TabSelectedAttr *bool
	// Show Ruler
	ShowRulerAttr *bool
	// Show Outline Symbols
	ShowOutlineSymbolsAttr *bool
	// Default Grid Color
	DefaultGridColorAttr *bool
	// Show White Space
	ShowWhiteSpaceAttr *bool
	// View Type
	ViewAttr ST_SheetViewType
	// Top Left Visible Cell
	TopLeftCellAttr *string
	// Color Id
	ColorIdAttr *uint32
	// Zoom Scale
	ZoomScaleAttr *uint32
	// Zoom Scale Normal View
	ZoomScaleNormalAttr *uint32
	// Zoom Scale Page Break Preview
	ZoomScaleSheetLayoutViewAttr *uint32
	// Zoom Scale Page Layout View
	ZoomScalePageLayoutViewAttr *uint32
	// Workbook View Index
	WorkbookViewIdAttr uint32
	// View Pane
	Pane *CT_Pane
	// Selection
	Selection []*CT_Selection
	// PivotTable Selection
	PivotSelection []*CT_PivotSelection
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_SheetView ¶ 

func NewCT_SheetView() *CT_SheetView

func (*CT_SheetView) MarshalXML ¶ 

func (m *CT_SheetView) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SheetView) UnmarshalXML ¶ 

func (m *CT_SheetView) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SheetView) Validate ¶ 

func (m *CT_SheetView) Validate() error

Validate validates the CT_SheetView and its children

func (*CT_SheetView) ValidateWithPath ¶ 

func (m *CT_SheetView) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SheetView and its children, prefixing error messages with path

type CT_SheetViews ¶ 

type CT_SheetViews struct {
	// Worksheet View
	SheetView []*CT_SheetView
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_SheetViews ¶ 

func NewCT_SheetViews() *CT_SheetViews

func (*CT_SheetViews) MarshalXML ¶ 

func (m *CT_SheetViews) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SheetViews) UnmarshalXML ¶ 

func (m *CT_SheetViews) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SheetViews) Validate ¶ 

func (m *CT_SheetViews) Validate() error

Validate validates the CT_SheetViews and its children

func (*CT_SheetViews) ValidateWithPath ¶ 

func (m *CT_SheetViews) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SheetViews and its children, prefixing error messages with path

type CT_Sheets ¶ 

type CT_Sheets struct {
	// Sheet Information
	Sheet []*CT_Sheet
}

func NewCT_Sheets ¶ 

func NewCT_Sheets() *CT_Sheets

func (*CT_Sheets) MarshalXML ¶ 

func (m *CT_Sheets) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Sheets) UnmarshalXML ¶ 

func (m *CT_Sheets) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Sheets) Validate ¶ 

func (m *CT_Sheets) Validate() error

Validate validates the CT_Sheets and its children

func (*CT_Sheets) ValidateWithPath ¶ 

func (m *CT_Sheets) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Sheets and its children, prefixing error messages with path

type CT_SingleXmlCell ¶ 

type CT_SingleXmlCell struct {
	// Table Id
	IdAttr uint32
	// Reference
	RAttr string
	// Connection ID
	ConnectionIdAttr uint32
	// Cell Properties
	XmlCellPr *CT_XmlCellPr
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_SingleXmlCell ¶ 

func NewCT_SingleXmlCell() *CT_SingleXmlCell

func (*CT_SingleXmlCell) MarshalXML ¶ 

func (m *CT_SingleXmlCell) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SingleXmlCell) UnmarshalXML ¶ 

func (m *CT_SingleXmlCell) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SingleXmlCell) Validate ¶ 

func (m *CT_SingleXmlCell) Validate() error

Validate validates the CT_SingleXmlCell and its children

func (*CT_SingleXmlCell) ValidateWithPath ¶ 

func (m *CT_SingleXmlCell) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SingleXmlCell and its children, prefixing error messages with path

type CT_SingleXmlCells ¶ 

type CT_SingleXmlCells struct {
	// Table Properties
	SingleXmlCell []*CT_SingleXmlCell
}

func NewCT_SingleXmlCells ¶ 

func NewCT_SingleXmlCells() *CT_SingleXmlCells

func (*CT_SingleXmlCells) MarshalXML ¶ 

func (m *CT_SingleXmlCells) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SingleXmlCells) UnmarshalXML ¶ 

func (m *CT_SingleXmlCells) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SingleXmlCells) Validate ¶ 

func (m *CT_SingleXmlCells) Validate() error

Validate validates the CT_SingleXmlCells and its children

func (*CT_SingleXmlCells) ValidateWithPath ¶ 

func (m *CT_SingleXmlCells) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SingleXmlCells and its children, prefixing error messages with path

type CT_SmartTagPr ¶ 

type CT_SmartTagPr struct {
	// Embed SmartTags
	EmbedAttr *bool
	// Show Smart Tags
	ShowAttr ST_SmartTagShow
}

func NewCT_SmartTagPr ¶ 

func NewCT_SmartTagPr() *CT_SmartTagPr

func (*CT_SmartTagPr) MarshalXML ¶ 

func (m *CT_SmartTagPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SmartTagPr) UnmarshalXML ¶ 

func (m *CT_SmartTagPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SmartTagPr) Validate ¶ 

func (m *CT_SmartTagPr) Validate() error

Validate validates the CT_SmartTagPr and its children

func (*CT_SmartTagPr) ValidateWithPath ¶ 

func (m *CT_SmartTagPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SmartTagPr and its children, prefixing error messages with path

type CT_SmartTagType ¶ 

type CT_SmartTagType struct {
	// SmartTag Namespace URI
	NamespaceUriAttr *string
	// Name
	NameAttr *string
	// Smart Tag URL
	UrlAttr *string
}

func NewCT_SmartTagType ¶ 

func NewCT_SmartTagType() *CT_SmartTagType

func (*CT_SmartTagType) MarshalXML ¶ 

func (m *CT_SmartTagType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SmartTagType) UnmarshalXML ¶ 

func (m *CT_SmartTagType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SmartTagType) Validate ¶ 

func (m *CT_SmartTagType) Validate() error

Validate validates the CT_SmartTagType and its children

func (*CT_SmartTagType) ValidateWithPath ¶ 

func (m *CT_SmartTagType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SmartTagType and its children, prefixing error messages with path

type CT_SmartTagTypes ¶ 

type CT_SmartTagTypes struct {
	// Smart Tag Type
	SmartTagType []*CT_SmartTagType
}

func NewCT_SmartTagTypes ¶ 

func NewCT_SmartTagTypes() *CT_SmartTagTypes

func (*CT_SmartTagTypes) MarshalXML ¶ 

func (m *CT_SmartTagTypes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SmartTagTypes) UnmarshalXML ¶ 

func (m *CT_SmartTagTypes) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SmartTagTypes) Validate ¶ 

func (m *CT_SmartTagTypes) Validate() error

Validate validates the CT_SmartTagTypes and its children

func (*CT_SmartTagTypes) ValidateWithPath ¶ 

func (m *CT_SmartTagTypes) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SmartTagTypes and its children, prefixing error messages with path

type CT_SmartTags ¶ 

type CT_SmartTags struct {
	// Cell Smart Tags
	CellSmartTags []*CT_CellSmartTags
}

func NewCT_SmartTags ¶ 

func NewCT_SmartTags() *CT_SmartTags

func (*CT_SmartTags) MarshalXML ¶ 

func (m *CT_SmartTags) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SmartTags) UnmarshalXML ¶ 

func (m *CT_SmartTags) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SmartTags) Validate ¶ 

func (m *CT_SmartTags) Validate() error

Validate validates the CT_SmartTags and its children

func (*CT_SmartTags) ValidateWithPath ¶ 

func (m *CT_SmartTags) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SmartTags and its children, prefixing error messages with path

type CT_SortCondition ¶ 

type CT_SortCondition struct {
	// Descending
	DescendingAttr *bool
	// Sort By
	SortByAttr ST_SortBy
	// Reference
	RefAttr string
	// Custom List
	CustomListAttr *string
	// Format Id
	DxfIdAttr *uint32
	// Icon Set
	IconSetAttr ST_IconSetType
	// Icon Id
	IconIdAttr *uint32
}

func NewCT_SortCondition ¶ 

func NewCT_SortCondition() *CT_SortCondition

func (*CT_SortCondition) MarshalXML ¶ 

func (m *CT_SortCondition) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SortCondition) UnmarshalXML ¶ 

func (m *CT_SortCondition) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SortCondition) Validate ¶ 

func (m *CT_SortCondition) Validate() error

Validate validates the CT_SortCondition and its children

func (*CT_SortCondition) ValidateWithPath ¶ 

func (m *CT_SortCondition) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SortCondition and its children, prefixing error messages with path

type CT_SortState ¶ 

type CT_SortState struct {
	// Sort by Columns
	ColumnSortAttr *bool
	// Case Sensitive
	CaseSensitiveAttr *bool
	// Sort Method
	SortMethodAttr ST_SortMethod
	// Sort Range
	RefAttr string
	// Sort Condition
	SortCondition []*CT_SortCondition
	ExtLst        *CT_ExtensionList
}

func NewCT_SortState ¶ 

func NewCT_SortState() *CT_SortState

func (*CT_SortState) MarshalXML ¶ 

func (m *CT_SortState) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_SortState) UnmarshalXML ¶ 

func (m *CT_SortState) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_SortState) Validate ¶ 

func (m *CT_SortState) Validate() error

Validate validates the CT_SortState and its children

func (*CT_SortState) ValidateWithPath ¶ 

func (m *CT_SortState) ValidateWithPath(path string) error

ValidateWithPath validates the CT_SortState and its children, prefixing error messages with path

type CT_Sst ¶ 

type CT_Sst struct {
	// String Count
	CountAttr *uint32
	// Unique String Count
	UniqueCountAttr *uint32
	// String Item
	Si     []*CT_Rst
	ExtLst *CT_ExtensionList
}

func NewCT_Sst ¶ 

func NewCT_Sst() *CT_Sst

func (*CT_Sst) MarshalXML ¶ 

func (m *CT_Sst) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Sst) UnmarshalXML ¶ 

func (m *CT_Sst) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Sst) Validate ¶ 

func (m *CT_Sst) Validate() error

Validate validates the CT_Sst and its children

func (*CT_Sst) ValidateWithPath ¶ 

func (m *CT_Sst) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Sst and its children, prefixing error messages with path

type CT_String ¶ 

type CT_String struct {
	// Value
	VAttr string
	// Unused Item
	UAttr *bool
	// Calculated Item
	FAttr *bool
	// Item Caption
	CAttr *string
	// Member Property Count
	CpAttr *uint32
	// Format Index
	InAttr *uint32
	// Background Color
	BcAttr *string
	// Foreground Color
	FcAttr *string
	// Italic
	IAttr *bool
	// Underline
	UnAttr *bool
	// Strikethrough
	StAttr *bool
	// Bold
	BAttr *bool
	// Tuples
	Tpls []*CT_Tuples
	// Member Property Index
	X []*CT_X
}

func NewCT_String ¶ 

func NewCT_String() *CT_String

func (*CT_String) MarshalXML ¶ 

func (m *CT_String) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_String) UnmarshalXML ¶ 

func (m *CT_String) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_String) Validate ¶ 

func (m *CT_String) Validate() error

Validate validates the CT_String and its children

func (*CT_String) ValidateWithPath ¶ 

func (m *CT_String) ValidateWithPath(path string) error

ValidateWithPath validates the CT_String and its children, prefixing error messages with path

type CT_Stylesheet ¶ 

type CT_Stylesheet struct {
	// Number Formats
	NumFmts *CT_NumFmts
	// Fonts
	Fonts *CT_Fonts
	// Fills
	Fills *CT_Fills
	// Borders
	Borders *CT_Borders
	// Formatting Records
	CellStyleXfs *CT_CellStyleXfs
	// Cell Formats
	CellXfs *CT_CellXfs
	// Cell Styles
	CellStyles *CT_CellStyles
	// Formats
	Dxfs *CT_Dxfs
	// Table Styles
	TableStyles *CT_TableStyles
	// Colors
	Colors *CT_Colors
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_Stylesheet ¶ 

func NewCT_Stylesheet() *CT_Stylesheet

func (*CT_Stylesheet) MarshalXML ¶ 

func (m *CT_Stylesheet) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Stylesheet) UnmarshalXML ¶ 

func (m *CT_Stylesheet) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Stylesheet) Validate ¶ 

func (m *CT_Stylesheet) Validate() error

Validate validates the CT_Stylesheet and its children

func (*CT_Stylesheet) ValidateWithPath ¶ 

func (m *CT_Stylesheet) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Stylesheet and its children, prefixing error messages with path

type CT_Table ¶ 

type CT_Table struct {
	// Table Id
	IdAttr uint32
	// Name
	NameAttr *string
	// Table Name
	DisplayNameAttr string
	// Table Comment
	CommentAttr *string
	// Reference
	RefAttr string
	// Table Type
	TableTypeAttr ST_TableType
	// Header Row Count
	HeaderRowCountAttr *uint32
	// Insert Row Showing
	InsertRowAttr *bool
	// Insert Row Shift
	InsertRowShiftAttr *bool
	// Totals Row Count
	TotalsRowCountAttr *uint32
	// Totals Row Shown
	TotalsRowShownAttr *bool
	// Published
	PublishedAttr *bool
	// Header Row Format Id
	HeaderRowDxfIdAttr *uint32
	// Data Area Format Id
	DataDxfIdAttr *uint32
	// Totals Row Format Id
	TotalsRowDxfIdAttr *uint32
	// Header Row Border Format Id
	HeaderRowBorderDxfIdAttr *uint32
	// Table Border Format Id
	TableBorderDxfIdAttr *uint32
	// Totals Row Border Format Id
	TotalsRowBorderDxfIdAttr *uint32
	// Header Row Style
	HeaderRowCellStyleAttr *string
	// Data Style Name
	DataCellStyleAttr *string
	// Totals Row Style
	TotalsRowCellStyleAttr *string
	// Connection ID
	ConnectionIdAttr *uint32
	// Table AutoFilter
	AutoFilter *CT_AutoFilter
	// Sort State
	SortState *CT_SortState
	// Table Columns
	TableColumns *CT_TableColumns
	// Table Style
	TableStyleInfo *CT_TableStyleInfo
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_Table ¶ 

func NewCT_Table() *CT_Table

func (*CT_Table) MarshalXML ¶ 

func (m *CT_Table) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Table) UnmarshalXML ¶ 

func (m *CT_Table) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Table) Validate ¶ 

func (m *CT_Table) Validate() error

Validate validates the CT_Table and its children

func (*CT_Table) ValidateWithPath ¶ 

func (m *CT_Table) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Table and its children, prefixing error messages with path

type CT_TableColumn ¶ 

type CT_TableColumn struct {
	// Table Field Id
	IdAttr uint32
	// Unique Name
	UniqueNameAttr *string
	// Column name
	NameAttr string
	// Totals Row Function
	TotalsRowFunctionAttr ST_TotalsRowFunction
	// Totals Row Label
	TotalsRowLabelAttr *string
	// Query Table Field Id
	QueryTableFieldIdAttr *uint32
	// Header Row Cell Format Id
	HeaderRowDxfIdAttr *uint32
	// Data & Insert Row Format Id
	DataDxfIdAttr *uint32
	// Totals Row Format Id
	TotalsRowDxfIdAttr *uint32
	// Header Row Cell Style
	HeaderRowCellStyleAttr *string
	// Data Area Style Name
	DataCellStyleAttr *string
	// Totals Row Style Name
	TotalsRowCellStyleAttr *string
	// Calculated Column Formula
	CalculatedColumnFormula *CT_TableFormula
	// Totals Row Formula
	TotalsRowFormula *CT_TableFormula
	// XML Column Properties
	XmlColumnPr *CT_XmlColumnPr
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_TableColumn ¶ 

func NewCT_TableColumn() *CT_TableColumn

func (*CT_TableColumn) MarshalXML ¶ 

func (m *CT_TableColumn) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TableColumn) UnmarshalXML ¶ 

func (m *CT_TableColumn) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TableColumn) Validate ¶ 

func (m *CT_TableColumn) Validate() error

Validate validates the CT_TableColumn and its children

func (*CT_TableColumn) ValidateWithPath ¶ 

func (m *CT_TableColumn) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TableColumn and its children, prefixing error messages with path

type CT_TableColumns ¶ 

type CT_TableColumns struct {
	// Column Count
	CountAttr *uint32
	// Table Column
	TableColumn []*CT_TableColumn
}

func NewCT_TableColumns ¶ 

func NewCT_TableColumns() *CT_TableColumns

func (*CT_TableColumns) MarshalXML ¶ 

func (m *CT_TableColumns) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TableColumns) UnmarshalXML ¶ 

func (m *CT_TableColumns) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TableColumns) Validate ¶ 

func (m *CT_TableColumns) Validate() error

Validate validates the CT_TableColumns and its children

func (*CT_TableColumns) ValidateWithPath ¶ 

func (m *CT_TableColumns) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TableColumns and its children, prefixing error messages with path

type CT_TableFormula ¶ 

type CT_TableFormula struct {
	ArrayAttr bool
	Content   string
}

func NewCT_TableFormula ¶ 

func NewCT_TableFormula() *CT_TableFormula

func (*CT_TableFormula) MarshalXML ¶ 

func (m *CT_TableFormula) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TableFormula) UnmarshalXML ¶ 

func (m *CT_TableFormula) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TableFormula) Validate ¶ 

func (m *CT_TableFormula) Validate() error

Validate validates the CT_TableFormula and its children

func (*CT_TableFormula) ValidateWithPath ¶ 

func (m *CT_TableFormula) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TableFormula and its children, prefixing error messages with path

type CT_TableMissing ¶ 

type CT_TableMissing struct {
}

func NewCT_TableMissing ¶ 

func NewCT_TableMissing() *CT_TableMissing

func (*CT_TableMissing) MarshalXML ¶ 

func (m *CT_TableMissing) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TableMissing) UnmarshalXML ¶ 

func (m *CT_TableMissing) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TableMissing) Validate ¶ 

func (m *CT_TableMissing) Validate() error

Validate validates the CT_TableMissing and its children

func (*CT_TableMissing) ValidateWithPath ¶ 

func (m *CT_TableMissing) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TableMissing and its children, prefixing error messages with path

type CT_TablePart ¶ 

type CT_TablePart struct {
	IdAttr string
}

func NewCT_TablePart ¶ 

func NewCT_TablePart() *CT_TablePart

func (*CT_TablePart) MarshalXML ¶ 

func (m *CT_TablePart) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TablePart) UnmarshalXML ¶ 

func (m *CT_TablePart) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TablePart) Validate ¶ 

func (m *CT_TablePart) Validate() error

Validate validates the CT_TablePart and its children

func (*CT_TablePart) ValidateWithPath ¶ 

func (m *CT_TablePart) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TablePart and its children, prefixing error messages with path

type CT_TableParts ¶ 

type CT_TableParts struct {
	// Count
	CountAttr *uint32
	// Table Part
	TablePart []*CT_TablePart
}

func NewCT_TableParts ¶ 

func NewCT_TableParts() *CT_TableParts

func (*CT_TableParts) MarshalXML ¶ 

func (m *CT_TableParts) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TableParts) UnmarshalXML ¶ 

func (m *CT_TableParts) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TableParts) Validate ¶ 

func (m *CT_TableParts) Validate() error

Validate validates the CT_TableParts and its children

func (*CT_TableParts) ValidateWithPath ¶ 

func (m *CT_TableParts) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TableParts and its children, prefixing error messages with path

type CT_TableStyle ¶ 

type CT_TableStyle struct {
	// Table Style Name
	NameAttr string
	// Pivot Style
	PivotAttr *bool
	// Table
	TableAttr *bool
	// Table Style Count
	CountAttr *uint32
	// Table Style
	TableStyleElement []*CT_TableStyleElement
}

func NewCT_TableStyle ¶ 

func NewCT_TableStyle() *CT_TableStyle

func (*CT_TableStyle) MarshalXML ¶ 

func (m *CT_TableStyle) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TableStyle) UnmarshalXML ¶ 

func (m *CT_TableStyle) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TableStyle) Validate ¶ 

func (m *CT_TableStyle) Validate() error

Validate validates the CT_TableStyle and its children

func (*CT_TableStyle) ValidateWithPath ¶ 

func (m *CT_TableStyle) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TableStyle and its children, prefixing error messages with path

type CT_TableStyleElement ¶ 

type CT_TableStyleElement struct {
	// Table Style Type
	TypeAttr ST_TableStyleType
	// Band Size
	SizeAttr *uint32
	// Formatting Id
	DxfIdAttr *uint32
}

func NewCT_TableStyleElement ¶ 

func NewCT_TableStyleElement() *CT_TableStyleElement

func (*CT_TableStyleElement) MarshalXML ¶ 

func (m *CT_TableStyleElement) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TableStyleElement) UnmarshalXML ¶ 

func (m *CT_TableStyleElement) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TableStyleElement) Validate ¶ 

func (m *CT_TableStyleElement) Validate() error

Validate validates the CT_TableStyleElement and its children

func (*CT_TableStyleElement) ValidateWithPath ¶ 

func (m *CT_TableStyleElement) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TableStyleElement and its children, prefixing error messages with path

type CT_TableStyleInfo ¶ 

type CT_TableStyleInfo struct {
	// Style Name
	NameAttr *string
	// Show First Column
	ShowFirstColumnAttr *bool
	// Show Last Column
	ShowLastColumnAttr *bool
	// Show Row Stripes
	ShowRowStripesAttr *bool
	// Show Column Stripes
	ShowColumnStripesAttr *bool
}

func NewCT_TableStyleInfo ¶ 

func NewCT_TableStyleInfo() *CT_TableStyleInfo

func (*CT_TableStyleInfo) MarshalXML ¶ 

func (m *CT_TableStyleInfo) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TableStyleInfo) UnmarshalXML ¶ 

func (m *CT_TableStyleInfo) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TableStyleInfo) Validate ¶ 

func (m *CT_TableStyleInfo) Validate() error

Validate validates the CT_TableStyleInfo and its children

func (*CT_TableStyleInfo) ValidateWithPath ¶ 

func (m *CT_TableStyleInfo) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TableStyleInfo and its children, prefixing error messages with path

type CT_TableStyles ¶ 

type CT_TableStyles struct {
	// Table Style Count
	CountAttr *uint32
	// Default Table Style
	DefaultTableStyleAttr *string
	// Default Pivot Style
	DefaultPivotStyleAttr *string
	// Table Style
	TableStyle []*CT_TableStyle
}

func NewCT_TableStyles ¶ 

func NewCT_TableStyles() *CT_TableStyles

func (*CT_TableStyles) MarshalXML ¶ 

func (m *CT_TableStyles) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TableStyles) UnmarshalXML ¶ 

func (m *CT_TableStyles) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TableStyles) Validate ¶ 

func (m *CT_TableStyles) Validate() error

Validate validates the CT_TableStyles and its children

func (*CT_TableStyles) ValidateWithPath ¶ 

func (m *CT_TableStyles) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TableStyles and its children, prefixing error messages with path

type CT_Tables ¶ 

type CT_Tables struct {
	// Count of Tables
	CountAttr *uint32
	// No Value
	M []*CT_TableMissing
	// Character Value
	S []*CT_XStringElement
	// Index
	X []*CT_Index
}

func NewCT_Tables ¶ 

func NewCT_Tables() *CT_Tables

func (*CT_Tables) MarshalXML ¶ 

func (m *CT_Tables) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Tables) UnmarshalXML ¶ 

func (m *CT_Tables) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Tables) Validate ¶ 

func (m *CT_Tables) Validate() error

Validate validates the CT_Tables and its children

func (*CT_Tables) ValidateWithPath ¶ 

func (m *CT_Tables) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Tables and its children, prefixing error messages with path

type CT_TextField ¶ 

type CT_TextField struct {
	// Field Type
	TypeAttr ST_ExternalConnectionType
	// Position
	PositionAttr *uint32
}

func NewCT_TextField ¶ 

func NewCT_TextField() *CT_TextField

func (*CT_TextField) MarshalXML ¶ 

func (m *CT_TextField) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TextField) UnmarshalXML ¶ 

func (m *CT_TextField) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TextField) Validate ¶ 

func (m *CT_TextField) Validate() error

Validate validates the CT_TextField and its children

func (*CT_TextField) ValidateWithPath ¶ 

func (m *CT_TextField) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TextField and its children, prefixing error messages with path

type CT_TextFields ¶ 

type CT_TextFields struct {
	// Count of Fields
	CountAttr *uint32
	// Text Import Field Settings
	TextField []*CT_TextField
}

func NewCT_TextFields ¶ 

func NewCT_TextFields() *CT_TextFields

func (*CT_TextFields) MarshalXML ¶ 

func (m *CT_TextFields) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TextFields) UnmarshalXML ¶ 

func (m *CT_TextFields) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TextFields) Validate ¶ 

func (m *CT_TextFields) Validate() error

Validate validates the CT_TextFields and its children

func (*CT_TextFields) ValidateWithPath ¶ 

func (m *CT_TextFields) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TextFields and its children, prefixing error messages with path

type CT_TextPr ¶ 

type CT_TextPr struct {
	// Prompt for File Name
	PromptAttr *bool
	// File Type
	FileTypeAttr ST_FileType
	// Code Page
	CodePageAttr *uint32
	// Character Set
	CharacterSetAttr *string
	// First Row
	FirstRowAttr *uint32
	// Source File Name
	SourceFileAttr *string
	// Delimited File
	DelimitedAttr *bool
	// Decimal Separator
	DecimalAttr *string
	// Thousands Separator
	ThousandsAttr *string
	// Tab as Delimiter
	TabAttr *bool
	// Space is Delimiter
	SpaceAttr *bool
	// Comma is Delimiter
	CommaAttr *bool
	// Semicolon is Delimiter
	SemicolonAttr *bool
	// Consecutive Delimiters
	ConsecutiveAttr *bool
	// Qualifier
	QualifierAttr ST_Qualifier
	// Custom Delimiter
	DelimiterAttr *string
	// Fields
	TextFields *CT_TextFields
}

func NewCT_TextPr ¶ 

func NewCT_TextPr() *CT_TextPr

func (*CT_TextPr) MarshalXML ¶ 

func (m *CT_TextPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TextPr) UnmarshalXML ¶ 

func (m *CT_TextPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TextPr) Validate ¶ 

func (m *CT_TextPr) Validate() error

Validate validates the CT_TextPr and its children

func (*CT_TextPr) ValidateWithPath ¶ 

func (m *CT_TextPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TextPr and its children, prefixing error messages with path

type CT_Top10 ¶ 

type CT_Top10 struct {
	// Top
	TopAttr *bool
	// Filter by Percent
	PercentAttr *bool
	// Top or Bottom Value
	ValAttr float64
	// Filter Value
	FilterValAttr *float64
}

func NewCT_Top10 ¶ 

func NewCT_Top10() *CT_Top10

func (*CT_Top10) MarshalXML ¶ 

func (m *CT_Top10) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Top10) UnmarshalXML ¶ 

func (m *CT_Top10) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Top10) Validate ¶ 

func (m *CT_Top10) Validate() error

Validate validates the CT_Top10 and its children

func (*CT_Top10) ValidateWithPath ¶ 

func (m *CT_Top10) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Top10 and its children, prefixing error messages with path

type CT_Tuple ¶ 

type CT_Tuple struct {
	// Field Index
	FldAttr *uint32
	// Hierarchy Index
	HierAttr *uint32
	// Item Index
	ItemAttr uint32
}

func NewCT_Tuple ¶ 

func NewCT_Tuple() *CT_Tuple

func (*CT_Tuple) MarshalXML ¶ 

func (m *CT_Tuple) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Tuple) UnmarshalXML ¶ 

func (m *CT_Tuple) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Tuple) Validate ¶ 

func (m *CT_Tuple) Validate() error

Validate validates the CT_Tuple and its children

func (*CT_Tuple) ValidateWithPath ¶ 

func (m *CT_Tuple) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Tuple and its children, prefixing error messages with path

type CT_TupleCache ¶ 

type CT_TupleCache struct {
	// Entries
	Entries *CT_PCDSDTCEntries
	// Sets
	Sets *CT_Sets
	// OLAP Query Cache
	QueryCache *CT_QueryCache
	// Server Formats
	ServerFormats *CT_ServerFormats
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_TupleCache ¶ 

func NewCT_TupleCache() *CT_TupleCache

func (*CT_TupleCache) MarshalXML ¶ 

func (m *CT_TupleCache) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_TupleCache) UnmarshalXML ¶ 

func (m *CT_TupleCache) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_TupleCache) Validate ¶ 

func (m *CT_TupleCache) Validate() error

Validate validates the CT_TupleCache and its children

func (*CT_TupleCache) ValidateWithPath ¶ 

func (m *CT_TupleCache) ValidateWithPath(path string) error

ValidateWithPath validates the CT_TupleCache and its children, prefixing error messages with path

type CT_Tuples ¶ 

type CT_Tuples struct {
	// Member Name Count
	CAttr *uint32
	// Tuple
	Tpl []*CT_Tuple
}

func NewCT_Tuples ¶ 

func NewCT_Tuples() *CT_Tuples

func (*CT_Tuples) MarshalXML ¶ 

func (m *CT_Tuples) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Tuples) UnmarshalXML ¶ 

func (m *CT_Tuples) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Tuples) Validate ¶ 

func (m *CT_Tuples) Validate() error

Validate validates the CT_Tuples and its children

func (*CT_Tuples) ValidateWithPath ¶ 

func (m *CT_Tuples) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Tuples and its children, prefixing error messages with path

type CT_UnderlineProperty ¶ 

type CT_UnderlineProperty struct {
	// Underline Value
	ValAttr ST_UnderlineValues
}

func NewCT_UnderlineProperty ¶ 

func NewCT_UnderlineProperty() *CT_UnderlineProperty

func (*CT_UnderlineProperty) MarshalXML ¶ 

func (m *CT_UnderlineProperty) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_UnderlineProperty) UnmarshalXML ¶ 

func (m *CT_UnderlineProperty) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_UnderlineProperty) Validate ¶ 

func (m *CT_UnderlineProperty) Validate() error

Validate validates the CT_UnderlineProperty and its children

func (*CT_UnderlineProperty) ValidateWithPath ¶ 

func (m *CT_UnderlineProperty) ValidateWithPath(path string) error

ValidateWithPath validates the CT_UnderlineProperty and its children, prefixing error messages with path

type CT_UndoInfo ¶ 

type CT_UndoInfo struct {
	// Index
	IndexAttr uint32
	// Expression
	ExpAttr ST_FormulaExpression
	// Reference 3D
	Ref3DAttr *bool
	// Array Formula
	ArrayAttr *bool
	// Value Needed
	VAttr *bool
	// Defined Name Formula
	NfAttr *bool
	// Cross Sheet Move
	CsAttr *bool
	// Range
	DrAttr string
	// Defined Name
	DnAttr *string
	// Cell Reference
	RAttr *string
	// Sheet Id
	SIdAttr *uint32
}

func NewCT_UndoInfo ¶ 

func NewCT_UndoInfo() *CT_UndoInfo

func (*CT_UndoInfo) MarshalXML ¶ 

func (m *CT_UndoInfo) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_UndoInfo) UnmarshalXML ¶ 

func (m *CT_UndoInfo) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_UndoInfo) Validate ¶ 

func (m *CT_UndoInfo) Validate() error

Validate validates the CT_UndoInfo and its children

func (*CT_UndoInfo) ValidateWithPath ¶ 

func (m *CT_UndoInfo) ValidateWithPath(path string) error

ValidateWithPath validates the CT_UndoInfo and its children, prefixing error messages with path

type CT_Users ¶ 

type CT_Users struct {
	// Active User Count
	CountAttr *uint32
	// User Information
	UserInfo []*CT_SharedUser
}

func NewCT_Users ¶ 

func NewCT_Users() *CT_Users

func (*CT_Users) MarshalXML ¶ 

func (m *CT_Users) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Users) UnmarshalXML ¶ 

func (m *CT_Users) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Users) Validate ¶ 

func (m *CT_Users) Validate() error

Validate validates the CT_Users and its children

func (*CT_Users) ValidateWithPath ¶ 

func (m *CT_Users) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Users and its children, prefixing error messages with path

type CT_VerticalAlignFontProperty ¶ 

type CT_VerticalAlignFontProperty struct {
	// Value
	ValAttr sharedTypes.ST_VerticalAlignRun
}

func NewCT_VerticalAlignFontProperty ¶ 

func NewCT_VerticalAlignFontProperty() *CT_VerticalAlignFontProperty

func (*CT_VerticalAlignFontProperty) MarshalXML ¶ 

func (m *CT_VerticalAlignFontProperty) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_VerticalAlignFontProperty) UnmarshalXML ¶ 

func (m *CT_VerticalAlignFontProperty) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_VerticalAlignFontProperty) Validate ¶ 

func (m *CT_VerticalAlignFontProperty) Validate() error

Validate validates the CT_VerticalAlignFontProperty and its children

func (*CT_VerticalAlignFontProperty) ValidateWithPath ¶ 

func (m *CT_VerticalAlignFontProperty) ValidateWithPath(path string) error

ValidateWithPath validates the CT_VerticalAlignFontProperty and its children, prefixing error messages with path

type CT_VolMain ¶ 

type CT_VolMain struct {
	// First String
	FirstAttr string
	// Topic
	Tp []*CT_VolTopic
}

func NewCT_VolMain ¶ 

func NewCT_VolMain() *CT_VolMain

func (*CT_VolMain) MarshalXML ¶ 

func (m *CT_VolMain) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_VolMain) UnmarshalXML ¶ 

func (m *CT_VolMain) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_VolMain) Validate ¶ 

func (m *CT_VolMain) Validate() error

Validate validates the CT_VolMain and its children

func (*CT_VolMain) ValidateWithPath ¶ 

func (m *CT_VolMain) ValidateWithPath(path string) error

ValidateWithPath validates the CT_VolMain and its children, prefixing error messages with path

type CT_VolTopic ¶ 

type CT_VolTopic struct {
	// Type
	TAttr ST_VolValueType
	// Topic Value
	V string
	// Strings in Subtopic
	Stp []string
	// References
	Tr []*CT_VolTopicRef
}

func NewCT_VolTopic ¶ 

func NewCT_VolTopic() *CT_VolTopic

func (*CT_VolTopic) MarshalXML ¶ 

func (m *CT_VolTopic) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_VolTopic) UnmarshalXML ¶ 

func (m *CT_VolTopic) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_VolTopic) Validate ¶ 

func (m *CT_VolTopic) Validate() error

Validate validates the CT_VolTopic and its children

func (*CT_VolTopic) ValidateWithPath ¶ 

func (m *CT_VolTopic) ValidateWithPath(path string) error

ValidateWithPath validates the CT_VolTopic and its children, prefixing error messages with path

type CT_VolTopicRef ¶ 

type CT_VolTopicRef struct {
	// Reference
	RAttr string
	// Sheet Id
	SAttr uint32
}

func NewCT_VolTopicRef ¶ 

func NewCT_VolTopicRef() *CT_VolTopicRef

func (*CT_VolTopicRef) MarshalXML ¶ 

func (m *CT_VolTopicRef) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_VolTopicRef) UnmarshalXML ¶ 

func (m *CT_VolTopicRef) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_VolTopicRef) Validate ¶ 

func (m *CT_VolTopicRef) Validate() error

Validate validates the CT_VolTopicRef and its children

func (*CT_VolTopicRef) ValidateWithPath ¶ 

func (m *CT_VolTopicRef) ValidateWithPath(path string) error

ValidateWithPath validates the CT_VolTopicRef and its children, prefixing error messages with path

type CT_VolType ¶ 

type CT_VolType struct {
	// Type
	TypeAttr ST_VolDepType
	// Main
	Main []*CT_VolMain
}

func NewCT_VolType ¶ 

func NewCT_VolType() *CT_VolType

func (*CT_VolType) MarshalXML ¶ 

func (m *CT_VolType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_VolType) UnmarshalXML ¶ 

func (m *CT_VolType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_VolType) Validate ¶ 

func (m *CT_VolType) Validate() error

Validate validates the CT_VolType and its children

func (*CT_VolType) ValidateWithPath ¶ 

func (m *CT_VolType) ValidateWithPath(path string) error

ValidateWithPath validates the CT_VolType and its children, prefixing error messages with path

type CT_VolTypes ¶ 

type CT_VolTypes struct {
	// Volatile Dependency Type
	VolType []*CT_VolType
	ExtLst  *CT_ExtensionList
}

func NewCT_VolTypes ¶ 

func NewCT_VolTypes() *CT_VolTypes

func (*CT_VolTypes) MarshalXML ¶ 

func (m *CT_VolTypes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_VolTypes) UnmarshalXML ¶ 

func (m *CT_VolTypes) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_VolTypes) Validate ¶ 

func (m *CT_VolTypes) Validate() error

Validate validates the CT_VolTypes and its children

func (*CT_VolTypes) ValidateWithPath ¶ 

func (m *CT_VolTypes) ValidateWithPath(path string) error

ValidateWithPath validates the CT_VolTypes and its children, prefixing error messages with path

type CT_WebPr ¶ 

type CT_WebPr struct {
	// XML Source
	XmlAttr *bool
	// Import XML Source Data
	SourceDataAttr *bool
	// Parse PRE
	ParsePreAttr *bool
	// Consecutive Delimiters
	ConsecutiveAttr *bool
	// Use First Row
	FirstRowAttr *bool
	// Created in Excel 97
	Xl97Attr *bool
	// Dates as Text
	TextDatesAttr *bool
	// Refreshed in Excel 2000
	Xl2000Attr *bool
	// URL
	UrlAttr *string
	// Web Post
	PostAttr *string
	// HTML Tables Only
	HtmlTablesAttr *bool
	// HTML Formatting Handling
	HtmlFormatAttr ST_HtmlFmt
	// Edit Query URL
	EditPageAttr *string
	// Tables
	Tables *CT_Tables
}

func NewCT_WebPr ¶ 

func NewCT_WebPr() *CT_WebPr

func (*CT_WebPr) MarshalXML ¶ 

func (m *CT_WebPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_WebPr) UnmarshalXML ¶ 

func (m *CT_WebPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_WebPr) Validate ¶ 

func (m *CT_WebPr) Validate() error

Validate validates the CT_WebPr and its children

func (*CT_WebPr) ValidateWithPath ¶ 

func (m *CT_WebPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_WebPr and its children, prefixing error messages with path

type CT_WebPublishItem ¶ 

type CT_WebPublishItem struct {
	// Id
	IdAttr uint32
	// Destination Bookmark
	DivIdAttr string
	// Web Source Type
	SourceTypeAttr ST_WebSourceType
	// Source Id
	SourceRefAttr *string
	// Source Object Name
	SourceObjectAttr *string
	// Destination File Name
	DestinationFileAttr string
	// Title
	TitleAttr *string
	// Automatically Publish
	AutoRepublishAttr *bool
}

func NewCT_WebPublishItem ¶ 

func NewCT_WebPublishItem() *CT_WebPublishItem

func (*CT_WebPublishItem) MarshalXML ¶ 

func (m *CT_WebPublishItem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_WebPublishItem) UnmarshalXML ¶ 

func (m *CT_WebPublishItem) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_WebPublishItem) Validate ¶ 

func (m *CT_WebPublishItem) Validate() error

Validate validates the CT_WebPublishItem and its children

func (*CT_WebPublishItem) ValidateWithPath ¶ 

func (m *CT_WebPublishItem) ValidateWithPath(path string) error

ValidateWithPath validates the CT_WebPublishItem and its children, prefixing error messages with path

type CT_WebPublishItems ¶ 

type CT_WebPublishItems struct {
	// Web Publishing Items Count
	CountAttr *uint32
	// Web Publishing Item
	WebPublishItem []*CT_WebPublishItem
}

func NewCT_WebPublishItems ¶ 

func NewCT_WebPublishItems() *CT_WebPublishItems

func (*CT_WebPublishItems) MarshalXML ¶ 

func (m *CT_WebPublishItems) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_WebPublishItems) UnmarshalXML ¶ 

func (m *CT_WebPublishItems) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_WebPublishItems) Validate ¶ 

func (m *CT_WebPublishItems) Validate() error

Validate validates the CT_WebPublishItems and its children

func (*CT_WebPublishItems) ValidateWithPath ¶ 

func (m *CT_WebPublishItems) ValidateWithPath(path string) error

ValidateWithPath validates the CT_WebPublishItems and its children, prefixing error messages with path

type CT_WebPublishObject ¶ 

type CT_WebPublishObject struct {
	// Id
	IdAttr uint32
	// Div Id
	DivIdAttr string
	// Source Object
	SourceObjectAttr *string
	// Destination File
	DestinationFileAttr string
	// Title
	TitleAttr *string
	// Auto Republish
	AutoRepublishAttr *bool
}

func NewCT_WebPublishObject ¶ 

func NewCT_WebPublishObject() *CT_WebPublishObject

func (*CT_WebPublishObject) MarshalXML ¶ 

func (m *CT_WebPublishObject) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_WebPublishObject) UnmarshalXML ¶ 

func (m *CT_WebPublishObject) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_WebPublishObject) Validate ¶ 

func (m *CT_WebPublishObject) Validate() error

Validate validates the CT_WebPublishObject and its children

func (*CT_WebPublishObject) ValidateWithPath ¶ 

func (m *CT_WebPublishObject) ValidateWithPath(path string) error

ValidateWithPath validates the CT_WebPublishObject and its children, prefixing error messages with path

type CT_WebPublishObjects ¶ 

type CT_WebPublishObjects struct {
	// Count
	CountAttr *uint32
	// Web Publishing Object
	WebPublishObject []*CT_WebPublishObject
}

func NewCT_WebPublishObjects ¶ 

func NewCT_WebPublishObjects() *CT_WebPublishObjects

func (*CT_WebPublishObjects) MarshalXML ¶ 

func (m *CT_WebPublishObjects) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_WebPublishObjects) UnmarshalXML ¶ 

func (m *CT_WebPublishObjects) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_WebPublishObjects) Validate ¶ 

func (m *CT_WebPublishObjects) Validate() error

Validate validates the CT_WebPublishObjects and its children

func (*CT_WebPublishObjects) ValidateWithPath ¶ 

func (m *CT_WebPublishObjects) ValidateWithPath(path string) error

ValidateWithPath validates the CT_WebPublishObjects and its children, prefixing error messages with path

type CT_WebPublishing ¶ 

type CT_WebPublishing struct {
	// Use CSS
	CssAttr *bool
	// Thicket
	ThicketAttr *bool
	// Enable Long File Names
	LongFileNamesAttr *bool
	// VML in Browsers
	VmlAttr *bool
	// Allow PNG
	AllowPngAttr *bool
	// Target Screen Size
	TargetScreenSizeAttr ST_TargetScreenSize
	// DPI
	DpiAttr *uint32
	// Code Page
	CodePageAttr *uint32
	// Character Set
	CharacterSetAttr *string
}

func NewCT_WebPublishing ¶ 

func NewCT_WebPublishing() *CT_WebPublishing

func (*CT_WebPublishing) MarshalXML ¶ 

func (m *CT_WebPublishing) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_WebPublishing) UnmarshalXML ¶ 

func (m *CT_WebPublishing) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_WebPublishing) Validate ¶ 

func (m *CT_WebPublishing) Validate() error

Validate validates the CT_WebPublishing and its children

func (*CT_WebPublishing) ValidateWithPath ¶ 

func (m *CT_WebPublishing) ValidateWithPath(path string) error

ValidateWithPath validates the CT_WebPublishing and its children, prefixing error messages with path

type CT_Workbook ¶ 

type CT_Workbook struct {
	// Document Conformance Class
	ConformanceAttr sharedTypes.ST_ConformanceClass
	// File Version
	FileVersion *CT_FileVersion
	// File Sharing
	FileSharing *CT_FileSharing
	// Workbook Properties
	WorkbookPr *CT_WorkbookPr
	// Workbook Protection
	WorkbookProtection *CT_WorkbookProtection
	// Workbook Views
	BookViews *CT_BookViews
	// Sheets
	Sheets *CT_Sheets
	// Function Groups
	FunctionGroups *CT_FunctionGroups
	// External References
	ExternalReferences *CT_ExternalReferences
	// Defined Names
	DefinedNames *CT_DefinedNames
	// Calculation Properties
	CalcPr *CT_CalcPr
	// Embedded Object Size
	OleSize *CT_OleSize
	// Custom Workbook Views
	CustomWorkbookViews *CT_CustomWorkbookViews
	// PivotCaches
	PivotCaches *CT_PivotCaches
	// Smart Tag Properties
	SmartTagPr *CT_SmartTagPr
	// Smart Tag Types
	SmartTagTypes *CT_SmartTagTypes
	// Web Publishing Properties
	WebPublishing *CT_WebPublishing
	// File Recovery Properties
	FileRecoveryPr []*CT_FileRecoveryPr
	// Web Publish Objects
	WebPublishObjects *CT_WebPublishObjects
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_Workbook ¶ 

func NewCT_Workbook() *CT_Workbook

func (*CT_Workbook) MarshalXML ¶ 

func (m *CT_Workbook) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Workbook) UnmarshalXML ¶ 

func (m *CT_Workbook) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Workbook) Validate ¶ 

func (m *CT_Workbook) Validate() error

Validate validates the CT_Workbook and its children

func (*CT_Workbook) ValidateWithPath ¶ 

func (m *CT_Workbook) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Workbook and its children, prefixing error messages with path

type CT_WorkbookPr ¶ 

type CT_WorkbookPr struct {
	// Date 1904
	Date1904Attr *bool
	// Show Objects
	ShowObjectsAttr ST_Objects
	// Show Border Unselected Table
	ShowBorderUnselectedTablesAttr *bool
	// Filter Privacy
	FilterPrivacyAttr *bool
	// Prompted Solutions
	PromptedSolutionsAttr *bool
	// Show Ink Annotations
	ShowInkAnnotationAttr *bool
	// Create Backup File
	BackupFileAttr *bool
	// Save External Link Values
	SaveExternalLinkValuesAttr *bool
	// Update Links Behavior
	UpdateLinksAttr ST_UpdateLinks
	// Code Name
	CodeNameAttr *string
	// Hide Pivot Field List
	HidePivotFieldListAttr *bool
	// Show Pivot Chart Filter
	ShowPivotChartFilterAttr *bool
	// Allow Refresh Query
	AllowRefreshQueryAttr *bool
	// Publish Items
	PublishItemsAttr *bool
	// Check Compatibility On Save
	CheckCompatibilityAttr *bool
	// Auto Compress Pictures
	AutoCompressPicturesAttr *bool
	// Refresh all Connections on Open
	RefreshAllConnectionsAttr *bool
	// Default Theme Version
	DefaultThemeVersionAttr *uint32
}

func NewCT_WorkbookPr ¶ 

func NewCT_WorkbookPr() *CT_WorkbookPr

func (*CT_WorkbookPr) MarshalXML ¶ 

func (m *CT_WorkbookPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_WorkbookPr) UnmarshalXML ¶ 

func (m *CT_WorkbookPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_WorkbookPr) Validate ¶ 

func (m *CT_WorkbookPr) Validate() error

Validate validates the CT_WorkbookPr and its children

func (*CT_WorkbookPr) ValidateWithPath ¶ 

func (m *CT_WorkbookPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_WorkbookPr and its children, prefixing error messages with path

type CT_WorkbookProtection ¶ 

type CT_WorkbookProtection struct {
	// Legacy Workbook Password
	WorkbookPasswordAttr *string
	// Workbook Password Character Set
	WorkbookPasswordCharacterSetAttr *string
	// Legacy Revisions Password
	RevisionsPasswordAttr *string
	// Revisions Password Character Set
	RevisionsPasswordCharacterSetAttr *string
	// Lock Structure
	LockStructureAttr *bool
	// Lock Windows
	LockWindowsAttr *bool
	// Lock Revisions
	LockRevisionAttr *bool
	// Cryptographic Algorithm Name
	RevisionsAlgorithmNameAttr *string
	// Password Hash Value
	RevisionsHashValueAttr *string
	// Salt Value for Password Verifier
	RevisionsSaltValueAttr *string
	// Iterations to Run Hashing Algorithm
	RevisionsSpinCountAttr *uint32
	// Cryptographic Algorithm Name
	WorkbookAlgorithmNameAttr *string
	// Password Hash Value
	WorkbookHashValueAttr *string
	// Salt Value for Password Verifier
	WorkbookSaltValueAttr *string
	// Iterations to Run Hashing Algorithm
	WorkbookSpinCountAttr *uint32
}

func NewCT_WorkbookProtection ¶ 

func NewCT_WorkbookProtection() *CT_WorkbookProtection

func (*CT_WorkbookProtection) MarshalXML ¶ 

func (m *CT_WorkbookProtection) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_WorkbookProtection) UnmarshalXML ¶ 

func (m *CT_WorkbookProtection) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_WorkbookProtection) Validate ¶ 

func (m *CT_WorkbookProtection) Validate() error

Validate validates the CT_WorkbookProtection and its children

func (*CT_WorkbookProtection) ValidateWithPath ¶ 

func (m *CT_WorkbookProtection) ValidateWithPath(path string) error

ValidateWithPath validates the CT_WorkbookProtection and its children, prefixing error messages with path

type CT_Worksheet ¶ 

type CT_Worksheet struct {
	// Worksheet Properties
	SheetPr *CT_SheetPr
	// Worksheet Dimensions
	Dimension *CT_SheetDimension
	// Sheet Views
	SheetViews *CT_SheetViews
	// Sheet Format Properties
	SheetFormatPr *CT_SheetFormatPr
	// Column Information
	Cols []*CT_Cols
	// Sheet Data
	SheetData *CT_SheetData
	// Sheet Calculation Properties
	SheetCalcPr *CT_SheetCalcPr
	// Sheet Protection
	SheetProtection *CT_SheetProtection
	// Protected Ranges
	ProtectedRanges *CT_ProtectedRanges
	// Scenarios
	Scenarios *CT_Scenarios
	// AutoFilter
	AutoFilter *CT_AutoFilter
	// Sort State
	SortState *CT_SortState
	// Data Consolidate
	DataConsolidate *CT_DataConsolidate
	// Custom Sheet Views
	CustomSheetViews *CT_CustomSheetViews
	// Merge Cells
	MergeCells *CT_MergeCells
	// Phonetic Properties
	PhoneticPr *CT_PhoneticPr
	// Conditional Formatting
	ConditionalFormatting []*CT_ConditionalFormatting
	// Data Validations
	DataValidations *CT_DataValidations
	// Hyperlinks
	Hyperlinks *CT_Hyperlinks
	// Print Options
	PrintOptions *CT_PrintOptions
	// Page Margins
	PageMargins *CT_PageMargins
	// Page Setup Settings
	PageSetup *CT_PageSetup
	// Header and Footer Settings
	HeaderFooter *CT_HeaderFooter
	// Horizontal Page Breaks
	RowBreaks *CT_PageBreak
	// Vertical Page Breaks
	ColBreaks *CT_PageBreak
	// Custom Properties
	CustomProperties *CT_CustomProperties
	// Cell Watch Items
	CellWatches *CT_CellWatches
	// Ignored Errors
	IgnoredErrors *CT_IgnoredErrors
	// Smart Tags
	SmartTags *CT_SmartTags
	// Drawing
	Drawing *CT_Drawing
	// Legacy Drawing
	LegacyDrawing *CT_LegacyDrawing
	// Legacy Drawing Header Footer
	LegacyDrawingHF *CT_LegacyDrawing
	DrawingHF       *CT_DrawingHF
	// Background Image
	Picture    *CT_SheetBackgroundPicture
	OleObjects *CT_OleObjects
	// Embedded Controls
	Controls *CT_Controls
	// Web Publishing Items
	WebPublishItems *CT_WebPublishItems
	// Table Parts
	TableParts *CT_TableParts
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_Worksheet ¶ 

func NewCT_Worksheet() *CT_Worksheet

func (*CT_Worksheet) MarshalXML ¶ 

func (m *CT_Worksheet) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Worksheet) UnmarshalXML ¶ 

func (m *CT_Worksheet) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Worksheet) Validate ¶ 

func (m *CT_Worksheet) Validate() error

Validate validates the CT_Worksheet and its children

func (*CT_Worksheet) ValidateWithPath ¶ 

func (m *CT_Worksheet) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Worksheet and its children, prefixing error messages with path

type CT_WorksheetSource ¶ 

type CT_WorksheetSource struct {
	// Reference
	RefAttr *string
	// Named Range
	NameAttr *string
	// Sheet Name
	SheetAttr *string
	IdAttr    *string
}

func NewCT_WorksheetSource ¶ 

func NewCT_WorksheetSource() *CT_WorksheetSource

func (*CT_WorksheetSource) MarshalXML ¶ 

func (m *CT_WorksheetSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_WorksheetSource) UnmarshalXML ¶ 

func (m *CT_WorksheetSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_WorksheetSource) Validate ¶ 

func (m *CT_WorksheetSource) Validate() error

Validate validates the CT_WorksheetSource and its children

func (*CT_WorksheetSource) ValidateWithPath ¶ 

func (m *CT_WorksheetSource) ValidateWithPath(path string) error

ValidateWithPath validates the CT_WorksheetSource and its children, prefixing error messages with path

type CT_X ¶ 

type CT_X struct {
	// Shared Items Index
	VAttr *int32
}

func NewCT_X ¶ 

func NewCT_X() *CT_X

func (*CT_X) MarshalXML ¶ 

func (m *CT_X) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_X) UnmarshalXML ¶ 

func (m *CT_X) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_X) Validate ¶ 

func (m *CT_X) Validate() error

Validate validates the CT_X and its children

func (*CT_X) ValidateWithPath ¶ 

func (m *CT_X) ValidateWithPath(path string) error

ValidateWithPath validates the CT_X and its children, prefixing error messages with path

type CT_XStringElement ¶ 

type CT_XStringElement struct {
	// Value
	VAttr string
}

func NewCT_XStringElement ¶ 

func NewCT_XStringElement() *CT_XStringElement

func (*CT_XStringElement) MarshalXML ¶ 

func (m *CT_XStringElement) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_XStringElement) UnmarshalXML ¶ 

func (m *CT_XStringElement) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_XStringElement) Validate ¶ 

func (m *CT_XStringElement) Validate() error

Validate validates the CT_XStringElement and its children

func (*CT_XStringElement) ValidateWithPath ¶ 

func (m *CT_XStringElement) ValidateWithPath(path string) error

ValidateWithPath validates the CT_XStringElement and its children, prefixing error messages with path

type CT_Xf ¶ 

type CT_Xf struct {
	// Number Format Id
	NumFmtIdAttr *uint32
	// Font Id
	FontIdAttr *uint32
	// Fill Id
	FillIdAttr *uint32
	// Border Id
	BorderIdAttr *uint32
	// Format Id
	XfIdAttr *uint32
	// Quote Prefix
	QuotePrefixAttr *bool
	// Pivot Button
	PivotButtonAttr *bool
	// Apply Number Format
	ApplyNumberFormatAttr *bool
	// Apply Font
	ApplyFontAttr *bool
	// Apply Fill
	ApplyFillAttr *bool
	// Apply Border
	ApplyBorderAttr *bool
	// Apply Alignment
	ApplyAlignmentAttr *bool
	// Apply Protection
	ApplyProtectionAttr *bool
	// Alignment
	Alignment *CT_CellAlignment
	// Protection
	Protection *CT_CellProtection
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_Xf ¶ 

func NewCT_Xf() *CT_Xf

func (*CT_Xf) MarshalXML ¶ 

func (m *CT_Xf) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_Xf) UnmarshalXML ¶ 

func (m *CT_Xf) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_Xf) Validate ¶ 

func (m *CT_Xf) Validate() error

Validate validates the CT_Xf and its children

func (*CT_Xf) ValidateWithPath ¶ 

func (m *CT_Xf) ValidateWithPath(path string) error

ValidateWithPath validates the CT_Xf and its children, prefixing error messages with path

type CT_XmlCellPr ¶ 

type CT_XmlCellPr struct {
	// Table Field Id
	IdAttr uint32
	// Unique Table Name
	UniqueNameAttr *string
	// Column XML Properties
	XmlPr *CT_XmlPr
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_XmlCellPr ¶ 

func NewCT_XmlCellPr() *CT_XmlCellPr

func (*CT_XmlCellPr) MarshalXML ¶ 

func (m *CT_XmlCellPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_XmlCellPr) UnmarshalXML ¶ 

func (m *CT_XmlCellPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_XmlCellPr) Validate ¶ 

func (m *CT_XmlCellPr) Validate() error

Validate validates the CT_XmlCellPr and its children

func (*CT_XmlCellPr) ValidateWithPath ¶ 

func (m *CT_XmlCellPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_XmlCellPr and its children, prefixing error messages with path

type CT_XmlColumnPr ¶ 

type CT_XmlColumnPr struct {
	// XML Map Id
	MapIdAttr uint32
	// XPath
	XpathAttr string
	// Denormalized
	DenormalizedAttr *bool
	// XML Data Type
	XmlDataTypeAttr string
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_XmlColumnPr ¶ 

func NewCT_XmlColumnPr() *CT_XmlColumnPr

func (*CT_XmlColumnPr) MarshalXML ¶ 

func (m *CT_XmlColumnPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_XmlColumnPr) UnmarshalXML ¶ 

func (m *CT_XmlColumnPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_XmlColumnPr) Validate ¶ 

func (m *CT_XmlColumnPr) Validate() error

Validate validates the CT_XmlColumnPr and its children

func (*CT_XmlColumnPr) ValidateWithPath ¶ 

func (m *CT_XmlColumnPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_XmlColumnPr and its children, prefixing error messages with path

type CT_XmlPr ¶ 

type CT_XmlPr struct {
	// XML Map Id
	MapIdAttr uint32
	// XPath
	XpathAttr string
	// XML Data Type
	XmlDataTypeAttr string
	// Future Feature Data Storage Area
	ExtLst *CT_ExtensionList
}

func NewCT_XmlPr ¶ 

func NewCT_XmlPr() *CT_XmlPr

func (*CT_XmlPr) MarshalXML ¶ 

func (m *CT_XmlPr) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_XmlPr) UnmarshalXML ¶ 

func (m *CT_XmlPr) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_XmlPr) Validate ¶ 

func (m *CT_XmlPr) Validate() error

Validate validates the CT_XmlPr and its children

func (*CT_XmlPr) ValidateWithPath ¶ 

func (m *CT_XmlPr) ValidateWithPath(path string) error

ValidateWithPath validates the CT_XmlPr and its children, prefixing error messages with path

type CT_colItems ¶ 

type CT_colItems struct {
	// Column Item Count
	CountAttr *uint32
	// Column Items
	I []*CT_I
}

func NewCT_colItems ¶ 

func NewCT_colItems() *CT_colItems

func (*CT_colItems) MarshalXML ¶ 

func (m *CT_colItems) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_colItems) UnmarshalXML ¶ 

func (m *CT_colItems) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_colItems) Validate ¶ 

func (m *CT_colItems) Validate() error

Validate validates the CT_colItems and its children

func (*CT_colItems) ValidateWithPath ¶ 

func (m *CT_colItems) ValidateWithPath(path string) error

ValidateWithPath validates the CT_colItems and its children, prefixing error messages with path

type CT_pivotTableDefinition ¶ 

type CT_pivotTableDefinition struct {
	// Name
	NameAttr string
	// PivotCache Definition Id
	CacheIdAttr uint32
	// Data On Rows
	DataOnRowsAttr *bool
	// Default Data Field Position
	DataPositionAttr *uint32
	// Data Field Header Name
	DataCaptionAttr string
	// Grand Totals Caption
	GrandTotalCaptionAttr *string
	// Error Caption
	ErrorCaptionAttr *string
	// Show Error
	ShowErrorAttr *bool
	// Caption for Missing Values
	MissingCaptionAttr *string
	// Show Missing
	ShowMissingAttr *bool
	// Page Header Style Name
	PageStyleAttr *string
	// Table Style Name
	PivotTableStyleAttr *string
	// Vacated Style
	VacatedStyleAttr *string
	// PivotTable Custom String
	TagAttr *string
	// PivotTable Last Updated Version
	UpdatedVersionAttr *uint8
	// Minimum Refreshable Version
	MinRefreshableVersionAttr *uint8
	// Asterisk Totals
	AsteriskTotalsAttr *bool
	// Show Item Names
	ShowItemsAttr *bool
	// Allow Edit Data
	EditDataAttr *bool
	// Disable Field List
	DisableFieldListAttr *bool
	// Show Calculated Members
	ShowCalcMbrsAttr *bool
	// Total Visual Data
	VisualTotalsAttr *bool
	// Show Multiple Labels
	ShowMultipleLabelAttr *bool
	// Show Drop Down
	ShowDataDropDownAttr *bool
	// Show Expand Collapse
	ShowDrillAttr *bool
	// Print Drill Indicators
	PrintDrillAttr *bool
	// Show Member Property ToolTips
	ShowMemberPropertyTipsAttr *bool
	// Show ToolTips on Data
	ShowDataTipsAttr *bool
	// Enable PivotTable Wizard
	EnableWizardAttr *bool
	// Enable Drill Down
	EnableDrillAttr *bool
	// Enable Field Properties
	EnableFieldPropertiesAttr *bool
	// Preserve Formatting
	PreserveFormattingAttr *bool
	// Auto Formatting
	UseAutoFormattingAttr *bool
	// Page Wrap
	PageWrapAttr *uint32
	// Page Over Then Down
	PageOverThenDownAttr *bool
	// Subtotal Hidden Items
	SubtotalHiddenItemsAttr *bool
	// Row Grand Totals
	RowGrandTotalsAttr *bool
	// Grand Totals On Columns
	ColGrandTotalsAttr *bool
	// Field Print Titles
	FieldPrintTitlesAttr *bool
	// Item Print Titles
	ItemPrintTitlesAttr *bool
	// Merge Titles
	MergeItemAttr *bool
	// Show Drop Zones
	ShowDropZonesAttr *bool
	// PivotCache Created Version
	CreatedVersionAttr *uint8
	// Indentation for Compact Axis
	IndentAttr *uint32
	// Show Empty Row
	ShowEmptyRowAttr *bool
	// Show Empty Column
	ShowEmptyColAttr *bool
	// Show Field Headers
	ShowHeadersAttr *bool
	// Compact New Fields
	CompactAttr *bool
	// Outline New Fields
	OutlineAttr *bool
	// Outline Data Fields
	OutlineDataAttr *bool
	// Compact Data
	CompactDataAttr *bool
	// Data Fields Published
	PublishedAttr *bool
	// Enable Drop Zones
	GridDropZonesAttr *bool
	// Stop Immersive UI
	ImmersiveAttr *bool
	// Multiple Field Filters
	MultipleFieldFiltersAttr *bool
	// Chart Format Id
	ChartFormatAttr *uint32
	// Row Header Caption
	RowHeaderCaptionAttr *string
	// Column Header Caption
	ColHeaderCaptionAttr *string
	// Default Sort Order
	FieldListSortAscendingAttr *bool
	// MDX Subqueries Supported
	MdxSubqueriesAttr *bool
	// Custom List AutoSort
	CustomListSortAttr *bool
	// PivotTable Location
	Location *CT_Location
	// PivotTable Fields
	PivotFields *CT_PivotFields
	// Row Fields
	RowFields *CT_RowFields
	// Row Items
	RowItems *CT_rowItems
	// Column Fields
	ColFields *CT_ColFields
	// Column Items
	ColItems *CT_colItems
	// Page Field Items
	PageFields *CT_PageFields
	// Data Fields
	DataFields *CT_DataFields
	// PivotTable Formats
	Formats *CT_Formats
	// Conditional Formats
	ConditionalFormats *CT_ConditionalFormats
	// PivotChart Formats
	ChartFormats *CT_ChartFormats
	// PivotTable OLAP Hierarchies
	PivotHierarchies *CT_PivotHierarchies
	// PivotTable Style
	PivotTableStyleInfo *CT_PivotTableStyle
	// Filters
	Filters *CT_PivotFilters
	// Row OLAP Hierarchy References
	RowHierarchiesUsage *CT_RowHierarchiesUsage
	// Column OLAP Hierarchy References
	ColHierarchiesUsage *CT_ColHierarchiesUsage
	// Future Feature Data Storage Area
	ExtLst                      *CT_ExtensionList
	AutoFormatIdAttr            *uint32
	ApplyNumberFormatsAttr      *bool
	ApplyBorderFormatsAttr      *bool
	ApplyFontFormatsAttr        *bool
	ApplyPatternFormatsAttr     *bool
	ApplyAlignmentFormatsAttr   *bool
	ApplyWidthHeightFormatsAttr *bool
}

func NewCT_pivotTableDefinition ¶ 

func NewCT_pivotTableDefinition() *CT_pivotTableDefinition

func (*CT_pivotTableDefinition) MarshalXML ¶ 

func (m *CT_pivotTableDefinition) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_pivotTableDefinition) UnmarshalXML ¶ 

func (m *CT_pivotTableDefinition) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_pivotTableDefinition) Validate ¶ 

func (m *CT_pivotTableDefinition) Validate() error

Validate validates the CT_pivotTableDefinition and its children

func (*CT_pivotTableDefinition) ValidateWithPath ¶ 

func (m *CT_pivotTableDefinition) ValidateWithPath(path string) error

ValidateWithPath validates the CT_pivotTableDefinition and its children, prefixing error messages with path

type CT_rowItems ¶ 

type CT_rowItems struct {
	// Items in a Row Count
	CountAttr *uint32
	// Row Items
	I []*CT_I
}

func NewCT_rowItems ¶ 

func NewCT_rowItems() *CT_rowItems

func (*CT_rowItems) MarshalXML ¶ 

func (m *CT_rowItems) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CT_rowItems) UnmarshalXML ¶ 

func (m *CT_rowItems) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CT_rowItems) Validate ¶ 

func (m *CT_rowItems) Validate() error

Validate validates the CT_rowItems and its children

func (*CT_rowItems) ValidateWithPath ¶ 

func (m *CT_rowItems) ValidateWithPath(path string) error

ValidateWithPath validates the CT_rowItems and its children, prefixing error messages with path

type CalcChain ¶ 

type CalcChain struct {
	CT_CalcChain
}

func NewCalcChain ¶ 

func NewCalcChain() *CalcChain

func (*CalcChain) MarshalXML ¶ 

func (m *CalcChain) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*CalcChain) UnmarshalXML ¶ 

func (m *CalcChain) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*CalcChain) Validate ¶ 

func (m *CalcChain) Validate() error

Validate validates the CalcChain and its children

func (*CalcChain) ValidateWithPath ¶ 

func (m *CalcChain) ValidateWithPath(path string) error

ValidateWithPath validates the CalcChain and its children, prefixing error messages with path

type Chartsheet ¶ 

type Chartsheet struct {
	CT_Chartsheet
}

func NewChartsheet ¶ 

func NewChartsheet() *Chartsheet

func (*Chartsheet) MarshalXML ¶ 

func (m *Chartsheet) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Chartsheet) UnmarshalXML ¶ 

func (m *Chartsheet) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Chartsheet) Validate ¶ 

func (m *Chartsheet) Validate() error

Validate validates the Chartsheet and its children

func (*Chartsheet) ValidateWithPath ¶ 

func (m *Chartsheet) ValidateWithPath(path string) error

ValidateWithPath validates the Chartsheet and its children, prefixing error messages with path

type Comments ¶ 

type Comments struct {
	CT_Comments
}

func NewComments ¶ 

func NewComments() *Comments

func (*Comments) MarshalXML ¶ 

func (m *Comments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Comments) UnmarshalXML ¶ 

func (m *Comments) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Comments) Validate ¶ 

func (m *Comments) Validate() error

Validate validates the Comments and its children

func (*Comments) ValidateWithPath ¶ 

func (m *Comments) ValidateWithPath(path string) error

ValidateWithPath validates the Comments and its children, prefixing error messages with path

type Connections ¶ 

type Connections struct {
	CT_Connections
}

func NewConnections ¶ 

func NewConnections() *Connections

func (*Connections) MarshalXML ¶ 

func (m *Connections) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Connections) UnmarshalXML ¶ 

func (m *Connections) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Connections) Validate ¶ 

func (m *Connections) Validate() error

Validate validates the Connections and its children

func (*Connections) ValidateWithPath ¶ 

func (m *Connections) ValidateWithPath(path string) error

ValidateWithPath validates the Connections and its children, prefixing error messages with path

type Dialogsheet ¶ 

type Dialogsheet struct {
	CT_Dialogsheet
}

func NewDialogsheet ¶ 

func NewDialogsheet() *Dialogsheet

func (*Dialogsheet) MarshalXML ¶ 

func (m *Dialogsheet) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Dialogsheet) UnmarshalXML ¶ 

func (m *Dialogsheet) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Dialogsheet) Validate ¶ 

func (m *Dialogsheet) Validate() error

Validate validates the Dialogsheet and its children

func (*Dialogsheet) ValidateWithPath ¶ 

func (m *Dialogsheet) ValidateWithPath(path string) error

ValidateWithPath validates the Dialogsheet and its children, prefixing error messages with path

type EG_ExtensionList ¶ 

type EG_ExtensionList struct {
	// Extension
	Ext []*CT_Extension
}

func NewEG_ExtensionList ¶ 

func NewEG_ExtensionList() *EG_ExtensionList

func (*EG_ExtensionList) MarshalXML ¶ 

func (m *EG_ExtensionList) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*EG_ExtensionList) UnmarshalXML ¶ 

func (m *EG_ExtensionList) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*EG_ExtensionList) Validate ¶ 

func (m *EG_ExtensionList) Validate() error

Validate validates the EG_ExtensionList and its children

func (*EG_ExtensionList) ValidateWithPath ¶ 

func (m *EG_ExtensionList) ValidateWithPath(path string) error

ValidateWithPath validates the EG_ExtensionList and its children, prefixing error messages with path 

type ExternalLink struct {
	CT_ExternalLink
}
func NewExternalLink() *ExternalLink

func (*ExternalLink) MarshalXML ¶ 

func (m *ExternalLink) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*ExternalLink) UnmarshalXML ¶ 

func (m *ExternalLink) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ExternalLink) Validate ¶ 

func (m *ExternalLink) Validate() error

Validate validates the ExternalLink and its children

func (*ExternalLink) ValidateWithPath ¶ 

func (m *ExternalLink) ValidateWithPath(path string) error

ValidateWithPath validates the ExternalLink and its children, prefixing error messages with path

type Headers ¶ 

type Headers struct {
	CT_RevisionHeaders
}

func NewHeaders ¶ 

func NewHeaders() *Headers

func (*Headers) MarshalXML ¶ 

func (m *Headers) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Headers) UnmarshalXML ¶ 

func (m *Headers) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Headers) Validate ¶ 

func (m *Headers) Validate() error

Validate validates the Headers and its children

func (*Headers) ValidateWithPath ¶ 

func (m *Headers) ValidateWithPath(path string) error

ValidateWithPath validates the Headers and its children, prefixing error messages with path

type MapInfo ¶ 

type MapInfo struct {
	CT_MapInfo
}

func NewMapInfo ¶ 

func NewMapInfo() *MapInfo

func (*MapInfo) MarshalXML ¶ 

func (m *MapInfo) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*MapInfo) UnmarshalXML ¶ 

func (m *MapInfo) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*MapInfo) Validate ¶ 

func (m *MapInfo) Validate() error

Validate validates the MapInfo and its children

func (*MapInfo) ValidateWithPath ¶ 

func (m *MapInfo) ValidateWithPath(path string) error

ValidateWithPath validates the MapInfo and its children, prefixing error messages with path

type Metadata ¶ 

type Metadata struct {
	CT_Metadata
}

func NewMetadata ¶ 

func NewMetadata() *Metadata

func (*Metadata) MarshalXML ¶ 

func (m *Metadata) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Metadata) UnmarshalXML ¶ 

func (m *Metadata) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Metadata) Validate ¶ 

func (m *Metadata) Validate() error

Validate validates the Metadata and its children

func (*Metadata) ValidateWithPath ¶ 

func (m *Metadata) ValidateWithPath(path string) error

ValidateWithPath validates the Metadata and its children, prefixing error messages with path

type PivotCacheDefinition ¶ 

type PivotCacheDefinition struct {
	CT_PivotCacheDefinition
}

func NewPivotCacheDefinition ¶ 

func NewPivotCacheDefinition() *PivotCacheDefinition

func (*PivotCacheDefinition) MarshalXML ¶ 

func (m *PivotCacheDefinition) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*PivotCacheDefinition) UnmarshalXML ¶ 

func (m *PivotCacheDefinition) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*PivotCacheDefinition) Validate ¶ 

func (m *PivotCacheDefinition) Validate() error

Validate validates the PivotCacheDefinition and its children

func (*PivotCacheDefinition) ValidateWithPath ¶ 

func (m *PivotCacheDefinition) ValidateWithPath(path string) error

ValidateWithPath validates the PivotCacheDefinition and its children, prefixing error messages with path

type PivotCacheRecords ¶ 

type PivotCacheRecords struct {
	CT_PivotCacheRecords
}

func NewPivotCacheRecords ¶ 

func NewPivotCacheRecords() *PivotCacheRecords

func (*PivotCacheRecords) MarshalXML ¶ 

func (m *PivotCacheRecords) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*PivotCacheRecords) UnmarshalXML ¶ 

func (m *PivotCacheRecords) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*PivotCacheRecords) Validate ¶ 

func (m *PivotCacheRecords) Validate() error

Validate validates the PivotCacheRecords and its children

func (*PivotCacheRecords) ValidateWithPath ¶ 

func (m *PivotCacheRecords) ValidateWithPath(path string) error

ValidateWithPath validates the PivotCacheRecords and its children, prefixing error messages with path

type PivotTableDefinition ¶ 

type PivotTableDefinition struct {
	CT_pivotTableDefinition
}

func NewPivotTableDefinition ¶ 

func NewPivotTableDefinition() *PivotTableDefinition

func (*PivotTableDefinition) MarshalXML ¶ 

func (m *PivotTableDefinition) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*PivotTableDefinition) UnmarshalXML ¶ 

func (m *PivotTableDefinition) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*PivotTableDefinition) Validate ¶ 

func (m *PivotTableDefinition) Validate() error

Validate validates the PivotTableDefinition and its children

func (*PivotTableDefinition) ValidateWithPath ¶ 

func (m *PivotTableDefinition) ValidateWithPath(path string) error

ValidateWithPath validates the PivotTableDefinition and its children, prefixing error messages with path

type QueryTable ¶ 

type QueryTable struct {
	CT_QueryTable
}

func NewQueryTable ¶ 

func NewQueryTable() *QueryTable

func (*QueryTable) MarshalXML ¶ 

func (m *QueryTable) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*QueryTable) UnmarshalXML ¶ 

func (m *QueryTable) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*QueryTable) Validate ¶ 

func (m *QueryTable) Validate() error

Validate validates the QueryTable and its children

func (*QueryTable) ValidateWithPath ¶ 

func (m *QueryTable) ValidateWithPath(path string) error

ValidateWithPath validates the QueryTable and its children, prefixing error messages with path

type Revisions ¶ 

type Revisions struct {
	CT_Revisions
}

func NewRevisions ¶ 

func NewRevisions() *Revisions

func (*Revisions) MarshalXML ¶ 

func (m *Revisions) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Revisions) UnmarshalXML ¶ 

func (m *Revisions) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Revisions) Validate ¶ 

func (m *Revisions) Validate() error

Validate validates the Revisions and its children

func (*Revisions) ValidateWithPath ¶ 

func (m *Revisions) ValidateWithPath(path string) error

ValidateWithPath validates the Revisions and its children, prefixing error messages with path

type ST_Axis ¶ 

type ST_Axis byte
const (
	ST_AxisUnset      ST_Axis = 0
	ST_AxisAxisRow    ST_Axis = 1
	ST_AxisAxisCol    ST_Axis = 2
	ST_AxisAxisPage   ST_Axis = 3
	ST_AxisAxisValues ST_Axis = 4
)

func (ST_Axis) MarshalXML ¶ 

func (m ST_Axis) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Axis) MarshalXMLAttr ¶ 

func (e ST_Axis) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Axis) String ¶ 

func (m ST_Axis) String() string

func (*ST_Axis) UnmarshalXML ¶ 

func (m *ST_Axis) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Axis) UnmarshalXMLAttr ¶ 

func (e *ST_Axis) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Axis) Validate ¶ 

func (m ST_Axis) Validate() error

func (ST_Axis) ValidateWithPath ¶ 

func (m ST_Axis) ValidateWithPath(path string) error

type ST_BorderStyle ¶ 

type ST_BorderStyle byte
const (
	ST_BorderStyleUnset            ST_BorderStyle = 0
	ST_BorderStyleNone             ST_BorderStyle = 1
	ST_BorderStyleThin             ST_BorderStyle = 2
	ST_BorderStyleMedium           ST_BorderStyle = 3
	ST_BorderStyleDashed           ST_BorderStyle = 4
	ST_BorderStyleDotted           ST_BorderStyle = 5
	ST_BorderStyleThick            ST_BorderStyle = 6
	ST_BorderStyleDouble           ST_BorderStyle = 7
	ST_BorderStyleHair             ST_BorderStyle = 8
	ST_BorderStyleMediumDashed     ST_BorderStyle = 9
	ST_BorderStyleDashDot          ST_BorderStyle = 10
	ST_BorderStyleMediumDashDot    ST_BorderStyle = 11
	ST_BorderStyleDashDotDot       ST_BorderStyle = 12
	ST_BorderStyleMediumDashDotDot ST_BorderStyle = 13
	ST_BorderStyleSlantDashDot     ST_BorderStyle = 14
)

func (ST_BorderStyle) MarshalXML ¶ 

func (m ST_BorderStyle) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_BorderStyle) MarshalXMLAttr ¶ 

func (e ST_BorderStyle) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_BorderStyle) String ¶ 

func (m ST_BorderStyle) String() string

func (*ST_BorderStyle) UnmarshalXML ¶ 

func (m *ST_BorderStyle) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_BorderStyle) UnmarshalXMLAttr ¶ 

func (e *ST_BorderStyle) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_BorderStyle) Validate ¶ 

func (m ST_BorderStyle) Validate() error

func (ST_BorderStyle) ValidateWithPath ¶ 

func (m ST_BorderStyle) ValidateWithPath(path string) error

type ST_CalcMode ¶ 

type ST_CalcMode byte
const (
	ST_CalcModeUnset       ST_CalcMode = 0
	ST_CalcModeManual      ST_CalcMode = 1
	ST_CalcModeAuto        ST_CalcMode = 2
	ST_CalcModeAutoNoTable ST_CalcMode = 3
)

func (ST_CalcMode) MarshalXML ¶ 

func (m ST_CalcMode) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_CalcMode) MarshalXMLAttr ¶ 

func (e ST_CalcMode) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_CalcMode) String ¶ 

func (m ST_CalcMode) String() string

func (*ST_CalcMode) UnmarshalXML ¶ 

func (m *ST_CalcMode) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_CalcMode) UnmarshalXMLAttr ¶ 

func (e *ST_CalcMode) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_CalcMode) Validate ¶ 

func (m ST_CalcMode) Validate() error

func (ST_CalcMode) ValidateWithPath ¶ 

func (m ST_CalcMode) ValidateWithPath(path string) error

type ST_CellComments ¶ 

type ST_CellComments byte
const (
	ST_CellCommentsUnset       ST_CellComments = 0
	ST_CellCommentsNone        ST_CellComments = 1
	ST_CellCommentsAsDisplayed ST_CellComments = 2
	ST_CellCommentsAtEnd       ST_CellComments = 3
)

func (ST_CellComments) MarshalXML ¶ 

func (m ST_CellComments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_CellComments) MarshalXMLAttr ¶ 

func (e ST_CellComments) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_CellComments) String ¶ 

func (m ST_CellComments) String() string

func (*ST_CellComments) UnmarshalXML ¶ 

func (m *ST_CellComments) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_CellComments) UnmarshalXMLAttr ¶ 

func (e *ST_CellComments) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_CellComments) Validate ¶ 

func (m ST_CellComments) Validate() error

func (ST_CellComments) ValidateWithPath ¶ 

func (m ST_CellComments) ValidateWithPath(path string) error

type ST_CellFormulaType ¶ 

type ST_CellFormulaType byte
const (
	ST_CellFormulaTypeUnset     ST_CellFormulaType = 0
	ST_CellFormulaTypeNormal    ST_CellFormulaType = 1
	ST_CellFormulaTypeArray     ST_CellFormulaType = 2
	ST_CellFormulaTypeDataTable ST_CellFormulaType = 3
	ST_CellFormulaTypeShared    ST_CellFormulaType = 4
)

func (ST_CellFormulaType) MarshalXML ¶ 

func (m ST_CellFormulaType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_CellFormulaType) MarshalXMLAttr ¶ 

func (e ST_CellFormulaType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_CellFormulaType) String ¶ 

func (m ST_CellFormulaType) String() string

func (*ST_CellFormulaType) UnmarshalXML ¶ 

func (m *ST_CellFormulaType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_CellFormulaType) UnmarshalXMLAttr ¶ 

func (e *ST_CellFormulaType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_CellFormulaType) Validate ¶ 

func (m ST_CellFormulaType) Validate() error

func (ST_CellFormulaType) ValidateWithPath ¶ 

func (m ST_CellFormulaType) ValidateWithPath(path string) error

type ST_CellSpans ¶ 

type ST_CellSpans []string

func ParseSliceST_CellSpans ¶ 

func ParseSliceST_CellSpans(s string) (ST_CellSpans, error)

func (ST_CellSpans) String ¶ 

func (s ST_CellSpans) String() string

type ST_CellType ¶ 

type ST_CellType byte
const (
	ST_CellTypeUnset     ST_CellType = 0
	ST_CellTypeB         ST_CellType = 1
	ST_CellTypeN         ST_CellType = 2
	ST_CellTypeE         ST_CellType = 3
	ST_CellTypeS         ST_CellType = 4
	ST_CellTypeStr       ST_CellType = 5
	ST_CellTypeInlineStr ST_CellType = 6
)

func (ST_CellType) MarshalXML ¶ 

func (m ST_CellType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_CellType) MarshalXMLAttr ¶ 

func (e ST_CellType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_CellType) String ¶ 

func (m ST_CellType) String() string

func (*ST_CellType) UnmarshalXML ¶ 

func (m *ST_CellType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_CellType) UnmarshalXMLAttr ¶ 

func (e *ST_CellType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_CellType) Validate ¶ 

func (m ST_CellType) Validate() error

func (ST_CellType) ValidateWithPath ¶ 

func (m ST_CellType) ValidateWithPath(path string) error

type ST_CfType ¶ 

type ST_CfType byte
const (
	ST_CfTypeUnset             ST_CfType = 0
	ST_CfTypeExpression        ST_CfType = 1
	ST_CfTypeCellIs            ST_CfType = 2
	ST_CfTypeColorScale        ST_CfType = 3
	ST_CfTypeDataBar           ST_CfType = 4
	ST_CfTypeIconSet           ST_CfType = 5
	ST_CfTypeTop10             ST_CfType = 6
	ST_CfTypeUniqueValues      ST_CfType = 7
	ST_CfTypeDuplicateValues   ST_CfType = 8
	ST_CfTypeContainsText      ST_CfType = 9
	ST_CfTypeNotContainsText   ST_CfType = 10
	ST_CfTypeBeginsWith        ST_CfType = 11
	ST_CfTypeEndsWith          ST_CfType = 12
	ST_CfTypeContainsBlanks    ST_CfType = 13
	ST_CfTypeNotContainsBlanks ST_CfType = 14
	ST_CfTypeContainsErrors    ST_CfType = 15
	ST_CfTypeNotContainsErrors ST_CfType = 16
	ST_CfTypeTimePeriod        ST_CfType = 17
	ST_CfTypeAboveAverage      ST_CfType = 18
)

func (ST_CfType) MarshalXML ¶ 

func (m ST_CfType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_CfType) MarshalXMLAttr ¶ 

func (e ST_CfType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_CfType) String ¶ 

func (m ST_CfType) String() string

func (*ST_CfType) UnmarshalXML ¶ 

func (m *ST_CfType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_CfType) UnmarshalXMLAttr ¶ 

func (e *ST_CfType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_CfType) Validate ¶ 

func (m ST_CfType) Validate() error

func (ST_CfType) ValidateWithPath ¶ 

func (m ST_CfType) ValidateWithPath(path string) error

type ST_CfvoType ¶ 

type ST_CfvoType byte
const (
	ST_CfvoTypeUnset      ST_CfvoType = 0
	ST_CfvoTypeNum        ST_CfvoType = 1
	ST_CfvoTypePercent    ST_CfvoType = 2
	ST_CfvoTypeMax        ST_CfvoType = 3
	ST_CfvoTypeMin        ST_CfvoType = 4
	ST_CfvoTypeFormula    ST_CfvoType = 5
	ST_CfvoTypePercentile ST_CfvoType = 6
)

func (ST_CfvoType) MarshalXML ¶ 

func (m ST_CfvoType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_CfvoType) MarshalXMLAttr ¶ 

func (e ST_CfvoType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_CfvoType) String ¶ 

func (m ST_CfvoType) String() string

func (*ST_CfvoType) UnmarshalXML ¶ 

func (m *ST_CfvoType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_CfvoType) UnmarshalXMLAttr ¶ 

func (e *ST_CfvoType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_CfvoType) Validate ¶ 

func (m ST_CfvoType) Validate() error

func (ST_CfvoType) ValidateWithPath ¶ 

func (m ST_CfvoType) ValidateWithPath(path string) error

type ST_Comments ¶ 

type ST_Comments byte
const (
	ST_CommentsUnset             ST_Comments = 0
	ST_CommentsCommNone          ST_Comments = 1
	ST_CommentsCommIndicator     ST_Comments = 2
	ST_CommentsCommIndAndComment ST_Comments = 3
)

func (ST_Comments) MarshalXML ¶ 

func (m ST_Comments) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Comments) MarshalXMLAttr ¶ 

func (e ST_Comments) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Comments) String ¶ 

func (m ST_Comments) String() string

func (*ST_Comments) UnmarshalXML ¶ 

func (m *ST_Comments) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Comments) UnmarshalXMLAttr ¶ 

func (e *ST_Comments) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Comments) Validate ¶ 

func (m ST_Comments) Validate() error

func (ST_Comments) ValidateWithPath ¶ 

func (m ST_Comments) ValidateWithPath(path string) error

type ST_ConditionalFormattingOperator ¶ 

type ST_ConditionalFormattingOperator byte
const (
	ST_ConditionalFormattingOperatorUnset              ST_ConditionalFormattingOperator = 0
	ST_ConditionalFormattingOperatorLessThan           ST_ConditionalFormattingOperator = 1
	ST_ConditionalFormattingOperatorLessThanOrEqual    ST_ConditionalFormattingOperator = 2
	ST_ConditionalFormattingOperatorEqual              ST_ConditionalFormattingOperator = 3
	ST_ConditionalFormattingOperatorNotEqual           ST_ConditionalFormattingOperator = 4
	ST_ConditionalFormattingOperatorGreaterThanOrEqual ST_ConditionalFormattingOperator = 5
	ST_ConditionalFormattingOperatorGreaterThan        ST_ConditionalFormattingOperator = 6
	ST_ConditionalFormattingOperatorBetween            ST_ConditionalFormattingOperator = 7
	ST_ConditionalFormattingOperatorNotBetween         ST_ConditionalFormattingOperator = 8
	ST_ConditionalFormattingOperatorContainsText       ST_ConditionalFormattingOperator = 9
	ST_ConditionalFormattingOperatorNotContains        ST_ConditionalFormattingOperator = 10
	ST_ConditionalFormattingOperatorBeginsWith         ST_ConditionalFormattingOperator = 11
	ST_ConditionalFormattingOperatorEndsWith           ST_ConditionalFormattingOperator = 12
)

func (ST_ConditionalFormattingOperator) MarshalXML ¶ 

func (m ST_ConditionalFormattingOperator) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_ConditionalFormattingOperator) MarshalXMLAttr ¶ 

func (e ST_ConditionalFormattingOperator) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_ConditionalFormattingOperator) String ¶ 

func (m ST_ConditionalFormattingOperator) String() string

func (*ST_ConditionalFormattingOperator) UnmarshalXML ¶ 

func (m *ST_ConditionalFormattingOperator) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_ConditionalFormattingOperator) UnmarshalXMLAttr ¶ 

func (e *ST_ConditionalFormattingOperator) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_ConditionalFormattingOperator) Validate ¶ 

func (m ST_ConditionalFormattingOperator) Validate() error

func (ST_ConditionalFormattingOperator) ValidateWithPath ¶ 

func (m ST_ConditionalFormattingOperator) ValidateWithPath(path string) error

type ST_CredMethod ¶ 

type ST_CredMethod byte
const (
	ST_CredMethodUnset      ST_CredMethod = 0
	ST_CredMethodIntegrated ST_CredMethod = 1
	ST_CredMethodNone       ST_CredMethod = 2
	ST_CredMethodStored     ST_CredMethod = 3
	ST_CredMethodPrompt     ST_CredMethod = 4
)

func (ST_CredMethod) MarshalXML ¶ 

func (m ST_CredMethod) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_CredMethod) MarshalXMLAttr ¶ 

func (e ST_CredMethod) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_CredMethod) String ¶ 

func (m ST_CredMethod) String() string

func (*ST_CredMethod) UnmarshalXML ¶ 

func (m *ST_CredMethod) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_CredMethod) UnmarshalXMLAttr ¶ 

func (e *ST_CredMethod) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_CredMethod) Validate ¶ 

func (m ST_CredMethod) Validate() error

func (ST_CredMethod) ValidateWithPath ¶ 

func (m ST_CredMethod) ValidateWithPath(path string) error

type ST_DataConsolidateFunction ¶ 

type ST_DataConsolidateFunction byte
const (
	ST_DataConsolidateFunctionUnset     ST_DataConsolidateFunction = 0
	ST_DataConsolidateFunctionAverage   ST_DataConsolidateFunction = 1
	ST_DataConsolidateFunctionCount     ST_DataConsolidateFunction = 2
	ST_DataConsolidateFunctionCountNums ST_DataConsolidateFunction = 3
	ST_DataConsolidateFunctionMax       ST_DataConsolidateFunction = 4
	ST_DataConsolidateFunctionMin       ST_DataConsolidateFunction = 5
	ST_DataConsolidateFunctionProduct   ST_DataConsolidateFunction = 6
	ST_DataConsolidateFunctionStdDev    ST_DataConsolidateFunction = 7
	ST_DataConsolidateFunctionStdDevp   ST_DataConsolidateFunction = 8
	ST_DataConsolidateFunctionSum       ST_DataConsolidateFunction = 9
	ST_DataConsolidateFunctionVar       ST_DataConsolidateFunction = 10
	ST_DataConsolidateFunctionVarp      ST_DataConsolidateFunction = 11
)

func (ST_DataConsolidateFunction) MarshalXML ¶ 

func (m ST_DataConsolidateFunction) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DataConsolidateFunction) MarshalXMLAttr ¶ 

func (e ST_DataConsolidateFunction) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_DataConsolidateFunction) String ¶ 

func (m ST_DataConsolidateFunction) String() string

func (*ST_DataConsolidateFunction) UnmarshalXML ¶ 

func (m *ST_DataConsolidateFunction) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_DataConsolidateFunction) UnmarshalXMLAttr ¶ 

func (e *ST_DataConsolidateFunction) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_DataConsolidateFunction) Validate ¶ 

func (m ST_DataConsolidateFunction) Validate() error

func (ST_DataConsolidateFunction) ValidateWithPath ¶ 

func (m ST_DataConsolidateFunction) ValidateWithPath(path string) error

type ST_DataValidationErrorStyle ¶ 

type ST_DataValidationErrorStyle byte
const (
	ST_DataValidationErrorStyleUnset       ST_DataValidationErrorStyle = 0
	ST_DataValidationErrorStyleStop        ST_DataValidationErrorStyle = 1
	ST_DataValidationErrorStyleWarning     ST_DataValidationErrorStyle = 2
	ST_DataValidationErrorStyleInformation ST_DataValidationErrorStyle = 3
)

func (ST_DataValidationErrorStyle) MarshalXML ¶ 

func (m ST_DataValidationErrorStyle) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DataValidationErrorStyle) MarshalXMLAttr ¶ 

func (e ST_DataValidationErrorStyle) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_DataValidationErrorStyle) String ¶ 

func (m ST_DataValidationErrorStyle) String() string

func (*ST_DataValidationErrorStyle) UnmarshalXML ¶ 

func (m *ST_DataValidationErrorStyle) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_DataValidationErrorStyle) UnmarshalXMLAttr ¶ 

func (e *ST_DataValidationErrorStyle) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_DataValidationErrorStyle) Validate ¶ 

func (m ST_DataValidationErrorStyle) Validate() error

func (ST_DataValidationErrorStyle) ValidateWithPath ¶ 

func (m ST_DataValidationErrorStyle) ValidateWithPath(path string) error

type ST_DataValidationImeMode ¶ 

type ST_DataValidationImeMode byte
const (
	ST_DataValidationImeModeUnset        ST_DataValidationImeMode = 0
	ST_DataValidationImeModeNoControl    ST_DataValidationImeMode = 1
	ST_DataValidationImeModeOff          ST_DataValidationImeMode = 2
	ST_DataValidationImeModeOn           ST_DataValidationImeMode = 3
	ST_DataValidationImeModeDisabled     ST_DataValidationImeMode = 4
	ST_DataValidationImeModeHiragana     ST_DataValidationImeMode = 5
	ST_DataValidationImeModeFullKatakana ST_DataValidationImeMode = 6
	ST_DataValidationImeModeHalfKatakana ST_DataValidationImeMode = 7
	ST_DataValidationImeModeFullAlpha    ST_DataValidationImeMode = 8
	ST_DataValidationImeModeHalfAlpha    ST_DataValidationImeMode = 9
	ST_DataValidationImeModeFullHangul   ST_DataValidationImeMode = 10
	ST_DataValidationImeModeHalfHangul   ST_DataValidationImeMode = 11
)

func (ST_DataValidationImeMode) MarshalXML ¶ 

func (m ST_DataValidationImeMode) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DataValidationImeMode) MarshalXMLAttr ¶ 

func (e ST_DataValidationImeMode) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_DataValidationImeMode) String ¶ 

func (m ST_DataValidationImeMode) String() string

func (*ST_DataValidationImeMode) UnmarshalXML ¶ 

func (m *ST_DataValidationImeMode) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_DataValidationImeMode) UnmarshalXMLAttr ¶ 

func (e *ST_DataValidationImeMode) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_DataValidationImeMode) Validate ¶ 

func (m ST_DataValidationImeMode) Validate() error

func (ST_DataValidationImeMode) ValidateWithPath ¶ 

func (m ST_DataValidationImeMode) ValidateWithPath(path string) error

type ST_DataValidationOperator ¶ 

type ST_DataValidationOperator byte
const (
	ST_DataValidationOperatorUnset              ST_DataValidationOperator = 0
	ST_DataValidationOperatorBetween            ST_DataValidationOperator = 1
	ST_DataValidationOperatorNotBetween         ST_DataValidationOperator = 2
	ST_DataValidationOperatorEqual              ST_DataValidationOperator = 3
	ST_DataValidationOperatorNotEqual           ST_DataValidationOperator = 4
	ST_DataValidationOperatorLessThan           ST_DataValidationOperator = 5
	ST_DataValidationOperatorLessThanOrEqual    ST_DataValidationOperator = 6
	ST_DataValidationOperatorGreaterThan        ST_DataValidationOperator = 7
	ST_DataValidationOperatorGreaterThanOrEqual ST_DataValidationOperator = 8
)

func (ST_DataValidationOperator) MarshalXML ¶ 

func (m ST_DataValidationOperator) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DataValidationOperator) MarshalXMLAttr ¶ 

func (e ST_DataValidationOperator) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_DataValidationOperator) String ¶ 

func (m ST_DataValidationOperator) String() string

func (*ST_DataValidationOperator) UnmarshalXML ¶ 

func (m *ST_DataValidationOperator) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_DataValidationOperator) UnmarshalXMLAttr ¶ 

func (e *ST_DataValidationOperator) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_DataValidationOperator) Validate ¶ 

func (m ST_DataValidationOperator) Validate() error

func (ST_DataValidationOperator) ValidateWithPath ¶ 

func (m ST_DataValidationOperator) ValidateWithPath(path string) error

type ST_DataValidationType ¶ 

type ST_DataValidationType byte
const (
	ST_DataValidationTypeUnset      ST_DataValidationType = 0
	ST_DataValidationTypeNone       ST_DataValidationType = 1
	ST_DataValidationTypeWhole      ST_DataValidationType = 2
	ST_DataValidationTypeDecimal    ST_DataValidationType = 3
	ST_DataValidationTypeList       ST_DataValidationType = 4
	ST_DataValidationTypeDate       ST_DataValidationType = 5
	ST_DataValidationTypeTime       ST_DataValidationType = 6
	ST_DataValidationTypeTextLength ST_DataValidationType = 7
	ST_DataValidationTypeCustom     ST_DataValidationType = 8
)

func (ST_DataValidationType) MarshalXML ¶ 

func (m ST_DataValidationType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DataValidationType) MarshalXMLAttr ¶ 

func (e ST_DataValidationType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_DataValidationType) String ¶ 

func (m ST_DataValidationType) String() string

func (*ST_DataValidationType) UnmarshalXML ¶ 

func (m *ST_DataValidationType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_DataValidationType) UnmarshalXMLAttr ¶ 

func (e *ST_DataValidationType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_DataValidationType) Validate ¶ 

func (m ST_DataValidationType) Validate() error

func (ST_DataValidationType) ValidateWithPath ¶ 

func (m ST_DataValidationType) ValidateWithPath(path string) error

type ST_DateTimeGrouping ¶ 

type ST_DateTimeGrouping byte
const (
	ST_DateTimeGroupingUnset  ST_DateTimeGrouping = 0
	ST_DateTimeGroupingYear   ST_DateTimeGrouping = 1
	ST_DateTimeGroupingMonth  ST_DateTimeGrouping = 2
	ST_DateTimeGroupingDay    ST_DateTimeGrouping = 3
	ST_DateTimeGroupingHour   ST_DateTimeGrouping = 4
	ST_DateTimeGroupingMinute ST_DateTimeGrouping = 5
	ST_DateTimeGroupingSecond ST_DateTimeGrouping = 6
)

func (ST_DateTimeGrouping) MarshalXML ¶ 

func (m ST_DateTimeGrouping) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DateTimeGrouping) MarshalXMLAttr ¶ 

func (e ST_DateTimeGrouping) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_DateTimeGrouping) String ¶ 

func (m ST_DateTimeGrouping) String() string

func (*ST_DateTimeGrouping) UnmarshalXML ¶ 

func (m *ST_DateTimeGrouping) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_DateTimeGrouping) UnmarshalXMLAttr ¶ 

func (e *ST_DateTimeGrouping) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_DateTimeGrouping) Validate ¶ 

func (m ST_DateTimeGrouping) Validate() error

func (ST_DateTimeGrouping) ValidateWithPath ¶ 

func (m ST_DateTimeGrouping) ValidateWithPath(path string) error

type ST_DdeValueType ¶ 

type ST_DdeValueType byte
const (
	ST_DdeValueTypeUnset ST_DdeValueType = 0
	ST_DdeValueTypeNil   ST_DdeValueType = 1
	ST_DdeValueTypeB     ST_DdeValueType = 2
	ST_DdeValueTypeN     ST_DdeValueType = 3
	ST_DdeValueTypeE     ST_DdeValueType = 4
	ST_DdeValueTypeStr   ST_DdeValueType = 5
)

func (ST_DdeValueType) MarshalXML ¶ 

func (m ST_DdeValueType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DdeValueType) MarshalXMLAttr ¶ 

func (e ST_DdeValueType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_DdeValueType) String ¶ 

func (m ST_DdeValueType) String() string

func (*ST_DdeValueType) UnmarshalXML ¶ 

func (m *ST_DdeValueType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_DdeValueType) UnmarshalXMLAttr ¶ 

func (e *ST_DdeValueType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_DdeValueType) Validate ¶ 

func (m ST_DdeValueType) Validate() error

func (ST_DdeValueType) ValidateWithPath ¶ 

func (m ST_DdeValueType) ValidateWithPath(path string) error

type ST_DvAspect ¶ 

type ST_DvAspect byte
const (
	ST_DvAspectUnset            ST_DvAspect = 0
	ST_DvAspectDVASPECT_CONTENT ST_DvAspect = 1
	ST_DvAspectDVASPECT_ICON    ST_DvAspect = 2
)

func (ST_DvAspect) MarshalXML ¶ 

func (m ST_DvAspect) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DvAspect) MarshalXMLAttr ¶ 

func (e ST_DvAspect) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_DvAspect) String ¶ 

func (m ST_DvAspect) String() string

func (*ST_DvAspect) UnmarshalXML ¶ 

func (m *ST_DvAspect) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_DvAspect) UnmarshalXMLAttr ¶ 

func (e *ST_DvAspect) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_DvAspect) Validate ¶ 

func (m ST_DvAspect) Validate() error

func (ST_DvAspect) ValidateWithPath ¶ 

func (m ST_DvAspect) ValidateWithPath(path string) error

type ST_DynamicFilterType ¶ 

type ST_DynamicFilterType byte
const (
	ST_DynamicFilterTypeUnset        ST_DynamicFilterType = 0
	ST_DynamicFilterTypeNull         ST_DynamicFilterType = 1
	ST_DynamicFilterTypeAboveAverage ST_DynamicFilterType = 2
	ST_DynamicFilterTypeBelowAverage ST_DynamicFilterType = 3
	ST_DynamicFilterTypeTomorrow     ST_DynamicFilterType = 4
	ST_DynamicFilterTypeToday        ST_DynamicFilterType = 5
	ST_DynamicFilterTypeYesterday    ST_DynamicFilterType = 6
	ST_DynamicFilterTypeNextWeek     ST_DynamicFilterType = 7
	ST_DynamicFilterTypeThisWeek     ST_DynamicFilterType = 8
	ST_DynamicFilterTypeLastWeek     ST_DynamicFilterType = 9
	ST_DynamicFilterTypeNextMonth    ST_DynamicFilterType = 10
	ST_DynamicFilterTypeThisMonth    ST_DynamicFilterType = 11
	ST_DynamicFilterTypeLastMonth    ST_DynamicFilterType = 12
	ST_DynamicFilterTypeNextQuarter  ST_DynamicFilterType = 13
	ST_DynamicFilterTypeThisQuarter  ST_DynamicFilterType = 14
	ST_DynamicFilterTypeLastQuarter  ST_DynamicFilterType = 15
	ST_DynamicFilterTypeNextYear     ST_DynamicFilterType = 16
	ST_DynamicFilterTypeThisYear     ST_DynamicFilterType = 17
	ST_DynamicFilterTypeLastYear     ST_DynamicFilterType = 18
	ST_DynamicFilterTypeYearToDate   ST_DynamicFilterType = 19
	ST_DynamicFilterTypeQ1           ST_DynamicFilterType = 20
	ST_DynamicFilterTypeQ2           ST_DynamicFilterType = 21
	ST_DynamicFilterTypeQ3           ST_DynamicFilterType = 22
	ST_DynamicFilterTypeQ4           ST_DynamicFilterType = 23
	ST_DynamicFilterTypeM1           ST_DynamicFilterType = 24
	ST_DynamicFilterTypeM2           ST_DynamicFilterType = 25
	ST_DynamicFilterTypeM3           ST_DynamicFilterType = 26
	ST_DynamicFilterTypeM4           ST_DynamicFilterType = 27
	ST_DynamicFilterTypeM5           ST_DynamicFilterType = 28
	ST_DynamicFilterTypeM6           ST_DynamicFilterType = 29
	ST_DynamicFilterTypeM7           ST_DynamicFilterType = 30
	ST_DynamicFilterTypeM8           ST_DynamicFilterType = 31
	ST_DynamicFilterTypeM9           ST_DynamicFilterType = 32
	ST_DynamicFilterTypeM10          ST_DynamicFilterType = 33
	ST_DynamicFilterTypeM11          ST_DynamicFilterType = 34
	ST_DynamicFilterTypeM12          ST_DynamicFilterType = 35
)

func (ST_DynamicFilterType) MarshalXML ¶ 

func (m ST_DynamicFilterType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_DynamicFilterType) MarshalXMLAttr ¶ 

func (e ST_DynamicFilterType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_DynamicFilterType) String ¶ 

func (m ST_DynamicFilterType) String() string

func (*ST_DynamicFilterType) UnmarshalXML ¶ 

func (m *ST_DynamicFilterType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_DynamicFilterType) UnmarshalXMLAttr ¶ 

func (e *ST_DynamicFilterType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_DynamicFilterType) Validate ¶ 

func (m ST_DynamicFilterType) Validate() error

func (ST_DynamicFilterType) ValidateWithPath ¶ 

func (m ST_DynamicFilterType) ValidateWithPath(path string) error

type ST_ExternalConnectionType ¶ 

type ST_ExternalConnectionType byte
const (
	ST_ExternalConnectionTypeUnset   ST_ExternalConnectionType = 0
	ST_ExternalConnectionTypeGeneral ST_ExternalConnectionType = 1
	ST_ExternalConnectionTypeText    ST_ExternalConnectionType = 2
	ST_ExternalConnectionTypeMDY     ST_ExternalConnectionType = 3
	ST_ExternalConnectionTypeDMY     ST_ExternalConnectionType = 4
	ST_ExternalConnectionTypeYMD     ST_ExternalConnectionType = 5
	ST_ExternalConnectionTypeMYD     ST_ExternalConnectionType = 6
	ST_ExternalConnectionTypeDYM     ST_ExternalConnectionType = 7
	ST_ExternalConnectionTypeYDM     ST_ExternalConnectionType = 8
	ST_ExternalConnectionTypeSkip    ST_ExternalConnectionType = 9
	ST_ExternalConnectionTypeEMD     ST_ExternalConnectionType = 10
)

func (ST_ExternalConnectionType) MarshalXML ¶ 

func (m ST_ExternalConnectionType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_ExternalConnectionType) MarshalXMLAttr ¶ 

func (e ST_ExternalConnectionType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_ExternalConnectionType) String ¶ 

func (m ST_ExternalConnectionType) String() string

func (*ST_ExternalConnectionType) UnmarshalXML ¶ 

func (m *ST_ExternalConnectionType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_ExternalConnectionType) UnmarshalXMLAttr ¶ 

func (e *ST_ExternalConnectionType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_ExternalConnectionType) Validate ¶ 

func (m ST_ExternalConnectionType) Validate() error

func (ST_ExternalConnectionType) ValidateWithPath ¶ 

func (m ST_ExternalConnectionType) ValidateWithPath(path string) error

type ST_FieldSortType ¶ 

type ST_FieldSortType byte
const (
	ST_FieldSortTypeUnset      ST_FieldSortType = 0
	ST_FieldSortTypeManual     ST_FieldSortType = 1
	ST_FieldSortTypeAscending  ST_FieldSortType = 2
	ST_FieldSortTypeDescending ST_FieldSortType = 3
)

func (ST_FieldSortType) MarshalXML ¶ 

func (m ST_FieldSortType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_FieldSortType) MarshalXMLAttr ¶ 

func (e ST_FieldSortType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_FieldSortType) String ¶ 

func (m ST_FieldSortType) String() string

func (*ST_FieldSortType) UnmarshalXML ¶ 

func (m *ST_FieldSortType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_FieldSortType) UnmarshalXMLAttr ¶ 

func (e *ST_FieldSortType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_FieldSortType) Validate ¶ 

func (m ST_FieldSortType) Validate() error

func (ST_FieldSortType) ValidateWithPath ¶ 

func (m ST_FieldSortType) ValidateWithPath(path string) error

type ST_FileType ¶ 

type ST_FileType byte
const (
	ST_FileTypeUnset ST_FileType = 0
	ST_FileTypeMac   ST_FileType = 1
	ST_FileTypeWin   ST_FileType = 2
	ST_FileTypeDos   ST_FileType = 3
	ST_FileTypeLin   ST_FileType = 4
	ST_FileTypeOther ST_FileType = 5
)

func (ST_FileType) MarshalXML ¶ 

func (m ST_FileType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_FileType) MarshalXMLAttr ¶ 

func (e ST_FileType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_FileType) String ¶ 

func (m ST_FileType) String() string

func (*ST_FileType) UnmarshalXML ¶ 

func (m *ST_FileType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_FileType) UnmarshalXMLAttr ¶ 

func (e *ST_FileType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_FileType) Validate ¶ 

func (m ST_FileType) Validate() error

func (ST_FileType) ValidateWithPath ¶ 

func (m ST_FileType) ValidateWithPath(path string) error

type ST_FilterOperator ¶ 

type ST_FilterOperator byte
const (
	ST_FilterOperatorUnset              ST_FilterOperator = 0
	ST_FilterOperatorEqual              ST_FilterOperator = 1
	ST_FilterOperatorLessThan           ST_FilterOperator = 2
	ST_FilterOperatorLessThanOrEqual    ST_FilterOperator = 3
	ST_FilterOperatorNotEqual           ST_FilterOperator = 4
	ST_FilterOperatorGreaterThanOrEqual ST_FilterOperator = 5
	ST_FilterOperatorGreaterThan        ST_FilterOperator = 6
)

func (ST_FilterOperator) MarshalXML ¶ 

func (m ST_FilterOperator) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_FilterOperator) MarshalXMLAttr ¶ 

func (e ST_FilterOperator) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_FilterOperator) String ¶ 

func (m ST_FilterOperator) String() string

func (*ST_FilterOperator) UnmarshalXML ¶ 

func (m *ST_FilterOperator) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_FilterOperator) UnmarshalXMLAttr ¶ 

func (e *ST_FilterOperator) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_FilterOperator) Validate ¶ 

func (m ST_FilterOperator) Validate() error

func (ST_FilterOperator) ValidateWithPath ¶ 

func (m ST_FilterOperator) ValidateWithPath(path string) error

type ST_FontScheme ¶ 

type ST_FontScheme byte
const (
	ST_FontSchemeUnset ST_FontScheme = 0
	ST_FontSchemeNone  ST_FontScheme = 1
	ST_FontSchemeMajor ST_FontScheme = 2
	ST_FontSchemeMinor ST_FontScheme = 3
)

func (ST_FontScheme) MarshalXML ¶ 

func (m ST_FontScheme) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_FontScheme) MarshalXMLAttr ¶ 

func (e ST_FontScheme) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_FontScheme) String ¶ 

func (m ST_FontScheme) String() string

func (*ST_FontScheme) UnmarshalXML ¶ 

func (m *ST_FontScheme) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_FontScheme) UnmarshalXMLAttr ¶ 

func (e *ST_FontScheme) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_FontScheme) Validate ¶ 

func (m ST_FontScheme) Validate() error

func (ST_FontScheme) ValidateWithPath ¶ 

func (m ST_FontScheme) ValidateWithPath(path string) error

type ST_FormatAction ¶ 

type ST_FormatAction byte
const (
	ST_FormatActionUnset      ST_FormatAction = 0
	ST_FormatActionBlank      ST_FormatAction = 1
	ST_FormatActionFormatting ST_FormatAction = 2
	ST_FormatActionDrill      ST_FormatAction = 3
	ST_FormatActionFormula    ST_FormatAction = 4
)

func (ST_FormatAction) MarshalXML ¶ 

func (m ST_FormatAction) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_FormatAction) MarshalXMLAttr ¶ 

func (e ST_FormatAction) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_FormatAction) String ¶ 

func (m ST_FormatAction) String() string

func (*ST_FormatAction) UnmarshalXML ¶ 

func (m *ST_FormatAction) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_FormatAction) UnmarshalXMLAttr ¶ 

func (e *ST_FormatAction) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_FormatAction) Validate ¶ 

func (m ST_FormatAction) Validate() error

func (ST_FormatAction) ValidateWithPath ¶ 

func (m ST_FormatAction) ValidateWithPath(path string) error

type ST_FormulaExpression ¶ 

type ST_FormulaExpression byte
const (
	ST_FormulaExpressionUnset        ST_FormulaExpression = 0
	ST_FormulaExpressionRef          ST_FormulaExpression = 1
	ST_FormulaExpressionRefError     ST_FormulaExpression = 2
	ST_FormulaExpressionArea         ST_FormulaExpression = 3
	ST_FormulaExpressionAreaError    ST_FormulaExpression = 4
	ST_FormulaExpressionComputedArea ST_FormulaExpression = 5
)

func (ST_FormulaExpression) MarshalXML ¶ 

func (m ST_FormulaExpression) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_FormulaExpression) MarshalXMLAttr ¶ 

func (e ST_FormulaExpression) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_FormulaExpression) String ¶ 

func (m ST_FormulaExpression) String() string

func (*ST_FormulaExpression) UnmarshalXML ¶ 

func (m *ST_FormulaExpression) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_FormulaExpression) UnmarshalXMLAttr ¶ 

func (e *ST_FormulaExpression) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_FormulaExpression) Validate ¶ 

func (m ST_FormulaExpression) Validate() error

func (ST_FormulaExpression) ValidateWithPath ¶ 

func (m ST_FormulaExpression) ValidateWithPath(path string) error

type ST_GradientType ¶ 

type ST_GradientType byte
const (
	ST_GradientTypeUnset  ST_GradientType = 0
	ST_GradientTypeLinear ST_GradientType = 1
	ST_GradientTypePath   ST_GradientType = 2
)

func (ST_GradientType) MarshalXML ¶ 

func (m ST_GradientType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_GradientType) MarshalXMLAttr ¶ 

func (e ST_GradientType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_GradientType) String ¶ 

func (m ST_GradientType) String() string

func (*ST_GradientType) UnmarshalXML ¶ 

func (m *ST_GradientType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_GradientType) UnmarshalXMLAttr ¶ 

func (e *ST_GradientType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_GradientType) Validate ¶ 

func (m ST_GradientType) Validate() error

func (ST_GradientType) ValidateWithPath ¶ 

func (m ST_GradientType) ValidateWithPath(path string) error

type ST_GroupBy ¶ 

type ST_GroupBy byte
const (
	ST_GroupByUnset    ST_GroupBy = 0
	ST_GroupByRange    ST_GroupBy = 1
	ST_GroupBySeconds  ST_GroupBy = 2
	ST_GroupByMinutes  ST_GroupBy = 3
	ST_GroupByHours    ST_GroupBy = 4
	ST_GroupByDays     ST_GroupBy = 5
	ST_GroupByMonths   ST_GroupBy = 6
	ST_GroupByQuarters ST_GroupBy = 7
	ST_GroupByYears    ST_GroupBy = 8
)

func (ST_GroupBy) MarshalXML ¶ 

func (m ST_GroupBy) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_GroupBy) MarshalXMLAttr ¶ 

func (e ST_GroupBy) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_GroupBy) String ¶ 

func (m ST_GroupBy) String() string

func (*ST_GroupBy) UnmarshalXML ¶ 

func (m *ST_GroupBy) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_GroupBy) UnmarshalXMLAttr ¶ 

func (e *ST_GroupBy) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_GroupBy) Validate ¶ 

func (m ST_GroupBy) Validate() error

func (ST_GroupBy) ValidateWithPath ¶ 

func (m ST_GroupBy) ValidateWithPath(path string) error

type ST_GrowShrinkType ¶ 

type ST_GrowShrinkType byte
const (
	ST_GrowShrinkTypeUnset          ST_GrowShrinkType = 0
	ST_GrowShrinkTypeInsertDelete   ST_GrowShrinkType = 1
	ST_GrowShrinkTypeInsertClear    ST_GrowShrinkType = 2
	ST_GrowShrinkTypeOverwriteClear ST_GrowShrinkType = 3
)

func (ST_GrowShrinkType) MarshalXML ¶ 

func (m ST_GrowShrinkType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_GrowShrinkType) MarshalXMLAttr ¶ 

func (e ST_GrowShrinkType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_GrowShrinkType) String ¶ 

func (m ST_GrowShrinkType) String() string

func (*ST_GrowShrinkType) UnmarshalXML ¶ 

func (m *ST_GrowShrinkType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_GrowShrinkType) UnmarshalXMLAttr ¶ 

func (e *ST_GrowShrinkType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_GrowShrinkType) Validate ¶ 

func (m ST_GrowShrinkType) Validate() error

func (ST_GrowShrinkType) ValidateWithPath ¶ 

func (m ST_GrowShrinkType) ValidateWithPath(path string) error

type ST_HorizontalAlignment ¶ 

type ST_HorizontalAlignment byte
const (
	ST_HorizontalAlignmentUnset            ST_HorizontalAlignment = 0
	ST_HorizontalAlignmentGeneral          ST_HorizontalAlignment = 1
	ST_HorizontalAlignmentLeft             ST_HorizontalAlignment = 2
	ST_HorizontalAlignmentCenter           ST_HorizontalAlignment = 3
	ST_HorizontalAlignmentRight            ST_HorizontalAlignment = 4
	ST_HorizontalAlignmentFill             ST_HorizontalAlignment = 5
	ST_HorizontalAlignmentJustify          ST_HorizontalAlignment = 6
	ST_HorizontalAlignmentCenterContinuous ST_HorizontalAlignment = 7
	ST_HorizontalAlignmentDistributed      ST_HorizontalAlignment = 8
)

func (ST_HorizontalAlignment) MarshalXML ¶ 

func (m ST_HorizontalAlignment) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_HorizontalAlignment) MarshalXMLAttr ¶ 

func (e ST_HorizontalAlignment) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_HorizontalAlignment) String ¶ 

func (m ST_HorizontalAlignment) String() string

func (*ST_HorizontalAlignment) UnmarshalXML ¶ 

func (m *ST_HorizontalAlignment) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_HorizontalAlignment) UnmarshalXMLAttr ¶ 

func (e *ST_HorizontalAlignment) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_HorizontalAlignment) Validate ¶ 

func (m ST_HorizontalAlignment) Validate() error

func (ST_HorizontalAlignment) ValidateWithPath ¶ 

func (m ST_HorizontalAlignment) ValidateWithPath(path string) error

type ST_HtmlFmt ¶ 

type ST_HtmlFmt byte
const (
	ST_HtmlFmtUnset ST_HtmlFmt = 0
	ST_HtmlFmtNone  ST_HtmlFmt = 1
	ST_HtmlFmtRtf   ST_HtmlFmt = 2
	ST_HtmlFmtAll   ST_HtmlFmt = 3
)

func (ST_HtmlFmt) MarshalXML ¶ 

func (m ST_HtmlFmt) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_HtmlFmt) MarshalXMLAttr ¶ 

func (e ST_HtmlFmt) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_HtmlFmt) String ¶ 

func (m ST_HtmlFmt) String() string

func (*ST_HtmlFmt) UnmarshalXML ¶ 

func (m *ST_HtmlFmt) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_HtmlFmt) UnmarshalXMLAttr ¶ 

func (e *ST_HtmlFmt) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_HtmlFmt) Validate ¶ 

func (m ST_HtmlFmt) Validate() error

func (ST_HtmlFmt) ValidateWithPath ¶ 

func (m ST_HtmlFmt) ValidateWithPath(path string) error

type ST_IconSetType ¶ 

type ST_IconSetType byte
const (
	ST_IconSetTypeUnset           ST_IconSetType = 0
	ST_IconSetType3Arrows         ST_IconSetType = 1
	ST_IconSetType3ArrowsGray     ST_IconSetType = 2
	ST_IconSetType3Flags          ST_IconSetType = 3
	ST_IconSetType3TrafficLights1 ST_IconSetType = 4
	ST_IconSetType3TrafficLights2 ST_IconSetType = 5
	ST_IconSetType3Signs          ST_IconSetType = 6
	ST_IconSetType3Symbols        ST_IconSetType = 7
	ST_IconSetType3Symbols2       ST_IconSetType = 8
	ST_IconSetType4Arrows         ST_IconSetType = 9
	ST_IconSetType4ArrowsGray     ST_IconSetType = 10
	ST_IconSetType4RedToBlack     ST_IconSetType = 11
	ST_IconSetType4Rating         ST_IconSetType = 12
	ST_IconSetType4TrafficLights  ST_IconSetType = 13
	ST_IconSetType5Arrows         ST_IconSetType = 14
	ST_IconSetType5ArrowsGray     ST_IconSetType = 15
	ST_IconSetType5Rating         ST_IconSetType = 16
	ST_IconSetType5Quarters       ST_IconSetType = 17
)

func (ST_IconSetType) MarshalXML ¶ 

func (m ST_IconSetType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_IconSetType) MarshalXMLAttr ¶ 

func (e ST_IconSetType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_IconSetType) String ¶ 

func (m ST_IconSetType) String() string

func (*ST_IconSetType) UnmarshalXML ¶ 

func (m *ST_IconSetType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_IconSetType) UnmarshalXMLAttr ¶ 

func (e *ST_IconSetType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_IconSetType) Validate ¶ 

func (m ST_IconSetType) Validate() error

func (ST_IconSetType) ValidateWithPath ¶ 

func (m ST_IconSetType) ValidateWithPath(path string) error

type ST_ItemType ¶ 

type ST_ItemType byte
const (
	ST_ItemTypeUnset   ST_ItemType = 0
	ST_ItemTypeData    ST_ItemType = 1
	ST_ItemTypeDefault ST_ItemType = 2
	ST_ItemTypeSum     ST_ItemType = 3
	ST_ItemTypeCountA  ST_ItemType = 4
	ST_ItemTypeAvg     ST_ItemType = 5
	ST_ItemTypeMax     ST_ItemType = 6
	ST_ItemTypeMin     ST_ItemType = 7
	ST_ItemTypeProduct ST_ItemType = 8
	ST_ItemTypeCount   ST_ItemType = 9
	ST_ItemTypeStdDev  ST_ItemType = 10
	ST_ItemTypeStdDevP ST_ItemType = 11
	ST_ItemTypeVar     ST_ItemType = 12
	ST_ItemTypeVarP    ST_ItemType = 13
	ST_ItemTypeGrand   ST_ItemType = 14
	ST_ItemTypeBlank   ST_ItemType = 15
)

func (ST_ItemType) MarshalXML ¶ 

func (m ST_ItemType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_ItemType) MarshalXMLAttr ¶ 

func (e ST_ItemType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_ItemType) String ¶ 

func (m ST_ItemType) String() string

func (*ST_ItemType) UnmarshalXML ¶ 

func (m *ST_ItemType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_ItemType) UnmarshalXMLAttr ¶ 

func (e *ST_ItemType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_ItemType) Validate ¶ 

func (m ST_ItemType) Validate() error

func (ST_ItemType) ValidateWithPath ¶ 

func (m ST_ItemType) ValidateWithPath(path string) error

type ST_MdxFunctionType ¶ 

type ST_MdxFunctionType byte
const (
	ST_MdxFunctionTypeUnset ST_MdxFunctionType = 0
	ST_MdxFunctionTypeM     ST_MdxFunctionType = 1
	ST_MdxFunctionTypeV     ST_MdxFunctionType = 2
	ST_MdxFunctionTypeS     ST_MdxFunctionType = 3
	ST_MdxFunctionTypeC     ST_MdxFunctionType = 4
	ST_MdxFunctionTypeR     ST_MdxFunctionType = 5
	ST_MdxFunctionTypeP     ST_MdxFunctionType = 6
	ST_MdxFunctionTypeK     ST_MdxFunctionType = 7
)

func (ST_MdxFunctionType) MarshalXML ¶ 

func (m ST_MdxFunctionType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_MdxFunctionType) MarshalXMLAttr ¶ 

func (e ST_MdxFunctionType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_MdxFunctionType) String ¶ 

func (m ST_MdxFunctionType) String() string

func (*ST_MdxFunctionType) UnmarshalXML ¶ 

func (m *ST_MdxFunctionType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_MdxFunctionType) UnmarshalXMLAttr ¶ 

func (e *ST_MdxFunctionType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_MdxFunctionType) Validate ¶ 

func (m ST_MdxFunctionType) Validate() error

func (ST_MdxFunctionType) ValidateWithPath ¶ 

func (m ST_MdxFunctionType) ValidateWithPath(path string) error

type ST_MdxKPIProperty ¶ 

type ST_MdxKPIProperty byte
const (
	ST_MdxKPIPropertyUnset ST_MdxKPIProperty = 0
	ST_MdxKPIPropertyV     ST_MdxKPIProperty = 1
	ST_MdxKPIPropertyG     ST_MdxKPIProperty = 2
	ST_MdxKPIPropertyS     ST_MdxKPIProperty = 3
	ST_MdxKPIPropertyT     ST_MdxKPIProperty = 4
	ST_MdxKPIPropertyW     ST_MdxKPIProperty = 5
	ST_MdxKPIPropertyM     ST_MdxKPIProperty = 6
)

func (ST_MdxKPIProperty) MarshalXML ¶ 

func (m ST_MdxKPIProperty) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_MdxKPIProperty) MarshalXMLAttr ¶ 

func (e ST_MdxKPIProperty) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_MdxKPIProperty) String ¶ 

func (m ST_MdxKPIProperty) String() string

func (*ST_MdxKPIProperty) UnmarshalXML ¶ 

func (m *ST_MdxKPIProperty) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_MdxKPIProperty) UnmarshalXMLAttr ¶ 

func (e *ST_MdxKPIProperty) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_MdxKPIProperty) Validate ¶ 

func (m ST_MdxKPIProperty) Validate() error

func (ST_MdxKPIProperty) ValidateWithPath ¶ 

func (m ST_MdxKPIProperty) ValidateWithPath(path string) error

type ST_MdxSetOrder ¶ 

type ST_MdxSetOrder byte
const (
	ST_MdxSetOrderUnset ST_MdxSetOrder = 0
	ST_MdxSetOrderU     ST_MdxSetOrder = 1
	ST_MdxSetOrderA     ST_MdxSetOrder = 2
	ST_MdxSetOrderD     ST_MdxSetOrder = 3
	ST_MdxSetOrderAa    ST_MdxSetOrder = 4
	ST_MdxSetOrderAd    ST_MdxSetOrder = 5
	ST_MdxSetOrderNa    ST_MdxSetOrder = 6
	ST_MdxSetOrderNd    ST_MdxSetOrder = 7
)

func (ST_MdxSetOrder) MarshalXML ¶ 

func (m ST_MdxSetOrder) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_MdxSetOrder) MarshalXMLAttr ¶ 

func (e ST_MdxSetOrder) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_MdxSetOrder) String ¶ 

func (m ST_MdxSetOrder) String() string

func (*ST_MdxSetOrder) UnmarshalXML ¶ 

func (m *ST_MdxSetOrder) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_MdxSetOrder) UnmarshalXMLAttr ¶ 

func (e *ST_MdxSetOrder) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_MdxSetOrder) Validate ¶ 

func (m ST_MdxSetOrder) Validate() error

func (ST_MdxSetOrder) ValidateWithPath ¶ 

func (m ST_MdxSetOrder) ValidateWithPath(path string) error

type ST_Objects ¶ 

type ST_Objects byte
const (
	ST_ObjectsUnset        ST_Objects = 0
	ST_ObjectsAll          ST_Objects = 1
	ST_ObjectsPlaceholders ST_Objects = 2
	ST_ObjectsNone         ST_Objects = 3
)

func (ST_Objects) MarshalXML ¶ 

func (m ST_Objects) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Objects) MarshalXMLAttr ¶ 

func (e ST_Objects) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Objects) String ¶ 

func (m ST_Objects) String() string

func (*ST_Objects) UnmarshalXML ¶ 

func (m *ST_Objects) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Objects) UnmarshalXMLAttr ¶ 

func (e *ST_Objects) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Objects) Validate ¶ 

func (m ST_Objects) Validate() error

func (ST_Objects) ValidateWithPath ¶ 

func (m ST_Objects) ValidateWithPath(path string) error

type ST_OleUpdate ¶ 

type ST_OleUpdate byte
const (
	ST_OleUpdateUnset            ST_OleUpdate = 0
	ST_OleUpdateOLEUPDATE_ALWAYS ST_OleUpdate = 1
	ST_OleUpdateOLEUPDATE_ONCALL ST_OleUpdate = 2
)

func (ST_OleUpdate) MarshalXML ¶ 

func (m ST_OleUpdate) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_OleUpdate) MarshalXMLAttr ¶ 

func (e ST_OleUpdate) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_OleUpdate) String ¶ 

func (m ST_OleUpdate) String() string

func (*ST_OleUpdate) UnmarshalXML ¶ 

func (m *ST_OleUpdate) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_OleUpdate) UnmarshalXMLAttr ¶ 

func (e *ST_OleUpdate) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_OleUpdate) Validate ¶ 

func (m ST_OleUpdate) Validate() error

func (ST_OleUpdate) ValidateWithPath ¶ 

func (m ST_OleUpdate) ValidateWithPath(path string) error

type ST_Orientation ¶ 

type ST_Orientation byte
const (
	ST_OrientationUnset     ST_Orientation = 0
	ST_OrientationDefault   ST_Orientation = 1
	ST_OrientationPortrait  ST_Orientation = 2
	ST_OrientationLandscape ST_Orientation = 3
)

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_PageOrder ¶ 

type ST_PageOrder byte
const (
	ST_PageOrderUnset        ST_PageOrder = 0
	ST_PageOrderDownThenOver ST_PageOrder = 1
	ST_PageOrderOverThenDown ST_PageOrder = 2
)

func (ST_PageOrder) MarshalXML ¶ 

func (m ST_PageOrder) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_PageOrder) MarshalXMLAttr ¶ 

func (e ST_PageOrder) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PageOrder) String ¶ 

func (m ST_PageOrder) String() string

func (*ST_PageOrder) UnmarshalXML ¶ 

func (m *ST_PageOrder) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_PageOrder) UnmarshalXMLAttr ¶ 

func (e *ST_PageOrder) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PageOrder) Validate ¶ 

func (m ST_PageOrder) Validate() error

func (ST_PageOrder) ValidateWithPath ¶ 

func (m ST_PageOrder) ValidateWithPath(path string) error

type ST_Pane ¶ 

type ST_Pane byte
const (
	ST_PaneUnset       ST_Pane = 0
	ST_PaneBottomRight ST_Pane = 1
	ST_PaneTopRight    ST_Pane = 2
	ST_PaneBottomLeft  ST_Pane = 3
	ST_PaneTopLeft     ST_Pane = 4
)

func (ST_Pane) MarshalXML ¶ 

func (m ST_Pane) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Pane) MarshalXMLAttr ¶ 

func (e ST_Pane) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Pane) String ¶ 

func (m ST_Pane) String() string

func (*ST_Pane) UnmarshalXML ¶ 

func (m *ST_Pane) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Pane) UnmarshalXMLAttr ¶ 

func (e *ST_Pane) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Pane) Validate ¶ 

func (m ST_Pane) Validate() error

func (ST_Pane) ValidateWithPath ¶ 

func (m ST_Pane) ValidateWithPath(path string) error

type ST_PaneState ¶ 

type ST_PaneState byte
const (
	ST_PaneStateUnset       ST_PaneState = 0
	ST_PaneStateSplit       ST_PaneState = 1
	ST_PaneStateFrozen      ST_PaneState = 2
	ST_PaneStateFrozenSplit ST_PaneState = 3
)

func (ST_PaneState) MarshalXML ¶ 

func (m ST_PaneState) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_PaneState) MarshalXMLAttr ¶ 

func (e ST_PaneState) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PaneState) String ¶ 

func (m ST_PaneState) String() string

func (*ST_PaneState) UnmarshalXML ¶ 

func (m *ST_PaneState) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_PaneState) UnmarshalXMLAttr ¶ 

func (e *ST_PaneState) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PaneState) Validate ¶ 

func (m ST_PaneState) Validate() error

func (ST_PaneState) ValidateWithPath ¶ 

func (m ST_PaneState) ValidateWithPath(path string) error

type ST_ParameterType ¶ 

type ST_ParameterType byte
const (
	ST_ParameterTypeUnset  ST_ParameterType = 0
	ST_ParameterTypePrompt ST_ParameterType = 1
	ST_ParameterTypeValue  ST_ParameterType = 2
	ST_ParameterTypeCell   ST_ParameterType = 3
)

func (ST_ParameterType) MarshalXML ¶ 

func (m ST_ParameterType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_ParameterType) MarshalXMLAttr ¶ 

func (e ST_ParameterType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_ParameterType) String ¶ 

func (m ST_ParameterType) String() string

func (*ST_ParameterType) UnmarshalXML ¶ 

func (m *ST_ParameterType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_ParameterType) UnmarshalXMLAttr ¶ 

func (e *ST_ParameterType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_ParameterType) Validate ¶ 

func (m ST_ParameterType) Validate() error

func (ST_ParameterType) ValidateWithPath ¶ 

func (m ST_ParameterType) ValidateWithPath(path string) error

type ST_PatternType ¶ 

type ST_PatternType byte
const (
	ST_PatternTypeUnset           ST_PatternType = 0
	ST_PatternTypeNone            ST_PatternType = 1
	ST_PatternTypeSolid           ST_PatternType = 2
	ST_PatternTypeMediumGray      ST_PatternType = 3
	ST_PatternTypeDarkGray        ST_PatternType = 4
	ST_PatternTypeLightGray       ST_PatternType = 5
	ST_PatternTypeDarkHorizontal  ST_PatternType = 6
	ST_PatternTypeDarkVertical    ST_PatternType = 7
	ST_PatternTypeDarkDown        ST_PatternType = 8
	ST_PatternTypeDarkUp          ST_PatternType = 9
	ST_PatternTypeDarkGrid        ST_PatternType = 10
	ST_PatternTypeDarkTrellis     ST_PatternType = 11
	ST_PatternTypeLightHorizontal ST_PatternType = 12
	ST_PatternTypeLightVertical   ST_PatternType = 13
	ST_PatternTypeLightDown       ST_PatternType = 14
	ST_PatternTypeLightUp         ST_PatternType = 15
	ST_PatternTypeLightGrid       ST_PatternType = 16
	ST_PatternTypeLightTrellis    ST_PatternType = 17
	ST_PatternTypeGray125         ST_PatternType = 18
	ST_PatternTypeGray0625        ST_PatternType = 19
)

func (ST_PatternType) MarshalXML ¶ 

func (m ST_PatternType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_PatternType) MarshalXMLAttr ¶ 

func (e ST_PatternType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PatternType) String ¶ 

func (m ST_PatternType) String() string

func (*ST_PatternType) UnmarshalXML ¶ 

func (m *ST_PatternType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_PatternType) UnmarshalXMLAttr ¶ 

func (e *ST_PatternType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PatternType) Validate ¶ 

func (m ST_PatternType) Validate() error

func (ST_PatternType) ValidateWithPath ¶ 

func (m ST_PatternType) ValidateWithPath(path string) error

type ST_PhoneticAlignment ¶ 

type ST_PhoneticAlignment byte
const (
	ST_PhoneticAlignmentUnset       ST_PhoneticAlignment = 0
	ST_PhoneticAlignmentNoControl   ST_PhoneticAlignment = 1
	ST_PhoneticAlignmentLeft        ST_PhoneticAlignment = 2
	ST_PhoneticAlignmentCenter      ST_PhoneticAlignment = 3
	ST_PhoneticAlignmentDistributed ST_PhoneticAlignment = 4
)

func (ST_PhoneticAlignment) MarshalXML ¶ 

func (m ST_PhoneticAlignment) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_PhoneticAlignment) MarshalXMLAttr ¶ 

func (e ST_PhoneticAlignment) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PhoneticAlignment) String ¶ 

func (m ST_PhoneticAlignment) String() string

func (*ST_PhoneticAlignment) UnmarshalXML ¶ 

func (m *ST_PhoneticAlignment) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_PhoneticAlignment) UnmarshalXMLAttr ¶ 

func (e *ST_PhoneticAlignment) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PhoneticAlignment) Validate ¶ 

func (m ST_PhoneticAlignment) Validate() error

func (ST_PhoneticAlignment) ValidateWithPath ¶ 

func (m ST_PhoneticAlignment) ValidateWithPath(path string) error

type ST_PhoneticType ¶ 

type ST_PhoneticType byte
const (
	ST_PhoneticTypeUnset             ST_PhoneticType = 0
	ST_PhoneticTypeHalfwidthKatakana ST_PhoneticType = 1
	ST_PhoneticTypeFullwidthKatakana ST_PhoneticType = 2
	ST_PhoneticTypeHiragana          ST_PhoneticType = 3
	ST_PhoneticTypeNoConversion      ST_PhoneticType = 4
)

func (ST_PhoneticType) MarshalXML ¶ 

func (m ST_PhoneticType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_PhoneticType) MarshalXMLAttr ¶ 

func (e ST_PhoneticType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PhoneticType) String ¶ 

func (m ST_PhoneticType) String() string

func (*ST_PhoneticType) UnmarshalXML ¶ 

func (m *ST_PhoneticType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_PhoneticType) UnmarshalXMLAttr ¶ 

func (e *ST_PhoneticType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PhoneticType) Validate ¶ 

func (m ST_PhoneticType) Validate() error

func (ST_PhoneticType) ValidateWithPath ¶ 

func (m ST_PhoneticType) ValidateWithPath(path string) error

type ST_PivotAreaType ¶ 

type ST_PivotAreaType byte
const (
	ST_PivotAreaTypeUnset    ST_PivotAreaType = 0
	ST_PivotAreaTypeNone     ST_PivotAreaType = 1
	ST_PivotAreaTypeNormal   ST_PivotAreaType = 2
	ST_PivotAreaTypeData     ST_PivotAreaType = 3
	ST_PivotAreaTypeAll      ST_PivotAreaType = 4
	ST_PivotAreaTypeOrigin   ST_PivotAreaType = 5
	ST_PivotAreaTypeButton   ST_PivotAreaType = 6
	ST_PivotAreaTypeTopEnd   ST_PivotAreaType = 7
	ST_PivotAreaTypeTopRight ST_PivotAreaType = 8
)

func (ST_PivotAreaType) MarshalXML ¶ 

func (m ST_PivotAreaType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_PivotAreaType) MarshalXMLAttr ¶ 

func (e ST_PivotAreaType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PivotAreaType) String ¶ 

func (m ST_PivotAreaType) String() string

func (*ST_PivotAreaType) UnmarshalXML ¶ 

func (m *ST_PivotAreaType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_PivotAreaType) UnmarshalXMLAttr ¶ 

func (e *ST_PivotAreaType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PivotAreaType) Validate ¶ 

func (m ST_PivotAreaType) Validate() error

func (ST_PivotAreaType) ValidateWithPath ¶ 

func (m ST_PivotAreaType) ValidateWithPath(path string) error

type ST_PivotFilterType ¶ 

type ST_PivotFilterType byte
const (
	ST_PivotFilterTypeUnset                     ST_PivotFilterType = 0
	ST_PivotFilterTypeUnknown                   ST_PivotFilterType = 1
	ST_PivotFilterTypeCount                     ST_PivotFilterType = 2
	ST_PivotFilterTypePercent                   ST_PivotFilterType = 3
	ST_PivotFilterTypeSum                       ST_PivotFilterType = 4
	ST_PivotFilterTypeCaptionEqual              ST_PivotFilterType = 5
	ST_PivotFilterTypeCaptionNotEqual           ST_PivotFilterType = 6
	ST_PivotFilterTypeCaptionBeginsWith         ST_PivotFilterType = 7
	ST_PivotFilterTypeCaptionNotBeginsWith      ST_PivotFilterType = 8
	ST_PivotFilterTypeCaptionEndsWith           ST_PivotFilterType = 9
	ST_PivotFilterTypeCaptionNotEndsWith        ST_PivotFilterType = 10
	ST_PivotFilterTypeCaptionContains           ST_PivotFilterType = 11
	ST_PivotFilterTypeCaptionNotContains        ST_PivotFilterType = 12
	ST_PivotFilterTypeCaptionGreaterThan        ST_PivotFilterType = 13
	ST_PivotFilterTypeCaptionGreaterThanOrEqual ST_PivotFilterType = 14
	ST_PivotFilterTypeCaptionLessThan           ST_PivotFilterType = 15
	ST_PivotFilterTypeCaptionLessThanOrEqual    ST_PivotFilterType = 16
	ST_PivotFilterTypeCaptionBetween            ST_PivotFilterType = 17
	ST_PivotFilterTypeCaptionNotBetween         ST_PivotFilterType = 18
	ST_PivotFilterTypeValueEqual                ST_PivotFilterType = 19
	ST_PivotFilterTypeValueNotEqual             ST_PivotFilterType = 20
	ST_PivotFilterTypeValueGreaterThan          ST_PivotFilterType = 21
	ST_PivotFilterTypeValueGreaterThanOrEqual   ST_PivotFilterType = 22
	ST_PivotFilterTypeValueLessThan             ST_PivotFilterType = 23
	ST_PivotFilterTypeValueLessThanOrEqual      ST_PivotFilterType = 24
	ST_PivotFilterTypeValueBetween              ST_PivotFilterType = 25
	ST_PivotFilterTypeValueNotBetween           ST_PivotFilterType = 26
	ST_PivotFilterTypeDateEqual                 ST_PivotFilterType = 27
	ST_PivotFilterTypeDateNotEqual              ST_PivotFilterType = 28
	ST_PivotFilterTypeDateOlderThan             ST_PivotFilterType = 29
	ST_PivotFilterTypeDateOlderThanOrEqual      ST_PivotFilterType = 30
	ST_PivotFilterTypeDateNewerThan             ST_PivotFilterType = 31
	ST_PivotFilterTypeDateNewerThanOrEqual      ST_PivotFilterType = 32
	ST_PivotFilterTypeDateBetween               ST_PivotFilterType = 33
	ST_PivotFilterTypeDateNotBetween            ST_PivotFilterType = 34
	ST_PivotFilterTypeTomorrow                  ST_PivotFilterType = 35
	ST_PivotFilterTypeToday                     ST_PivotFilterType = 36
	ST_PivotFilterTypeYesterday                 ST_PivotFilterType = 37
	ST_PivotFilterTypeNextWeek                  ST_PivotFilterType = 38
	ST_PivotFilterTypeThisWeek                  ST_PivotFilterType = 39
	ST_PivotFilterTypeLastWeek                  ST_PivotFilterType = 40
	ST_PivotFilterTypeNextMonth                 ST_PivotFilterType = 41
	ST_PivotFilterTypeThisMonth                 ST_PivotFilterType = 42
	ST_PivotFilterTypeLastMonth                 ST_PivotFilterType = 43
	ST_PivotFilterTypeNextQuarter               ST_PivotFilterType = 44
	ST_PivotFilterTypeThisQuarter               ST_PivotFilterType = 45
	ST_PivotFilterTypeLastQuarter               ST_PivotFilterType = 46
	ST_PivotFilterTypeNextYear                  ST_PivotFilterType = 47
	ST_PivotFilterTypeThisYear                  ST_PivotFilterType = 48
	ST_PivotFilterTypeLastYear                  ST_PivotFilterType = 49
	ST_PivotFilterTypeYearToDate                ST_PivotFilterType = 50
	ST_PivotFilterTypeQ1                        ST_PivotFilterType = 51
	ST_PivotFilterTypeQ2                        ST_PivotFilterType = 52
	ST_PivotFilterTypeQ3                        ST_PivotFilterType = 53
	ST_PivotFilterTypeQ4                        ST_PivotFilterType = 54
	ST_PivotFilterTypeM1                        ST_PivotFilterType = 55
	ST_PivotFilterTypeM2                        ST_PivotFilterType = 56
	ST_PivotFilterTypeM3                        ST_PivotFilterType = 57
	ST_PivotFilterTypeM4                        ST_PivotFilterType = 58
	ST_PivotFilterTypeM5                        ST_PivotFilterType = 59
	ST_PivotFilterTypeM6                        ST_PivotFilterType = 60
	ST_PivotFilterTypeM7                        ST_PivotFilterType = 61
	ST_PivotFilterTypeM8                        ST_PivotFilterType = 62
	ST_PivotFilterTypeM9                        ST_PivotFilterType = 63
	ST_PivotFilterTypeM10                       ST_PivotFilterType = 64
	ST_PivotFilterTypeM11                       ST_PivotFilterType = 65
	ST_PivotFilterTypeM12                       ST_PivotFilterType = 66
)

func (ST_PivotFilterType) MarshalXML ¶ 

func (m ST_PivotFilterType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_PivotFilterType) MarshalXMLAttr ¶ 

func (e ST_PivotFilterType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PivotFilterType) String ¶ 

func (m ST_PivotFilterType) String() string

func (*ST_PivotFilterType) UnmarshalXML ¶ 

func (m *ST_PivotFilterType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_PivotFilterType) UnmarshalXMLAttr ¶ 

func (e *ST_PivotFilterType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PivotFilterType) Validate ¶ 

func (m ST_PivotFilterType) Validate() error

func (ST_PivotFilterType) ValidateWithPath ¶ 

func (m ST_PivotFilterType) ValidateWithPath(path string) error

type ST_PrintError ¶ 

type ST_PrintError byte
const (
	ST_PrintErrorUnset     ST_PrintError = 0
	ST_PrintErrorDisplayed ST_PrintError = 1
	ST_PrintErrorBlank     ST_PrintError = 2
	ST_PrintErrorDash      ST_PrintError = 3
	ST_PrintErrorNA        ST_PrintError = 4
)

func (ST_PrintError) MarshalXML ¶ 

func (m ST_PrintError) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_PrintError) MarshalXMLAttr ¶ 

func (e ST_PrintError) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_PrintError) String ¶ 

func (m ST_PrintError) String() string

func (*ST_PrintError) UnmarshalXML ¶ 

func (m *ST_PrintError) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_PrintError) UnmarshalXMLAttr ¶ 

func (e *ST_PrintError) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_PrintError) Validate ¶ 

func (m ST_PrintError) Validate() error

func (ST_PrintError) ValidateWithPath ¶ 

func (m ST_PrintError) ValidateWithPath(path string) error

type ST_Qualifier ¶ 

type ST_Qualifier byte
const (
	ST_QualifierUnset       ST_Qualifier = 0
	ST_QualifierDoubleQuote ST_Qualifier = 1
	ST_QualifierSingleQuote ST_Qualifier = 2
	ST_QualifierNone        ST_Qualifier = 3
)

func (ST_Qualifier) MarshalXML ¶ 

func (m ST_Qualifier) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Qualifier) MarshalXMLAttr ¶ 

func (e ST_Qualifier) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Qualifier) String ¶ 

func (m ST_Qualifier) String() string

func (*ST_Qualifier) UnmarshalXML ¶ 

func (m *ST_Qualifier) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Qualifier) UnmarshalXMLAttr ¶ 

func (e *ST_Qualifier) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Qualifier) Validate ¶ 

func (m ST_Qualifier) Validate() error

func (ST_Qualifier) ValidateWithPath ¶ 

func (m ST_Qualifier) ValidateWithPath(path string) error

type ST_RefMode ¶ 

type ST_RefMode byte
const (
	ST_RefModeUnset ST_RefMode = 0
	ST_RefModeA1    ST_RefMode = 1
	ST_RefModeR1C1  ST_RefMode = 2
)

func (ST_RefMode) MarshalXML ¶ 

func (m ST_RefMode) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_RefMode) MarshalXMLAttr ¶ 

func (e ST_RefMode) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_RefMode) String ¶ 

func (m ST_RefMode) String() string

func (*ST_RefMode) UnmarshalXML ¶ 

func (m *ST_RefMode) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_RefMode) UnmarshalXMLAttr ¶ 

func (e *ST_RefMode) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_RefMode) Validate ¶ 

func (m ST_RefMode) Validate() error

func (ST_RefMode) ValidateWithPath ¶ 

func (m ST_RefMode) ValidateWithPath(path string) error

type ST_RevisionAction ¶ 

type ST_RevisionAction byte
const (
	ST_RevisionActionUnset  ST_RevisionAction = 0
	ST_RevisionActionAdd    ST_RevisionAction = 1
	ST_RevisionActionDelete ST_RevisionAction = 2
)

func (ST_RevisionAction) MarshalXML ¶ 

func (m ST_RevisionAction) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_RevisionAction) MarshalXMLAttr ¶ 

func (e ST_RevisionAction) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_RevisionAction) String ¶ 

func (m ST_RevisionAction) String() string

func (*ST_RevisionAction) UnmarshalXML ¶ 

func (m *ST_RevisionAction) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_RevisionAction) UnmarshalXMLAttr ¶ 

func (e *ST_RevisionAction) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_RevisionAction) Validate ¶ 

func (m ST_RevisionAction) Validate() error

func (ST_RevisionAction) ValidateWithPath ¶ 

func (m ST_RevisionAction) ValidateWithPath(path string) error

type ST_Scope ¶ 

type ST_Scope byte
const (
	ST_ScopeUnset     ST_Scope = 0
	ST_ScopeSelection ST_Scope = 1
	ST_ScopeData      ST_Scope = 2
	ST_ScopeField     ST_Scope = 3
)

func (ST_Scope) MarshalXML ¶ 

func (m ST_Scope) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Scope) MarshalXMLAttr ¶ 

func (e ST_Scope) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Scope) String ¶ 

func (m ST_Scope) String() string

func (*ST_Scope) UnmarshalXML ¶ 

func (m *ST_Scope) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Scope) UnmarshalXMLAttr ¶ 

func (e *ST_Scope) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Scope) Validate ¶ 

func (m ST_Scope) Validate() error

func (ST_Scope) ValidateWithPath ¶ 

func (m ST_Scope) ValidateWithPath(path string) error

type ST_SheetState ¶ 

type ST_SheetState byte
const (
	ST_SheetStateUnset      ST_SheetState = 0
	ST_SheetStateVisible    ST_SheetState = 1
	ST_SheetStateHidden     ST_SheetState = 2
	ST_SheetStateVeryHidden ST_SheetState = 3
)

func (ST_SheetState) MarshalXML ¶ 

func (m ST_SheetState) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_SheetState) MarshalXMLAttr ¶ 

func (e ST_SheetState) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_SheetState) String ¶ 

func (m ST_SheetState) String() string

func (*ST_SheetState) UnmarshalXML ¶ 

func (m *ST_SheetState) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_SheetState) UnmarshalXMLAttr ¶ 

func (e *ST_SheetState) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_SheetState) Validate ¶ 

func (m ST_SheetState) Validate() error

func (ST_SheetState) ValidateWithPath ¶ 

func (m ST_SheetState) ValidateWithPath(path string) error

type ST_SheetViewType ¶ 

type ST_SheetViewType byte
const (
	ST_SheetViewTypeUnset            ST_SheetViewType = 0
	ST_SheetViewTypeNormal           ST_SheetViewType = 1
	ST_SheetViewTypePageBreakPreview ST_SheetViewType = 2
	ST_SheetViewTypePageLayout       ST_SheetViewType = 3
)

func (ST_SheetViewType) MarshalXML ¶ 

func (m ST_SheetViewType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_SheetViewType) MarshalXMLAttr ¶ 

func (e ST_SheetViewType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_SheetViewType) String ¶ 

func (m ST_SheetViewType) String() string

func (*ST_SheetViewType) UnmarshalXML ¶ 

func (m *ST_SheetViewType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_SheetViewType) UnmarshalXMLAttr ¶ 

func (e *ST_SheetViewType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_SheetViewType) Validate ¶ 

func (m ST_SheetViewType) Validate() error

func (ST_SheetViewType) ValidateWithPath ¶ 

func (m ST_SheetViewType) ValidateWithPath(path string) error

type ST_ShowDataAs ¶ 

type ST_ShowDataAs byte
const (
	ST_ShowDataAsUnset          ST_ShowDataAs = 0
	ST_ShowDataAsNormal         ST_ShowDataAs = 1
	ST_ShowDataAsDifference     ST_ShowDataAs = 2
	ST_ShowDataAsPercent        ST_ShowDataAs = 3
	ST_ShowDataAsPercentDiff    ST_ShowDataAs = 4
	ST_ShowDataAsRunTotal       ST_ShowDataAs = 5
	ST_ShowDataAsPercentOfRow   ST_ShowDataAs = 6
	ST_ShowDataAsPercentOfCol   ST_ShowDataAs = 7
	ST_ShowDataAsPercentOfTotal ST_ShowDataAs = 8
	ST_ShowDataAsIndex          ST_ShowDataAs = 9
)

func (ST_ShowDataAs) MarshalXML ¶ 

func (m ST_ShowDataAs) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_ShowDataAs) MarshalXMLAttr ¶ 

func (e ST_ShowDataAs) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_ShowDataAs) String ¶ 

func (m ST_ShowDataAs) String() string

func (*ST_ShowDataAs) UnmarshalXML ¶ 

func (m *ST_ShowDataAs) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_ShowDataAs) UnmarshalXMLAttr ¶ 

func (e *ST_ShowDataAs) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_ShowDataAs) Validate ¶ 

func (m ST_ShowDataAs) Validate() error

func (ST_ShowDataAs) ValidateWithPath ¶ 

func (m ST_ShowDataAs) ValidateWithPath(path string) error

type ST_SmartTagShow ¶ 

type ST_SmartTagShow byte
const (
	ST_SmartTagShowUnset       ST_SmartTagShow = 0
	ST_SmartTagShowAll         ST_SmartTagShow = 1
	ST_SmartTagShowNone        ST_SmartTagShow = 2
	ST_SmartTagShowNoIndicator ST_SmartTagShow = 3
)

func (ST_SmartTagShow) MarshalXML ¶ 

func (m ST_SmartTagShow) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_SmartTagShow) MarshalXMLAttr ¶ 

func (e ST_SmartTagShow) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_SmartTagShow) String ¶ 

func (m ST_SmartTagShow) String() string

func (*ST_SmartTagShow) UnmarshalXML ¶ 

func (m *ST_SmartTagShow) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_SmartTagShow) UnmarshalXMLAttr ¶ 

func (e *ST_SmartTagShow) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_SmartTagShow) Validate ¶ 

func (m ST_SmartTagShow) Validate() error

func (ST_SmartTagShow) ValidateWithPath ¶ 

func (m ST_SmartTagShow) ValidateWithPath(path string) error

type ST_SortBy ¶ 

type ST_SortBy byte
const (
	ST_SortByUnset     ST_SortBy = 0
	ST_SortByValue     ST_SortBy = 1
	ST_SortByCellColor ST_SortBy = 2
	ST_SortByFontColor ST_SortBy = 3
	ST_SortByIcon      ST_SortBy = 4
)

func (ST_SortBy) MarshalXML ¶ 

func (m ST_SortBy) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_SortBy) MarshalXMLAttr ¶ 

func (e ST_SortBy) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_SortBy) String ¶ 

func (m ST_SortBy) String() string

func (*ST_SortBy) UnmarshalXML ¶ 

func (m *ST_SortBy) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_SortBy) UnmarshalXMLAttr ¶ 

func (e *ST_SortBy) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_SortBy) Validate ¶ 

func (m ST_SortBy) Validate() error

func (ST_SortBy) ValidateWithPath ¶ 

func (m ST_SortBy) ValidateWithPath(path string) error

type ST_SortMethod ¶ 

type ST_SortMethod byte
const (
	ST_SortMethodUnset  ST_SortMethod = 0
	ST_SortMethodStroke ST_SortMethod = 1
	ST_SortMethodPinYin ST_SortMethod = 2
	ST_SortMethodNone   ST_SortMethod = 3
)

func (ST_SortMethod) MarshalXML ¶ 

func (m ST_SortMethod) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_SortMethod) MarshalXMLAttr ¶ 

func (e ST_SortMethod) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_SortMethod) String ¶ 

func (m ST_SortMethod) String() string

func (*ST_SortMethod) UnmarshalXML ¶ 

func (m *ST_SortMethod) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_SortMethod) UnmarshalXMLAttr ¶ 

func (e *ST_SortMethod) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_SortMethod) Validate ¶ 

func (m ST_SortMethod) Validate() error

func (ST_SortMethod) ValidateWithPath ¶ 

func (m ST_SortMethod) ValidateWithPath(path string) error

type ST_SortType ¶ 

type ST_SortType byte
const (
	ST_SortTypeUnset             ST_SortType = 0
	ST_SortTypeNone              ST_SortType = 1
	ST_SortTypeAscending         ST_SortType = 2
	ST_SortTypeDescending        ST_SortType = 3
	ST_SortTypeAscendingAlpha    ST_SortType = 4
	ST_SortTypeDescendingAlpha   ST_SortType = 5
	ST_SortTypeAscendingNatural  ST_SortType = 6
	ST_SortTypeDescendingNatural ST_SortType = 7
)

func (ST_SortType) MarshalXML ¶ 

func (m ST_SortType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_SortType) MarshalXMLAttr ¶ 

func (e ST_SortType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_SortType) String ¶ 

func (m ST_SortType) String() string

func (*ST_SortType) UnmarshalXML ¶ 

func (m *ST_SortType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_SortType) UnmarshalXMLAttr ¶ 

func (e *ST_SortType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_SortType) Validate ¶ 

func (m ST_SortType) Validate() error

func (ST_SortType) ValidateWithPath ¶ 

func (m ST_SortType) ValidateWithPath(path string) error

type ST_SourceType ¶ 

type ST_SourceType byte
const (
	ST_SourceTypeUnset         ST_SourceType = 0
	ST_SourceTypeWorksheet     ST_SourceType = 1
	ST_SourceTypeExternal      ST_SourceType = 2
	ST_SourceTypeConsolidation ST_SourceType = 3
	ST_SourceTypeScenario      ST_SourceType = 4
)

func (ST_SourceType) MarshalXML ¶ 

func (m ST_SourceType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_SourceType) MarshalXMLAttr ¶ 

func (e ST_SourceType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_SourceType) String ¶ 

func (m ST_SourceType) String() string

func (*ST_SourceType) UnmarshalXML ¶ 

func (m *ST_SourceType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_SourceType) UnmarshalXMLAttr ¶ 

func (e *ST_SourceType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_SourceType) Validate ¶ 

func (m ST_SourceType) Validate() error

func (ST_SourceType) ValidateWithPath ¶ 

func (m ST_SourceType) ValidateWithPath(path string) error

type ST_Sqref ¶ 

type ST_Sqref []string

func ParseSliceST_Sqref ¶ 

func ParseSliceST_Sqref(s string) (ST_Sqref, error)

func (ST_Sqref) String ¶ 

func (s ST_Sqref) String() string

type ST_TableStyleType ¶ 

type ST_TableStyleType byte
const (
	ST_TableStyleTypeUnset                  ST_TableStyleType = 0
	ST_TableStyleTypeWholeTable             ST_TableStyleType = 1
	ST_TableStyleTypeHeaderRow              ST_TableStyleType = 2
	ST_TableStyleTypeTotalRow               ST_TableStyleType = 3
	ST_TableStyleTypeFirstColumn            ST_TableStyleType = 4
	ST_TableStyleTypeLastColumn             ST_TableStyleType = 5
	ST_TableStyleTypeFirstRowStripe         ST_TableStyleType = 6
	ST_TableStyleTypeSecondRowStripe        ST_TableStyleType = 7
	ST_TableStyleTypeFirstColumnStripe      ST_TableStyleType = 8
	ST_TableStyleTypeSecondColumnStripe     ST_TableStyleType = 9
	ST_TableStyleTypeFirstHeaderCell        ST_TableStyleType = 10
	ST_TableStyleTypeLastHeaderCell         ST_TableStyleType = 11
	ST_TableStyleTypeFirstTotalCell         ST_TableStyleType = 12
	ST_TableStyleTypeLastTotalCell          ST_TableStyleType = 13
	ST_TableStyleTypeFirstSubtotalColumn    ST_TableStyleType = 14
	ST_TableStyleTypeSecondSubtotalColumn   ST_TableStyleType = 15
	ST_TableStyleTypeThirdSubtotalColumn    ST_TableStyleType = 16
	ST_TableStyleTypeFirstSubtotalRow       ST_TableStyleType = 17
	ST_TableStyleTypeSecondSubtotalRow      ST_TableStyleType = 18
	ST_TableStyleTypeThirdSubtotalRow       ST_TableStyleType = 19
	ST_TableStyleTypeBlankRow               ST_TableStyleType = 20
	ST_TableStyleTypeFirstColumnSubheading  ST_TableStyleType = 21
	ST_TableStyleTypeSecondColumnSubheading ST_TableStyleType = 22
	ST_TableStyleTypeThirdColumnSubheading  ST_TableStyleType = 23
	ST_TableStyleTypeFirstRowSubheading     ST_TableStyleType = 24
	ST_TableStyleTypeSecondRowSubheading    ST_TableStyleType = 25
	ST_TableStyleTypeThirdRowSubheading     ST_TableStyleType = 26
	ST_TableStyleTypePageFieldLabels        ST_TableStyleType = 27
	ST_TableStyleTypePageFieldValues        ST_TableStyleType = 28
)

func (ST_TableStyleType) MarshalXML ¶ 

func (m ST_TableStyleType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TableStyleType) MarshalXMLAttr ¶ 

func (e ST_TableStyleType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TableStyleType) String ¶ 

func (m ST_TableStyleType) String() string

func (*ST_TableStyleType) UnmarshalXML ¶ 

func (m *ST_TableStyleType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TableStyleType) UnmarshalXMLAttr ¶ 

func (e *ST_TableStyleType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TableStyleType) Validate ¶ 

func (m ST_TableStyleType) Validate() error

func (ST_TableStyleType) ValidateWithPath ¶ 

func (m ST_TableStyleType) ValidateWithPath(path string) error

type ST_TableType ¶ 

type ST_TableType byte
const (
	ST_TableTypeUnset      ST_TableType = 0
	ST_TableTypeWorksheet  ST_TableType = 1
	ST_TableTypeXml        ST_TableType = 2
	ST_TableTypeQueryTable ST_TableType = 3
)

func (ST_TableType) MarshalXML ¶ 

func (m ST_TableType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TableType) MarshalXMLAttr ¶ 

func (e ST_TableType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TableType) String ¶ 

func (m ST_TableType) String() string

func (*ST_TableType) UnmarshalXML ¶ 

func (m *ST_TableType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TableType) UnmarshalXMLAttr ¶ 

func (e *ST_TableType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TableType) Validate ¶ 

func (m ST_TableType) Validate() error

func (ST_TableType) ValidateWithPath ¶ 

func (m ST_TableType) ValidateWithPath(path string) error

type ST_TargetScreenSize ¶ 

type ST_TargetScreenSize byte
const (
	ST_TargetScreenSizeUnset     ST_TargetScreenSize = 0
	ST_TargetScreenSize544x376   ST_TargetScreenSize = 1
	ST_TargetScreenSize640x480   ST_TargetScreenSize = 2
	ST_TargetScreenSize720x512   ST_TargetScreenSize = 3
	ST_TargetScreenSize800x600   ST_TargetScreenSize = 4
	ST_TargetScreenSize1024x768  ST_TargetScreenSize = 5
	ST_TargetScreenSize1152x882  ST_TargetScreenSize = 6
	ST_TargetScreenSize1152x900  ST_TargetScreenSize = 7
	ST_TargetScreenSize1280x1024 ST_TargetScreenSize = 8
	ST_TargetScreenSize1600x1200 ST_TargetScreenSize = 9
	ST_TargetScreenSize1800x1440 ST_TargetScreenSize = 10
	ST_TargetScreenSize1920x1200 ST_TargetScreenSize = 11
)

func (ST_TargetScreenSize) MarshalXML ¶ 

func (m ST_TargetScreenSize) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TargetScreenSize) MarshalXMLAttr ¶ 

func (e ST_TargetScreenSize) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TargetScreenSize) String ¶ 

func (m ST_TargetScreenSize) String() string

func (*ST_TargetScreenSize) UnmarshalXML ¶ 

func (m *ST_TargetScreenSize) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TargetScreenSize) UnmarshalXMLAttr ¶ 

func (e *ST_TargetScreenSize) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TargetScreenSize) Validate ¶ 

func (m ST_TargetScreenSize) Validate() error

func (ST_TargetScreenSize) ValidateWithPath ¶ 

func (m ST_TargetScreenSize) ValidateWithPath(path string) error

type ST_TextHAlign ¶ 

type ST_TextHAlign byte
const (
	ST_TextHAlignUnset       ST_TextHAlign = 0
	ST_TextHAlignLeft        ST_TextHAlign = 1
	ST_TextHAlignCenter      ST_TextHAlign = 2
	ST_TextHAlignRight       ST_TextHAlign = 3
	ST_TextHAlignJustify     ST_TextHAlign = 4
	ST_TextHAlignDistributed ST_TextHAlign = 5
)

func (ST_TextHAlign) MarshalXML ¶ 

func (m ST_TextHAlign) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TextHAlign) MarshalXMLAttr ¶ 

func (e ST_TextHAlign) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TextHAlign) String ¶ 

func (m ST_TextHAlign) String() string

func (*ST_TextHAlign) UnmarshalXML ¶ 

func (m *ST_TextHAlign) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TextHAlign) UnmarshalXMLAttr ¶ 

func (e *ST_TextHAlign) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TextHAlign) Validate ¶ 

func (m ST_TextHAlign) Validate() error

func (ST_TextHAlign) ValidateWithPath ¶ 

func (m ST_TextHAlign) ValidateWithPath(path string) error

type ST_TextVAlign ¶ 

type ST_TextVAlign byte
const (
	ST_TextVAlignUnset       ST_TextVAlign = 0
	ST_TextVAlignTop         ST_TextVAlign = 1
	ST_TextVAlignCenter      ST_TextVAlign = 2
	ST_TextVAlignBottom      ST_TextVAlign = 3
	ST_TextVAlignJustify     ST_TextVAlign = 4
	ST_TextVAlignDistributed ST_TextVAlign = 5
)

func (ST_TextVAlign) MarshalXML ¶ 

func (m ST_TextVAlign) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TextVAlign) MarshalXMLAttr ¶ 

func (e ST_TextVAlign) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TextVAlign) String ¶ 

func (m ST_TextVAlign) String() string

func (*ST_TextVAlign) UnmarshalXML ¶ 

func (m *ST_TextVAlign) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TextVAlign) UnmarshalXMLAttr ¶ 

func (e *ST_TextVAlign) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TextVAlign) Validate ¶ 

func (m ST_TextVAlign) Validate() error

func (ST_TextVAlign) ValidateWithPath ¶ 

func (m ST_TextVAlign) ValidateWithPath(path string) error

type ST_TimePeriod ¶ 

type ST_TimePeriod byte
const (
	ST_TimePeriodUnset     ST_TimePeriod = 0
	ST_TimePeriodToday     ST_TimePeriod = 1
	ST_TimePeriodYesterday ST_TimePeriod = 2
	ST_TimePeriodTomorrow  ST_TimePeriod = 3
	ST_TimePeriodLast7Days ST_TimePeriod = 4
	ST_TimePeriodThisMonth ST_TimePeriod = 5
	ST_TimePeriodLastMonth ST_TimePeriod = 6
	ST_TimePeriodNextMonth ST_TimePeriod = 7
	ST_TimePeriodThisWeek  ST_TimePeriod = 8
	ST_TimePeriodLastWeek  ST_TimePeriod = 9
	ST_TimePeriodNextWeek  ST_TimePeriod = 10
)

func (ST_TimePeriod) MarshalXML ¶ 

func (m ST_TimePeriod) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TimePeriod) MarshalXMLAttr ¶ 

func (e ST_TimePeriod) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TimePeriod) String ¶ 

func (m ST_TimePeriod) String() string

func (*ST_TimePeriod) UnmarshalXML ¶ 

func (m *ST_TimePeriod) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TimePeriod) UnmarshalXMLAttr ¶ 

func (e *ST_TimePeriod) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TimePeriod) Validate ¶ 

func (m ST_TimePeriod) Validate() error

func (ST_TimePeriod) ValidateWithPath ¶ 

func (m ST_TimePeriod) ValidateWithPath(path string) error

type ST_TotalsRowFunction ¶ 

type ST_TotalsRowFunction byte
const (
	ST_TotalsRowFunctionUnset     ST_TotalsRowFunction = 0
	ST_TotalsRowFunctionNone      ST_TotalsRowFunction = 1
	ST_TotalsRowFunctionSum       ST_TotalsRowFunction = 2
	ST_TotalsRowFunctionMin       ST_TotalsRowFunction = 3
	ST_TotalsRowFunctionMax       ST_TotalsRowFunction = 4
	ST_TotalsRowFunctionAverage   ST_TotalsRowFunction = 5
	ST_TotalsRowFunctionCount     ST_TotalsRowFunction = 6
	ST_TotalsRowFunctionCountNums ST_TotalsRowFunction = 7
	ST_TotalsRowFunctionStdDev    ST_TotalsRowFunction = 8
	ST_TotalsRowFunctionVar       ST_TotalsRowFunction = 9
	ST_TotalsRowFunctionCustom    ST_TotalsRowFunction = 10
)

func (ST_TotalsRowFunction) MarshalXML ¶ 

func (m ST_TotalsRowFunction) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_TotalsRowFunction) MarshalXMLAttr ¶ 

func (e ST_TotalsRowFunction) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_TotalsRowFunction) String ¶ 

func (m ST_TotalsRowFunction) String() string

func (*ST_TotalsRowFunction) UnmarshalXML ¶ 

func (m *ST_TotalsRowFunction) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_TotalsRowFunction) UnmarshalXMLAttr ¶ 

func (e *ST_TotalsRowFunction) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_TotalsRowFunction) Validate ¶ 

func (m ST_TotalsRowFunction) Validate() error

func (ST_TotalsRowFunction) ValidateWithPath ¶ 

func (m ST_TotalsRowFunction) ValidateWithPath(path string) error

type ST_Type ¶ 

type ST_Type byte
const (
	ST_TypeUnset  ST_Type = 0
	ST_TypeNone   ST_Type = 1
	ST_TypeAll    ST_Type = 2
	ST_TypeRow    ST_Type = 3
	ST_TypeColumn ST_Type = 4
)

func (ST_Type) MarshalXML ¶ 

func (m ST_Type) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Type) MarshalXMLAttr ¶ 

func (e ST_Type) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Type) String ¶ 

func (m ST_Type) String() string

func (*ST_Type) UnmarshalXML ¶ 

func (m *ST_Type) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Type) UnmarshalXMLAttr ¶ 

func (e *ST_Type) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Type) Validate ¶ 

func (m ST_Type) Validate() error

func (ST_Type) ValidateWithPath ¶ 

func (m ST_Type) ValidateWithPath(path string) error

type ST_UnderlineValues ¶ 

type ST_UnderlineValues byte
const (
	ST_UnderlineValuesUnset            ST_UnderlineValues = 0
	ST_UnderlineValuesSingle           ST_UnderlineValues = 1
	ST_UnderlineValuesDouble           ST_UnderlineValues = 2
	ST_UnderlineValuesSingleAccounting ST_UnderlineValues = 3
	ST_UnderlineValuesDoubleAccounting ST_UnderlineValues = 4
	ST_UnderlineValuesNone             ST_UnderlineValues = 5
)

func (ST_UnderlineValues) MarshalXML ¶ 

func (m ST_UnderlineValues) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_UnderlineValues) MarshalXMLAttr ¶ 

func (e ST_UnderlineValues) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_UnderlineValues) String ¶ 

func (m ST_UnderlineValues) String() string

func (*ST_UnderlineValues) UnmarshalXML ¶ 

func (m *ST_UnderlineValues) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_UnderlineValues) UnmarshalXMLAttr ¶ 

func (e *ST_UnderlineValues) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_UnderlineValues) Validate ¶ 

func (m ST_UnderlineValues) Validate() error

func (ST_UnderlineValues) ValidateWithPath ¶ 

func (m ST_UnderlineValues) ValidateWithPath(path string) error
type ST_UpdateLinks byte
const (
	ST_UpdateLinksUnset   ST_UpdateLinks = 0
	ST_UpdateLinksUserSet ST_UpdateLinks = 1
	ST_UpdateLinksNever   ST_UpdateLinks = 2
	ST_UpdateLinksAlways  ST_UpdateLinks = 3
)

func (ST_UpdateLinks) MarshalXML ¶ 

func (m ST_UpdateLinks) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_UpdateLinks) MarshalXMLAttr ¶ 

func (e ST_UpdateLinks) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_UpdateLinks) String ¶ 

func (m ST_UpdateLinks) String() string

func (*ST_UpdateLinks) UnmarshalXML ¶ 

func (m *ST_UpdateLinks) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_UpdateLinks) UnmarshalXMLAttr ¶ 

func (e *ST_UpdateLinks) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_UpdateLinks) Validate ¶ 

func (m ST_UpdateLinks) Validate() error

func (ST_UpdateLinks) ValidateWithPath ¶ 

func (m ST_UpdateLinks) ValidateWithPath(path string) error

type ST_VerticalAlignment ¶ 

type ST_VerticalAlignment byte
const (
	ST_VerticalAlignmentUnset       ST_VerticalAlignment = 0
	ST_VerticalAlignmentTop         ST_VerticalAlignment = 1
	ST_VerticalAlignmentCenter      ST_VerticalAlignment = 2
	ST_VerticalAlignmentBottom      ST_VerticalAlignment = 3
	ST_VerticalAlignmentJustify     ST_VerticalAlignment = 4
	ST_VerticalAlignmentDistributed ST_VerticalAlignment = 5
)

func (ST_VerticalAlignment) MarshalXML ¶ 

func (m ST_VerticalAlignment) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_VerticalAlignment) MarshalXMLAttr ¶ 

func (e ST_VerticalAlignment) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_VerticalAlignment) String ¶ 

func (m ST_VerticalAlignment) String() string

func (*ST_VerticalAlignment) UnmarshalXML ¶ 

func (m *ST_VerticalAlignment) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_VerticalAlignment) UnmarshalXMLAttr ¶ 

func (e *ST_VerticalAlignment) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_VerticalAlignment) Validate ¶ 

func (m ST_VerticalAlignment) Validate() error

func (ST_VerticalAlignment) ValidateWithPath ¶ 

func (m ST_VerticalAlignment) ValidateWithPath(path string) error

type ST_Visibility ¶ 

type ST_Visibility byte
const (
	ST_VisibilityUnset      ST_Visibility = 0
	ST_VisibilityVisible    ST_Visibility = 1
	ST_VisibilityHidden     ST_Visibility = 2
	ST_VisibilityVeryHidden ST_Visibility = 3
)

func (ST_Visibility) MarshalXML ¶ 

func (m ST_Visibility) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_Visibility) MarshalXMLAttr ¶ 

func (e ST_Visibility) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_Visibility) String ¶ 

func (m ST_Visibility) String() string

func (*ST_Visibility) UnmarshalXML ¶ 

func (m *ST_Visibility) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_Visibility) UnmarshalXMLAttr ¶ 

func (e *ST_Visibility) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_Visibility) Validate ¶ 

func (m ST_Visibility) Validate() error

func (ST_Visibility) ValidateWithPath ¶ 

func (m ST_Visibility) ValidateWithPath(path string) error

type ST_VolDepType ¶ 

type ST_VolDepType byte
const (
	ST_VolDepTypeUnset         ST_VolDepType = 0
	ST_VolDepTypeRealTimeData  ST_VolDepType = 1
	ST_VolDepTypeOlapFunctions ST_VolDepType = 2
)

func (ST_VolDepType) MarshalXML ¶ 

func (m ST_VolDepType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_VolDepType) MarshalXMLAttr ¶ 

func (e ST_VolDepType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_VolDepType) String ¶ 

func (m ST_VolDepType) String() string

func (*ST_VolDepType) UnmarshalXML ¶ 

func (m *ST_VolDepType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_VolDepType) UnmarshalXMLAttr ¶ 

func (e *ST_VolDepType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_VolDepType) Validate ¶ 

func (m ST_VolDepType) Validate() error

func (ST_VolDepType) ValidateWithPath ¶ 

func (m ST_VolDepType) ValidateWithPath(path string) error

type ST_VolValueType ¶ 

type ST_VolValueType byte
const (
	ST_VolValueTypeUnset ST_VolValueType = 0
	ST_VolValueTypeB     ST_VolValueType = 1
	ST_VolValueTypeN     ST_VolValueType = 2
	ST_VolValueTypeE     ST_VolValueType = 3
	ST_VolValueTypeS     ST_VolValueType = 4
)

func (ST_VolValueType) MarshalXML ¶ 

func (m ST_VolValueType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_VolValueType) MarshalXMLAttr ¶ 

func (e ST_VolValueType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_VolValueType) String ¶ 

func (m ST_VolValueType) String() string

func (*ST_VolValueType) UnmarshalXML ¶ 

func (m *ST_VolValueType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_VolValueType) UnmarshalXMLAttr ¶ 

func (e *ST_VolValueType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_VolValueType) Validate ¶ 

func (m ST_VolValueType) Validate() error

func (ST_VolValueType) ValidateWithPath ¶ 

func (m ST_VolValueType) ValidateWithPath(path string) error

type ST_WebSourceType ¶ 

type ST_WebSourceType byte
const (
	ST_WebSourceTypeUnset      ST_WebSourceType = 0
	ST_WebSourceTypeSheet      ST_WebSourceType = 1
	ST_WebSourceTypePrintArea  ST_WebSourceType = 2
	ST_WebSourceTypeAutoFilter ST_WebSourceType = 3
	ST_WebSourceTypeRange      ST_WebSourceType = 4
	ST_WebSourceTypeChart      ST_WebSourceType = 5
	ST_WebSourceTypePivotTable ST_WebSourceType = 6
	ST_WebSourceTypeQuery      ST_WebSourceType = 7
	ST_WebSourceTypeLabel      ST_WebSourceType = 8
)

func (ST_WebSourceType) MarshalXML ¶ 

func (m ST_WebSourceType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_WebSourceType) MarshalXMLAttr ¶ 

func (e ST_WebSourceType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_WebSourceType) String ¶ 

func (m ST_WebSourceType) String() string

func (*ST_WebSourceType) UnmarshalXML ¶ 

func (m *ST_WebSourceType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_WebSourceType) UnmarshalXMLAttr ¶ 

func (e *ST_WebSourceType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_WebSourceType) Validate ¶ 

func (m ST_WebSourceType) Validate() error

func (ST_WebSourceType) ValidateWithPath ¶ 

func (m ST_WebSourceType) ValidateWithPath(path string) error

type ST_rwColActionType ¶ 

type ST_rwColActionType byte
const (
	ST_rwColActionTypeUnset     ST_rwColActionType = 0
	ST_rwColActionTypeInsertRow ST_rwColActionType = 1
	ST_rwColActionTypeDeleteRow ST_rwColActionType = 2
	ST_rwColActionTypeInsertCol ST_rwColActionType = 3
	ST_rwColActionTypeDeleteCol ST_rwColActionType = 4
)

func (ST_rwColActionType) MarshalXML ¶ 

func (m ST_rwColActionType) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (ST_rwColActionType) MarshalXMLAttr ¶ 

func (e ST_rwColActionType) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (ST_rwColActionType) String ¶ 

func (m ST_rwColActionType) String() string

func (*ST_rwColActionType) UnmarshalXML ¶ 

func (m *ST_rwColActionType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*ST_rwColActionType) UnmarshalXMLAttr ¶ 

func (e *ST_rwColActionType) UnmarshalXMLAttr(attr xml.Attr) error

func (ST_rwColActionType) Validate ¶ 

func (m ST_rwColActionType) Validate() error

func (ST_rwColActionType) ValidateWithPath ¶ 

func (m ST_rwColActionType) ValidateWithPath(path string) error

type SingleXmlCells ¶ 

type SingleXmlCells struct {
	CT_SingleXmlCells
}

func NewSingleXmlCells ¶ 

func NewSingleXmlCells() *SingleXmlCells

func (*SingleXmlCells) MarshalXML ¶ 

func (m *SingleXmlCells) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*SingleXmlCells) UnmarshalXML ¶ 

func (m *SingleXmlCells) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*SingleXmlCells) Validate ¶ 

func (m *SingleXmlCells) Validate() error

Validate validates the SingleXmlCells and its children

func (*SingleXmlCells) ValidateWithPath ¶ 

func (m *SingleXmlCells) ValidateWithPath(path string) error

ValidateWithPath validates the SingleXmlCells and its children, prefixing error messages with path

type Sst ¶ 

type Sst struct {
	CT_Sst
}

func NewSst ¶ 

func NewSst() *Sst

func (*Sst) MarshalXML ¶ 

func (m *Sst) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Sst) UnmarshalXML ¶ 

func (m *Sst) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Sst) Validate ¶ 

func (m *Sst) Validate() error

Validate validates the Sst and its children

func (*Sst) ValidateWithPath ¶ 

func (m *Sst) ValidateWithPath(path string) error

ValidateWithPath validates the Sst and its children, prefixing error messages with path

type StyleSheet ¶ 

type StyleSheet struct {
	CT_Stylesheet
}

func NewStyleSheet ¶ 

func NewStyleSheet() *StyleSheet

func (*StyleSheet) MarshalXML ¶ 

func (m *StyleSheet) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*StyleSheet) UnmarshalXML ¶ 

func (m *StyleSheet) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*StyleSheet) Validate ¶ 

func (m *StyleSheet) Validate() error

Validate validates the StyleSheet and its children

func (*StyleSheet) ValidateWithPath ¶ 

func (m *StyleSheet) ValidateWithPath(path string) error

ValidateWithPath validates the StyleSheet and its children, prefixing error messages with path

type Table ¶ 

type Table struct {
	CT_Table
}

func NewTable ¶ 

func NewTable() *Table

func (*Table) MarshalXML ¶ 

func (m *Table) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Table) UnmarshalXML ¶ 

func (m *Table) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Table) Validate ¶ 

func (m *Table) Validate() error

Validate validates the Table and its children

func (*Table) ValidateWithPath ¶ 

func (m *Table) ValidateWithPath(path string) error

ValidateWithPath validates the Table and its children, prefixing error messages with path

type Users ¶ 

type Users struct {
	CT_Users
}

func NewUsers ¶ 

func NewUsers() *Users

func (*Users) MarshalXML ¶ 

func (m *Users) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Users) UnmarshalXML ¶ 

func (m *Users) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Users) Validate ¶ 

func (m *Users) Validate() error

Validate validates the Users and its children

func (*Users) ValidateWithPath ¶ 

func (m *Users) ValidateWithPath(path string) error

ValidateWithPath validates the Users and its children, prefixing error messages with path

type VolTypes ¶ 

type VolTypes struct {
	CT_VolTypes
}

func NewVolTypes ¶ 

func NewVolTypes() *VolTypes

func (*VolTypes) MarshalXML ¶ 

func (m *VolTypes) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*VolTypes) UnmarshalXML ¶ 

func (m *VolTypes) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*VolTypes) Validate ¶ 

func (m *VolTypes) Validate() error

Validate validates the VolTypes and its children

func (*VolTypes) ValidateWithPath ¶ 

func (m *VolTypes) ValidateWithPath(path string) error

ValidateWithPath validates the VolTypes and its children, prefixing error messages with path

type Workbook ¶ 

type Workbook struct {
	CT_Workbook
}

func NewWorkbook ¶ 

func NewWorkbook() *Workbook

func (*Workbook) MarshalXML ¶ 

func (m *Workbook) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Workbook) UnmarshalXML ¶ 

func (m *Workbook) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Workbook) Validate ¶ 

func (m *Workbook) Validate() error

Validate validates the Workbook and its children

func (*Workbook) ValidateWithPath ¶ 

func (m *Workbook) ValidateWithPath(path string) error

ValidateWithPath validates the Workbook and its children, prefixing error messages with path

type Worksheet ¶ 

type Worksheet struct {
	CT_Worksheet
}

func NewWorksheet ¶ 

func NewWorksheet() *Worksheet

func (*Worksheet) MarshalXML ¶ 

func (m *Worksheet) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Worksheet) UnmarshalXML ¶ 

func (m *Worksheet) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

func (*Worksheet) Validate ¶ 

func (m *Worksheet) Validate() error

Validate validates the Worksheet and its children

func (*Worksheet) ValidateWithPath ¶ 

func (m *Worksheet) ValidateWithPath(path string) error

ValidateWithPath validates the Worksheet and its children, prefixing error messages with path

Source Files ¶

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.