1 files changed, 965 insertions, 0 deletions
diff --git a/.venv/lib/python3.12/site-packages/openpyxl/pivot/cache.py b/.venv/lib/python3.12/site-packages/openpyxl/pivot/cache.py
new file mode 100644
index 00000000..7ae2b4dd
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/openpyxl/pivot/cache.py
@@ -0,0 +1,965 @@
+# Copyright (c) 2010-2024 openpyxl
+
+from openpyxl.descriptors.serialisable import Serialisable
+from openpyxl.descriptors import (
+    Typed,
+    Bool,
+    Float,
+    Set,
+    NoneSet,
+    String,
+    Integer,
+    DateTime,
+    Sequence,
+)
+
+from openpyxl.descriptors.excel import (
+    HexBinary,
+    ExtensionList,
+    Relation,
+)
+from openpyxl.descriptors.nested import NestedInteger
+from openpyxl.descriptors.sequence import (
+    NestedSequence,
+    MultiSequence,
+    MultiSequencePart,
+)
+from openpyxl.xml.constants import SHEET_MAIN_NS
+from openpyxl.xml.functions import tostring
+from openpyxl.packaging.relationship import (
+    RelationshipList,
+    Relationship,
+    get_rels_path
+)
+
+from .table import (
+    PivotArea,
+    Reference,
+)
+from .fields import (
+    Boolean,
+    Error,
+    Missing,
+    Number,
+    Text,
+    TupleList,
+    DateTimeField,
+)
+
+class MeasureDimensionMap(Serialisable):
+
+    tagname = "map"
+
+    measureGroup = Integer(allow_none=True)
+    dimension = Integer(allow_none=True)
+
+    def __init__(self,
+                 measureGroup=None,
+                 dimension=None,
+                ):
+        self.measureGroup = measureGroup
+        self.dimension = dimension
+
+
+class MeasureGroup(Serialisable):
+
+    tagname = "measureGroup"
+
+    name = String()
+    caption = String()
+
+    def __init__(self,
+                 name=None,
+                 caption=None,
+                ):
+        self.name = name
+        self.caption = caption
+
+
+class PivotDimension(Serialisable):
+
+    tagname = "dimension"
+
+    measure = Bool()
+    name = String()
+    uniqueName = String()
+    caption = String()
+
+    def __init__(self,
+                 measure=None,
+                 name=None,
+                 uniqueName=None,
+                 caption=None,
+                ):
+        self.measure = measure
+        self.name = name
+        self.uniqueName = uniqueName
+        self.caption = caption
+
+
+class CalculatedMember(Serialisable):
+
+    tagname = "calculatedMember"
+
+    name = String()
+    mdx = String()
+    memberName = String(allow_none=True)
+    hierarchy = String(allow_none=True)
+    parent = String(allow_none=True)
+    solveOrder = Integer(allow_none=True)
+    set = Bool()
+    extLst = Typed(expected_type=ExtensionList, allow_none=True)
+
+    __elements__ = ()
+
+    def __init__(self,
+                 name=None,
+                 mdx=None,
+                 memberName=None,
+                 hierarchy=None,
+                 parent=None,
+                 solveOrder=None,
+                 set=None,
+                 extLst=None,
+                ):
+        self.name = name
+        self.mdx = mdx
+        self.memberName = memberName
+        self.hierarchy = hierarchy
+        self.parent = parent
+        self.solveOrder = solveOrder
+        self.set = set
+        #self.extLst = extLst
+
+
+class CalculatedItem(Serialisable):
+
+    tagname = "calculatedItem"
+
+    field = Integer(allow_none=True)
+    formula = String()
+    pivotArea = Typed(expected_type=PivotArea, )
+    extLst = Typed(expected_type=ExtensionList, allow_none=True)
+
+    __elements__ = ('pivotArea', 'extLst')
+
+    def __init__(self,
+                 field=None,
+                 formula=None,
+                 pivotArea=None,
+                 extLst=None,
+                ):
+        self.field = field
+        self.formula = formula
+        self.pivotArea = pivotArea
+        self.extLst = extLst
+
+
+class ServerFormat(Serialisable):
+
+    tagname = "serverFormat"
+
+    culture = String(allow_none=True)
+    format = String(allow_none=True)
+
+    def __init__(self,
+                 culture=None,
+                 format=None,
+                ):
+        self.culture = culture
+        self.format = format
+
+
+class Query(Serialisable):
+
+    tagname = "query"
+
+    mdx = String()
+    tpls = Typed(expected_type=TupleList, allow_none=True)
+
+    __elements__ = ('tpls',)
+
+    def __init__(self,
+                 mdx=None,
+                 tpls=None,
+                ):
+        self.mdx = mdx
+        self.tpls = tpls
+
+
+class OLAPSet(Serialisable):
+
+    tagname = "set"
+
+    count = Integer()
+    maxRank = Integer()
+    setDefinition = String()
+    sortType = NoneSet(values=(['ascending', 'descending', 'ascendingAlpha',
+                                'descendingAlpha', 'ascendingNatural', 'descendingNatural']))
+    queryFailed = Bool()
+    tpls = Typed(expected_type=TupleList, allow_none=True)
+    sortByTuple = Typed(expected_type=TupleList, allow_none=True)
+
+    __elements__ = ('tpls', 'sortByTuple')
+
+    def __init__(self,
+                 count=None,
+                 maxRank=None,
+                 setDefinition=None,
+                 sortType=None,
+                 queryFailed=None,
+                 tpls=None,
+                 sortByTuple=None,
+                ):
+        self.count = count
+        self.maxRank = maxRank
+        self.setDefinition = setDefinition
+        self.sortType = sortType
+        self.queryFailed = queryFailed
+        self.tpls = tpls
+        self.sortByTuple = sortByTuple
+
+
+class PCDSDTCEntries(Serialisable):
+    # Implements CT_PCDSDTCEntries
+
+    tagname = "entries"
+
+    count = Integer(allow_none=True)
+    # elements are choice
+    m = Typed(expected_type=Missing, allow_none=True)
+    n = Typed(expected_type=Number, allow_none=True)
+    e = Typed(expected_type=Error, allow_none=True)
+    s = Typed(expected_type=Text, allow_none=True)
+
+    __elements__ = ('m', 'n', 'e', 's')
+
+    def __init__(self,
+                 count=None,
+                 m=None,
+                 n=None,
+                 e=None,
+                 s=None,
+                ):
+        self.count = count
+        self.m = m
+        self.n = n
+        self.e = e
+        self.s = s
+
+
+class TupleCache(Serialisable):
+
+    tagname = "tupleCache"
+
+    entries = Typed(expected_type=PCDSDTCEntries, allow_none=True)
+    sets = NestedSequence(expected_type=OLAPSet, count=True)
+    queryCache = NestedSequence(expected_type=Query, count=True)
+    serverFormats = NestedSequence(expected_type=ServerFormat, count=True)
+    extLst = Typed(expected_type=ExtensionList, allow_none=True)
+
+    __elements__ = ('entries', 'sets', 'queryCache', 'serverFormats', 'extLst')
+
+    def __init__(self,
+                 entries=None,
+                 sets=(),
+                 queryCache=(),
+                 serverFormats=(),
+                 extLst=None,
+                ):
+        self.entries = entries
+        self.sets = sets
+        self.queryCache = queryCache
+        self.serverFormats = serverFormats
+        self.extLst = extLst
+
+
+class OLAPKPI(Serialisable):
+
+    tagname = "kpi"
+
+    uniqueName = String()
+    caption = String(allow_none=True)
+    displayFolder = String(allow_none=True)
+    measureGroup = String(allow_none=True)
+    parent = String(allow_none=True)
+    value = String()
+    goal = String(allow_none=True)
+    status = String(allow_none=True)
+    trend = String(allow_none=True)
+    weight = String(allow_none=True)
+    time = String(allow_none=True)
+
+    def __init__(self,
+                 uniqueName=None,
+                 caption=None,
+                 displayFolder=None,
+                 measureGroup=None,
+                 parent=None,
+                 value=None,
+                 goal=None,
+                 status=None,
+                 trend=None,
+                 weight=None,
+                 time=None,
+                ):
+        self.uniqueName = uniqueName
+        self.caption = caption
+        self.displayFolder = displayFolder
+        self.measureGroup = measureGroup
+        self.parent = parent
+        self.value = value
+        self.goal = goal
+        self.status = status
+        self.trend = trend
+        self.weight = weight
+        self.time = time
+
+
+class GroupMember(Serialisable):
+
+    tagname = "groupMember"
+
+    uniqueName = String()
+    group = Bool()
+
+    def __init__(self,
+                 uniqueName=None,
+                 group=None,
+                ):
+        self.uniqueName = uniqueName
+        self.group = group
+
+
+class LevelGroup(Serialisable):
+
+    tagname = "group"
+
+    name = String()
+    uniqueName = String()
+    caption = String()
+    uniqueParent = String()
+    id = Integer()
+    groupMembers = NestedSequence(expected_type=GroupMember, count=True)
+
+    __elements__ = ('groupMembers',)
+
+    def __init__(self,
+                 name=None,
+                 uniqueName=None,
+                 caption=None,
+                 uniqueParent=None,
+                 id=None,
+                 groupMembers=(),
+                ):
+        self.name = name
+        self.uniqueName = uniqueName
+        self.caption = caption
+        self.uniqueParent = uniqueParent
+        self.id = id
+        self.groupMembers = groupMembers
+
+
+class GroupLevel(Serialisable):
+
+    tagname = "groupLevel"
+
+    uniqueName = String()
+    caption = String()
+    user = Bool()
+    customRollUp = Bool()
+    groups = NestedSequence(expected_type=LevelGroup, count=True)
+    extLst = Typed(expected_type=ExtensionList, allow_none=True)
+
+    __elements__ = ('groups', 'extLst')
+
+    def __init__(self,
+                 uniqueName=None,
+                 caption=None,
+                 user=None,
+                 customRollUp=None,
+                 groups=(),
+                 extLst=None,
+                ):
+        self.uniqueName = uniqueName
+        self.caption = caption
+        self.user = user
+        self.customRollUp = customRollUp
+        self.groups = groups
+        self.extLst = extLst
+
+
+class FieldUsage(Serialisable):
+
+    tagname = "fieldUsage"
+
+    x = Integer()
+
+    def __init__(self,
+                 x=None,
+                ):
+        self.x = x
+
+
+class CacheHierarchy(Serialisable):
+
+    tagname = "cacheHierarchy"
+
+    uniqueName = String()
+    caption = String(allow_none=True)
+    measure = Bool()
+    set = Bool()
+    parentSet = Integer(allow_none=True)
+    iconSet = Integer()
+    attribute = Bool()
+    time = Bool()
+    keyAttribute = Bool()
+    defaultMemberUniqueName = String(allow_none=True)
+    allUniqueName = String(allow_none=True)
+    allCaption = String(allow_none=True)
+    dimensionUniqueName = String(allow_none=True)
+    displayFolder = String(allow_none=True)
+    measureGroup = String(allow_none=True)
+    measures = Bool()
+    count = Integer()
+    oneField = Bool()
+    memberValueDatatype = Integer(allow_none=True)
+    unbalanced = Bool(allow_none=True)
+    unbalancedGroup = Bool(allow_none=True)
+    hidden = Bool()
+    fieldsUsage = NestedSequence(expected_type=FieldUsage, count=True)
+    groupLevels = NestedSequence(expected_type=GroupLevel, count=True)
+    extLst = Typed(expected_type=ExtensionList, allow_none=True)
+
+    __elements__ = ('fieldsUsage', 'groupLevels')
+
+    def __init__(self,
+                 uniqueName="",
+                 caption=None,
+                 measure=None,
+                 set=None,
+                 parentSet=None,
+                 iconSet=0,
+                 attribute=None,
+                 time=None,
+                 keyAttribute=None,
+                 defaultMemberUniqueName=None,
+                 allUniqueName=None,
+                 allCaption=None,
+                 dimensionUniqueName=None,
+                 displayFolder=None,
+                 measureGroup=None,
+                 measures=None,
+                 count=None,
+                 oneField=None,
+                 memberValueDatatype=None,
+                 unbalanced=None,
+                 unbalancedGroup=None,
+                 hidden=None,
+                 fieldsUsage=(),
+                 groupLevels=(),
+                 extLst=None,
+                ):
+        self.uniqueName = uniqueName
+        self.caption = caption
+        self.measure = measure
+        self.set = set
+        self.parentSet = parentSet
+        self.iconSet = iconSet
+        self.attribute = attribute
+        self.time = time
+        self.keyAttribute = keyAttribute
+        self.defaultMemberUniqueName = defaultMemberUniqueName
+        self.allUniqueName = allUniqueName
+        self.allCaption = allCaption
+        self.dimensionUniqueName = dimensionUniqueName
+        self.displayFolder = displayFolder
+        self.measureGroup = measureGroup
+        self.measures = measures
+        self.count = count
+        self.oneField = oneField
+        self.memberValueDatatype = memberValueDatatype
+        self.unbalanced = unbalanced
+        self.unbalancedGroup = unbalancedGroup
+        self.hidden = hidden
+        self.fieldsUsage = fieldsUsage
+        self.groupLevels = groupLevels
+        self.extLst = extLst
+
+
+class GroupItems(Serialisable):
+
+    tagname = "groupItems"
+
+    m = Sequence(expected_type=Missing)
+    n = Sequence(expected_type=Number)
+    b = Sequence(expected_type=Boolean)
+    e = Sequence(expected_type=Error)
+    s = Sequence(expected_type=Text)
+    d = Sequence(expected_type=DateTimeField,)
+
+    __elements__ = ('m', 'n', 'b', 'e', 's', 'd')
+    __attrs__ = ("count", )
+
+    def __init__(self,
+                 count=None,
+                 m=(),
+                 n=(),
+                 b=(),
+                 e=(),
+                 s=(),
+                 d=(),
+                ):
+        self.m = m
+        self.n = n
+        self.b = b
+        self.e = e
+        self.s = s
+        self.d = d
+
+
+    @property
+    def count(self):
+        return len(self.m + self.n + self.b + self.e + self.s + self.d)
+
+
+class RangePr(Serialisable):
+
+    tagname = "rangePr"
+
+    autoStart = Bool(allow_none=True)
+    autoEnd = Bool(allow_none=True)
+    groupBy = NoneSet(values=(['range', 'seconds', 'minutes', 'hours', 'days',
+                           'months', 'quarters', 'years']))
+    startNum = Float(allow_none=True)
+    endNum = Float(allow_none=True)
+    startDate = DateTime(allow_none=True)
+    endDate = DateTime(allow_none=True)
+    groupInterval = Float(allow_none=True)
+
+    def __init__(self,
+                 autoStart=True,
+                 autoEnd=True,
+                 groupBy="range",
+                 startNum=None,
+                 endNum=None,
+                 startDate=None,
+                 endDate=None,
+                 groupInterval=1,
+                ):
+        self.autoStart = autoStart
+        self.autoEnd = autoEnd
+        self.groupBy = groupBy
+        self.startNum = startNum
+        self.endNum = endNum
+        self.startDate = startDate
+        self.endDate = endDate
+        self.groupInterval = groupInterval
+
+
+class FieldGroup(Serialisable):
+
+    tagname = "fieldGroup"
+
+    par = Integer(allow_none=True)
+    base = Integer(allow_none=True)
+    rangePr = Typed(expected_type=RangePr, allow_none=True)
+    discretePr = NestedSequence(expected_type=NestedInteger, count=True)
+    groupItems = Typed(expected_type=GroupItems, allow_none=True)
+
+    __elements__ = ('rangePr', 'discretePr', 'groupItems')
+
+    def __init__(self,
+                 par=None,
+                 base=None,
+                 rangePr=None,
+                 discretePr=(),
+                 groupItems=None,
+                ):
+        self.par = par
+        self.base = base
+        self.rangePr = rangePr
+        self.discretePr = discretePr
+        self.groupItems = groupItems
+
+
+class SharedItems(Serialisable):
+
+    tagname = "sharedItems"
+
+    _fields = MultiSequence()
+    m = MultiSequencePart(expected_type=Missing, store="_fields")
+    n = MultiSequencePart(expected_type=Number, store="_fields")
+    b = MultiSequencePart(expected_type=Boolean, store="_fields")
+    e = MultiSequencePart(expected_type=Error, store="_fields")
+    s = MultiSequencePart(expected_type=Text,  store="_fields")
+    d = MultiSequencePart(expected_type=DateTimeField, store="_fields")
+    # attributes are optional and must be derived from associated cache records
+    containsSemiMixedTypes = Bool(allow_none=True)
+    containsNonDate = Bool(allow_none=True)
+    containsDate = Bool(allow_none=True)
+    containsString = Bool(allow_none=True)
+    containsBlank = Bool(allow_none=True)
+    containsMixedTypes = Bool(allow_none=True)
+    containsNumber = Bool(allow_none=True)
+    containsInteger = Bool(allow_none=True)
+    minValue = Float(allow_none=True)
+    maxValue = Float(allow_none=True)
+    minDate = DateTime(allow_none=True)
+    maxDate = DateTime(allow_none=True)
+    longText = Bool(allow_none=True)
+
+    __attrs__ = ('count', 'containsBlank', 'containsDate', 'containsInteger',
+                 'containsMixedTypes', 'containsNonDate', 'containsNumber',
+                 'containsSemiMixedTypes', 'containsString', 'minValue', 'maxValue',
+                 'minDate', 'maxDate', 'longText')
+
+    def __init__(self,
+                 _fields=(),
+                 containsSemiMixedTypes=None,
+                 containsNonDate=None,
+                 containsDate=None,
+                 containsString=None,
+                 containsBlank=None,
+                 containsMixedTypes=None,
+                 containsNumber=None,
+                 containsInteger=None,
+                 minValue=None,
+                 maxValue=None,
+                 minDate=None,
+                 maxDate=None,
+                 count=None,
+                 longText=None,
+                ):
+        self._fields = _fields
+        self.containsBlank = containsBlank
+        self.containsDate = containsDate
+        self.containsNonDate = containsNonDate
+        self.containsString = containsString
+        self.containsMixedTypes = containsMixedTypes
+        self.containsSemiMixedTypes = containsSemiMixedTypes
+        self.containsNumber = containsNumber
+        self.containsInteger = containsInteger
+        self.minValue = minValue
+        self.maxValue = maxValue
+        self.minDate = minDate
+        self.maxDate = maxDate
+        self.longText = longText
+
+
+    @property
+    def count(self):
+        return len(self._fields)
+
+
+class CacheField(Serialisable):
+
+    tagname = "cacheField"
+
+    sharedItems = Typed(expected_type=SharedItems, allow_none=True)
+    fieldGroup = Typed(expected_type=FieldGroup, allow_none=True)
+    mpMap = NestedInteger(allow_none=True, attribute="v")
+    extLst = Typed(expected_type=ExtensionList, allow_none=True)
+    name = String()
+    caption = String(allow_none=True)
+    propertyName = String(allow_none=True)
+    serverField = Bool(allow_none=True)
+    uniqueList = Bool(allow_none=True)
+    numFmtId = Integer(allow_none=True)
+    formula = String(allow_none=True)
+    sqlType = Integer(allow_none=True)
+    hierarchy = Integer(allow_none=True)
+    level = Integer(allow_none=True)
+    databaseField = Bool(allow_none=True)
+    mappingCount = Integer(allow_none=True)
+    memberPropertyField = Bool(allow_none=True)
+
+    __elements__ = ('sharedItems', 'fieldGroup', 'mpMap')
+
+    def __init__(self,
+                 sharedItems=None,
+                 fieldGroup=None,
+                 mpMap=None,
+                 extLst=None,
+                 name=None,
+                 caption=None,
+                 propertyName=None,
+                 serverField=None,
+                 uniqueList=True,
+                 numFmtId=None,
+                 formula=None,
+                 sqlType=0,
+                 hierarchy=0,
+                 level=0,
+                 databaseField=True,
+                 mappingCount=None,
+                 memberPropertyField=None,
+                ):
+        self.sharedItems = sharedItems
+        self.fieldGroup = fieldGroup
+        self.mpMap = mpMap
+        self.extLst = extLst
+        self.name = name
+        self.caption = caption
+        self.propertyName = propertyName
+        self.serverField = serverField
+        self.uniqueList = uniqueList
+        self.numFmtId = numFmtId
+        self.formula = formula
+        self.sqlType = sqlType
+        self.hierarchy = hierarchy
+        self.level = level
+        self.databaseField = databaseField
+        self.mappingCount = mappingCount
+        self.memberPropertyField = memberPropertyField
+
+
+class RangeSet(Serialisable):
+
+    tagname = "rangeSet"
+
+    i1 = Integer(allow_none=True)
+    i2 = Integer(allow_none=True)
+    i3 = Integer(allow_none=True)
+    i4 = Integer(allow_none=True)
+    ref = String()
+    name = String(allow_none=True)
+    sheet = String(allow_none=True)
+
+    def __init__(self,
+                 i1=None,
+                 i2=None,
+                 i3=None,
+                 i4=None,
+                 ref=None,
+                 name=None,
+                 sheet=None,
+                ):
+        self.i1 = i1
+        self.i2 = i2
+        self.i3 = i3
+        self.i4 = i4
+        self.ref = ref
+        self.name = name
+        self.sheet = sheet
+
+
+class PageItem(Serialisable):
+
+    tagname = "pageItem"
+
+    name = String()
+
+    def __init__(self,
+                 name=None,
+                ):
+        self.name = name
+
+
+class Consolidation(Serialisable):
+
+    tagname = "consolidation"
+
+    autoPage = Bool(allow_none=True)
+    pages = NestedSequence(expected_type=PageItem, count=True)
+    rangeSets = NestedSequence(expected_type=RangeSet, count=True)
+
+    __elements__ = ('pages', 'rangeSets')
+
+    def __init__(self,
+                 autoPage=None,
+                 pages=(),
+                 rangeSets=(),
+                ):
+        self.autoPage = autoPage
+        self.pages = pages
+        self.rangeSets = rangeSets
+
+
+class WorksheetSource(Serialisable):
+
+    tagname = "worksheetSource"
+
+    ref = String(allow_none=True)
+    name = String(allow_none=True)
+    sheet = String(allow_none=True)
+
+    def __init__(self,
+                 ref=None,
+                 name=None,
+                 sheet=None,
+                ):
+        self.ref = ref
+        self.name = name
+        self.sheet = sheet
+
+
+class CacheSource(Serialisable):
+
+    tagname = "cacheSource"
+
+    type = Set(values=(['worksheet', 'external', 'consolidation', 'scenario']))
+    connectionId = Integer(allow_none=True)
+    # some elements are choice
+    worksheetSource = Typed(expected_type=WorksheetSource, allow_none=True)
+    consolidation = Typed(expected_type=Consolidation, allow_none=True)
+    extLst = Typed(expected_type=ExtensionList, allow_none=True)
+
+    __elements__ = ('worksheetSource', 'consolidation',)
+
+    def __init__(self,
+                 type=None,
+                 connectionId=None,
+                 worksheetSource=None,
+                 consolidation=None,
+                 extLst=None,
+                ):
+        self.type = type
+        self.connectionId = connectionId
+        self.worksheetSource = worksheetSource
+        self.consolidation = consolidation
+
+
+class CacheDefinition(Serialisable):
+
+    mime_type = "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml"
+    rel_type = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition"
+    _id = 1
+    _path = "/xl/pivotCache/pivotCacheDefinition{0}.xml"
+    records = None
+
+    tagname = "pivotCacheDefinition"
+
+    invalid = Bool(allow_none=True)
+    saveData = Bool(allow_none=True)
+    refreshOnLoad = Bool(allow_none=True)
+    optimizeMemory = Bool(allow_none=True)
+    enableRefresh = Bool(allow_none=True)
+    refreshedBy = String(allow_none=True)
+    refreshedDate = Float(allow_none=True)
+    refreshedDateIso = DateTime(allow_none=True)
+    backgroundQuery = Bool(allow_none=True)
+    missingItemsLimit = Integer(allow_none=True)
+    createdVersion = Integer(allow_none=True)
+    refreshedVersion = Integer(allow_none=True)
+    minRefreshableVersion = Integer(allow_none=True)
+    recordCount = Integer(allow_none=True)
+    upgradeOnRefresh = Bool(allow_none=True)
+    supportSubquery = Bool(allow_none=True)
+    supportAdvancedDrill = Bool(allow_none=True)
+    cacheSource = Typed(expected_type=CacheSource)
+    cacheFields = NestedSequence(expected_type=CacheField, count=True)
+    cacheHierarchies = NestedSequence(expected_type=CacheHierarchy, allow_none=True)
+    kpis = NestedSequence(expected_type=OLAPKPI, count=True)
+    tupleCache = Typed(expected_type=TupleCache, allow_none=True)
+    calculatedItems = NestedSequence(expected_type=CalculatedItem, count=True)
+    calculatedMembers = NestedSequence(expected_type=CalculatedMember, count=True)
+    dimensions = NestedSequence(expected_type=PivotDimension, allow_none=True)
+    measureGroups = NestedSequence(expected_type=MeasureGroup, count=True)
+    maps = NestedSequence(expected_type=MeasureDimensionMap, count=True)
+    extLst = Typed(expected_type=ExtensionList, allow_none=True)
+    id = Relation()
+
+    __elements__ = ('cacheSource', 'cacheFields', 'cacheHierarchies', 'kpis',
+                    'tupleCache', 'calculatedItems', 'calculatedMembers', 'dimensions',
+                    'measureGroups', 'maps',)
+
+    def __init__(self,
+                 invalid=None,
+                 saveData=None,
+                 refreshOnLoad=None,
+                 optimizeMemory=None,
+                 enableRefresh=None,
+                 refreshedBy=None,
+                 refreshedDate=None,
+                 refreshedDateIso=None,
+                 backgroundQuery=None,
+                 missingItemsLimit=None,
+                 createdVersion=None,
+                 refreshedVersion=None,
+                 minRefreshableVersion=None,
+                 recordCount=None,
+                 upgradeOnRefresh=None,
+                 tupleCache=None,
+                 supportSubquery=None,
+                 supportAdvancedDrill=None,
+                 cacheSource=None,
+                 cacheFields=(),
+                 cacheHierarchies=(),
+                 kpis=(),
+                 calculatedItems=(),
+                 calculatedMembers=(),
+                 dimensions=(),
+                 measureGroups=(),
+                 maps=(),
+                 extLst=None,
+                 id = None,
+                ):
+        self.invalid = invalid
+        self.saveData = saveData
+        self.refreshOnLoad = refreshOnLoad
+        self.optimizeMemory = optimizeMemory
+        self.enableRefresh = enableRefresh
+        self.refreshedBy = refreshedBy
+        self.refreshedDate = refreshedDate
+        self.refreshedDateIso = refreshedDateIso
+        self.backgroundQuery = backgroundQuery
+        self.missingItemsLimit = missingItemsLimit
+        self.createdVersion = createdVersion
+        self.refreshedVersion = refreshedVersion
+        self.minRefreshableVersion = minRefreshableVersion
+        self.recordCount = recordCount
+        self.upgradeOnRefresh = upgradeOnRefresh
+        self.supportSubquery = supportSubquery
+        self.supportAdvancedDrill = supportAdvancedDrill
+        self.cacheSource = cacheSource
+        self.cacheFields = cacheFields
+        self.cacheHierarchies = cacheHierarchies
+        self.kpis = kpis
+        self.tupleCache = tupleCache
+        self.calculatedItems = calculatedItems
+        self.calculatedMembers = calculatedMembers
+        self.dimensions = dimensions
+        self.measureGroups = measureGroups
+        self.maps = maps
+        self.id = id
+
+
+    def to_tree(self):
+        node = super().to_tree()
+        node.set("xmlns", SHEET_MAIN_NS)
+        return node
+
+
+    @property
+    def path(self):
+        return self._path.format(self._id)
+
+
+    def _write(self, archive, manifest):
+        """
+        Add to zipfile and update manifest
+        """
+        self._write_rels(archive, manifest)
+        xml = tostring(self.to_tree())
+        archive.writestr(self.path[1:], xml)
+        manifest.append(self)
+
+
+    def _write_rels(self, archive, manifest):
+        """
+        Write the relevant child objects and add links
+        """
+        if self.records is None:
+            return
+
+        rels = RelationshipList()
+        r = Relationship(Type=self.records.rel_type, Target=self.records.path)
+        rels.append(r)
+        self.id = r.id
+        self.records._id = self._id
+        self.records._write(archive, manifest)
+
+        path = get_rels_path(self.path)
+        xml = tostring(rels.to_tree())
+        archive.writestr(path[1:], xml)