Package sml

AG_AutoFormat.go AG_RevData.go CT_Authors.go CT_AutoFilter.go CT_AutoSortScope.go CT_BookView.go CT_BookViews.go CT_Boolean.go CT_BooleanProperty.go CT_Border.go CT_BorderPr.go CT_Borders.go CT_Break.go CT_CacheField.go CT_CacheFields.go CT_CacheHierarchies.go CT_CacheHierarchy.go CT_CacheSource.go CT_CalcCell.go CT_CalcChain.go CT_CalcPr.go CT_CalculatedItem.go CT_CalculatedItems.go CT_CalculatedMember.go CT_CalculatedMembers.go CT_Cell.go CT_CellAlignment.go CT_CellFormula.go CT_CellProtection.go CT_CellSmartTag.go CT_CellSmartTagPr.go CT_CellSmartTags.go CT_CellStyle.go CT_CellStyleXfs.go CT_CellStyles.go CT_CellWatch.go CT_CellWatches.go CT_CellXfs.go CT_CfRule.go CT_Cfvo.go CT_ChartFormat.go CT_ChartFormats.go CT_Chartsheet.go CT_ChartsheetPr.go CT_ChartsheetProtection.go CT_ChartsheetView.go CT_ChartsheetViews.go CT_Col.go CT_ColFields.go CT_ColHierarchiesUsage.go CT_Color.go CT_ColorFilter.go CT_ColorScale.go CT_Colors.go CT_Cols.go CT_Comment.go CT_CommentList.go CT_CommentPr.go CT_Comments.go CT_ConditionalFormat.go CT_ConditionalFormats.go CT_ConditionalFormatting.go CT_Connection.go CT_Connections.go CT_Consolidation.go CT_Control.go CT_ControlPr.go CT_Controls.go CT_CsPageSetup.go CT_CustomChartsheetView.go CT_CustomChartsheetViews.go CT_CustomFilter.go CT_CustomFilters.go CT_CustomProperties.go CT_CustomProperty.go CT_CustomSheetView.go CT_CustomSheetViews.go CT_CustomWorkbookView.go CT_CustomWorkbookViews.go CT_DataBar.go CT_DataBinding.go CT_DataConsolidate.go CT_DataField.go CT_DataFields.go CT_DataRef.go CT_DataRefs.go CT_DataValidation.go CT_DataValidations.go CT_DateGroupItem.go CT_DateTime.go CT_DbPr.go CT_DdeItem.go CT_DdeItems.go CT_DdeLink.go CT_DdeValue.go CT_DdeValues.go CT_DefinedName.go CT_DefinedNames.go CT_DeletedField.go CT_Dialogsheet.go CT_Dimensions.go CT_DiscretePr.go CT_Drawing.go CT_DrawingHF.go CT_Dxf.go CT_Dxfs.go CT_DynamicFilter.go CT_Error.go CT_Extension.go CT_ExtensionList.go CT_ExternalBook.go CT_ExternalCell.go CT_ExternalDefinedName.go CT_ExternalDefinedNames.go CT_ExternalLink.go CT_ExternalLinkChoice.go CT_ExternalReference.go CT_ExternalReferences.go CT_ExternalRow.go CT_ExternalSheetData.go CT_ExternalSheetDataSet.go CT_ExternalSheetName.go CT_ExternalSheetNames.go CT_Field.go CT_FieldGroup.go CT_FieldUsage.go CT_FieldsUsage.go CT_FileRecoveryPr.go CT_FileSharing.go CT_FileVersion.go CT_Fill.go CT_Fills.go CT_Filter.go CT_FilterColumn.go CT_Filters.go CT_Font.go CT_FontFamily.go CT_FontName.go CT_FontScheme.go CT_FontSize.go CT_Fonts.go CT_Format.go CT_Formats.go CT_FunctionGroup.go CT_FunctionGroups.go CT_FutureMetadata.go CT_FutureMetadataBlock.go CT_GradientFill.go CT_GradientStop.go CT_GroupItems.go CT_GroupLevel.go CT_GroupLevels.go CT_GroupMember.go CT_GroupMembers.go CT_Groups.go CT_HeaderFooter.go CT_HierarchyUsage.go CT_Hyperlink.go CT_Hyperlinks.go CT_I.go CT_IconFilter.go CT_IconSet.go CT_IgnoredError.go CT_IgnoredErrors.go CT_Index.go CT_IndexedColors.go CT_InputCells.go CT_IntProperty.go CT_Item.go CT_Items.go CT_LegacyDrawing.go CT_LevelGroup.go CT_Location.go CT_MRUColors.go CT_Macrosheet.go CT_Map.go CT_MapInfo.go CT_Mdx.go CT_MdxKPI.go CT_MdxMemeberProp.go CT_MdxMetadata.go CT_MdxSet.go CT_MdxTuple.go CT_MeasureDimensionMap.go CT_MeasureDimensionMaps.go CT_MeasureGroup.go CT_MeasureGroups.go CT_Member.go CT_MemberProperties.go CT_MemberProperty.go CT_Members.go CT_MergeCell.go CT_MergeCells.go CT_Metadata.go CT_MetadataBlock.go CT_MetadataBlocks.go CT_MetadataRecord.go CT_MetadataStringIndex.go CT_MetadataStrings.go CT_MetadataType.go CT_MetadataTypes.go CT_Missing.go CT_NumFmt.go CT_NumFmts.go CT_Number.go CT_ObjectAnchor.go CT_ObjectPr.go CT_OlapPr.go CT_OleItem.go CT_OleItems.go CT_OleLink.go CT_OleObject.go CT_OleObjects.go CT_OleSize.go CT_OutlinePr.go CT_PCDKPI.go CT_PCDKPIs.go CT_PCDSCPage.go CT_PCDSDTCEntries.go CT_PageBreak.go CT_PageField.go CT_PageFields.go CT_PageItem.go CT_PageMargins.go CT_PageSetUpPr.go CT_PageSetup.go CT_Pages.go CT_Pane.go CT_Parameter.go CT_Parameters.go CT_PatternFill.go CT_PhoneticPr.go CT_PhoneticRun.go CT_PivotArea.go CT_PivotAreaReference.go CT_PivotAreaReferences.go CT_PivotAreas.go CT_PivotCache.go CT_PivotCacheDefinition.go CT_PivotCacheRecords.go CT_PivotCaches.go CT_PivotDimension.go CT_PivotField.go CT_PivotFields.go CT_PivotFilter.go CT_PivotFilters.go CT_PivotHierarchies.go CT_PivotHierarchy.go CT_PivotSelection.go CT_PivotTableStyle.go CT_PrintOptions.go CT_ProtectedRange.go CT_ProtectedRanges.go CT_Query.go CT_QueryCache.go CT_QueryTable.go CT_QueryTableDeletedFields.go CT_QueryTableField.go CT_QueryTableFields.go CT_QueryTableRefresh.go CT_RElt.go CT_RPrElt.go CT_RangePr.go CT_RangeSet.go CT_RangeSets.go CT_Record.go CT_Reviewed.go CT_ReviewedRevisions.go CT_RevisionAutoFormatting.go CT_RevisionCellChange.go CT_RevisionComment.go CT_RevisionConflict.go CT_RevisionCustomView.go CT_RevisionDefinedName.go CT_RevisionFormatting.go CT_RevisionHeader.go CT_RevisionHeaders.go CT_RevisionInsertSheet.go CT_RevisionMove.go CT_RevisionQueryTableField.go CT_RevisionRowColumn.go CT_RevisionSheetRename.go CT_Revisions.go CT_RgbColor.go CT_Row.go CT_RowFields.go CT_RowHierarchiesUsage.go CT_Rst.go CT_Scenario.go CT_Scenarios.go CT_Schema.go CT_Selection.go CT_ServerFormat.go CT_ServerFormats.go CT_Set.go CT_Sets.go CT_SharedItems.go CT_SharedUser.go CT_Sheet.go CT_SheetBackgroundPicture.go CT_SheetCalcPr.go CT_SheetData.go CT_SheetDimension.go CT_SheetFormatPr.go CT_SheetId.go CT_SheetIdMap.go CT_SheetPr.go CT_SheetProtection.go CT_SheetView.go CT_SheetViews.go CT_Sheets.go CT_SingleXmlCell.go CT_SingleXmlCells.go CT_SmartTagPr.go CT_SmartTagType.go CT_SmartTagTypes.go CT_SmartTags.go CT_SortCondition.go CT_SortState.go CT_Sst.go CT_String.go CT_Stylesheet.go CT_Table.go CT_TableColumn.go CT_TableColumns.go CT_TableFormula.go CT_TableMissing.go CT_TablePart.go CT_TableParts.go CT_TableStyle.go CT_TableStyleElement.go CT_TableStyleInfo.go CT_TableStyles.go CT_Tables.go CT_TextField.go CT_TextFields.go CT_TextPr.go CT_Top10.go CT_Tuple.go CT_TupleCache.go CT_Tuples.go CT_UnderlineProperty.go CT_UndoInfo.go CT_Users.go CT_VerticalAlignFontProperty.go CT_VolMain.go CT_VolTopic.go CT_VolTopicRef.go CT_VolType.go CT_VolTypes.go CT_WebPr.go CT_WebPublishItem.go CT_WebPublishItems.go CT_WebPublishObject.go CT_WebPublishObjects.go CT_WebPublishing.go CT_Workbook.go CT_WorkbookPr.go CT_WorkbookProtection.go CT_Worksheet.go CT_WorksheetSource.go CT_X.go CT_XStringElement.go CT_Xf.go CT_XmlCellPr.go CT_XmlColumnPr.go CT_XmlPr.go CT_colItems.go CT_pivotTableDefinition.go CT_rowItems.go CalcChain.go Chartsheet.go Comments.go Connections.go Dialogsheet.go EG_ExtensionList.go ExternalLink.go Headers.go MapInfo.go Metadata.go PivotCacheDefinition.go PivotCacheRecords.go PivotTableDefinition.go QueryTable.go Revisions.go SingleXmlCells.go Sst.go StyleSheet.go Table.go Users.go VolTypes.go Workbook.go Worksheet.go common.go

func ParseStdlibTime ¶

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

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 *uint8
    // 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 References
    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                     unioffice.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 ¶

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

func NewCT_DdeLink ¶

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     unioffice.Any
}

func NewCT_Extension ¶

func NewCT_Extension() *CT_Extension

func (*CT_Extension) MarshalXML ¶

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

func (*CT_Extension) UnmarshalXML ¶

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

func (*CT_Extension) Validate ¶

func (m *CT_Extension) Validate() error

Validate validates the CT_Extension and its children

func (*CT_Extension) ValidateWithPath ¶

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

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

type CT_ExtensionList ¶

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

func NewCT_ExtensionList ¶

func NewCT_ExtensionList() *CT_ExtensionList

func (*CT_ExtensionList) MarshalXML ¶

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

func (*CT_ExtensionList) UnmarshalXML ¶

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

func (*CT_ExtensionList) Validate ¶

func (m *CT_ExtensionList) Validate() error

Validate validates the CT_ExtensionList and its children

func (*CT_ExtensionList) ValidateWithPath ¶

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

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

type CT_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 ¶

type CT_ExternalLink struct {
    Choice *CT_ExternalLinkChoice
    ExtLst *CT_ExtensionList
}

func NewCT_ExternalLink ¶

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 ¶

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

func NewCT_Hyperlink ¶

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 ¶

type CT_Hyperlinks struct {
    // Hyperlink
    Hyperlink []*CT_Hyperlink
}

func NewCT_Hyperlinks ¶

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.