arelle-release 2.37.17__py3-none-any.whl → 2.37.19__py3-none-any.whl

arelle/plugin/OimTaxonomy/ViewXbrlTxmyObj.py

@@ -0,0 +1,240 @@
+'''
+See COPYRIGHT.md for copyright information.
+'''
+from typing import Union
+from types import UnionType
+from collections import defaultdict
+from decimal import Decimal
+from typing import GenericAlias
+from arelle import ViewWinTree, XbrlConst
+from arelle.FunctionFn import false
+from arelle.ModelValue import qname
+from arelle.PythonUtil import OrderedSet
+from .XbrlCube import XbrlCube, XbrlPeriodConstraint
+from .XbrlDimension import XbrlDomain
+from .XbrlGroup import XbrlGroup
+from .XbrlNetwork import XbrlNetwork
+from .XbrlTaxonomyObject import EMPTY_DICT, XbrlTaxonomyObject
+from .XbrlConst import qnStdLabel
+
+
+def viewXbrlTxmyObj(xbrlDts, objClass, tabWin, header, additionalViews=None):
+    xbrlDts.modelManager.showStatus(_("viewing concepts"))
+    view = ViewXbrlTxmyObj(xbrlDts, objClass, tabWin, header)
+    view.propNameTypes = []
+    initialParentObjProp = True
+    for propName, propType in getattr(objClass, "__annotations__", {}).items():
+        if initialParentObjProp:
+            initialParentProp = False
+            if isinstance(propType, str):
+                continue
+            elif isinstance(propType, UnionType):
+                if any(arg.__name__.startswith("Xbrl") for arg in propType.__args__):
+                    continue
+            elif propType.__name__.startswith("Xbrl"): # skip taxonomy alias type
+                continue
+        if not isinstance(propType, GenericAlias): # set, dict, etc
+            view.propNameTypes.append((propName, propType))
+    # add label col if first col is name for Concepts pane
+    if view.propNameTypes and view.propNameTypes[0][0] == "name":
+        if objClass.__name__ in ("XbrlConcept", "XbrlFact"):
+            view.propNameTypes.insert(0, ("label", str))
+        else:
+            view.propNameTypes[0] = ("name", view.propNameTypes[0][1])
+    # check nested object types
+    for i in range(len(view.propNameTypes),10):
+        view.propNameTypes.append( (f"col{i+1}",str))
+    view.colNames = tuple(propName for propName, _propType in view.propNameTypes[1:])
+    view.treeView["columns"] = view.colNames
+    firstCol = True
+    for propName, propType in view.propNameTypes:
+        colName = propName
+        if firstCol:
+            firstCol = False
+            colName = "#0"
+            w = 360
+        elif isinstance(propType, (int,float,Decimal)):
+            w = 50
+        else:
+            w = 120
+        view.treeView.column(colName, width=w, anchor="w")
+        view.treeView.heading(colName, text=propName)
+    view.treeView["displaycolumns"] = view.colNames
+    if objClass.__name__ == "XbrlReference":
+        view.labelRole = None
+    else:
+        view.labelrole = qnStdLabel
+    view.view()
+    view.blockSelectEvent = 1
+    view.blockViewModelObject = 0
+    view.treeView.bind("<<TreeviewSelect>>", view.treeviewSelect, '+')
+    view.treeView.bind("<Enter>", view.treeviewEnter, '+')
+    view.treeView.bind("<Leave>", view.treeviewLeave, '+')
+
+    # languages menu
+    menu = view.contextMenu()
+    if objClass.__name__ != "XbrlConcept":
+        view.menuAddExpandCollapse() # for tree view panes but not for Concept table pane
+    view.menuAddClipboard()
+    view.menuAddLangs()
+
+    view.menuAddLabelRoles(usedLabelroles=
+        (("1Name",XbrlConst.conceptNameLabelRole),
+         ("2Standard Label", qnStdLabel)) +
+        tuple((f"3{t}", t) for t in sorted(xbrlDts.labelTypes) if t != qnStdLabel))
+    view.menuAddNameStyle()
+    view.menuAddViews(addClose=False, additionalViews=additionalViews, additionalViewMethod=viewXbrlTxmyObj)
+
+class ViewXbrlTxmyObj(ViewWinTree.ViewTree):
+    def __init__(self, xbrlDts, objClass, tabWin, header):
+        super(ViewXbrlTxmyObj, self).__init__(xbrlDts, tabWin, header, True, None)
+        self.xbrlDts = xbrlDts
+        self.objClass = objClass
+
+    def view(self):
+        # sort by labels
+        self.setColumnsSortable()
+        self.tag_has = defaultdict(list)
+        lbls = defaultdict(list)
+        role = self.labelrole
+        lang = self.lang
+        self.clearTreeView()
+        self.id = 1
+        nodeNum = 0
+        excludedNamespaces = XbrlConst.ixbrlAll.union(
+            (XbrlConst.xbrli, XbrlConst.link, XbrlConst.xlink, XbrlConst.xl,
+             XbrlConst.xbrldt,
+             XbrlConst.xhtml))
+        for obj in self.xbrlDts.filterNamedObjects(self.objClass, role, lang): # this is a yield generator
+            propName = self.propNameTypes[0][0]
+            node = self.treeView.insert("", "end",
+                                        f"_{self.id}_{obj.dtsObjectIndex}",
+                                        text=str(self.xbrlDts.labelValue(obj.getProperty(propName, self.labelrole), self.labelrole, self.lang)),
+                                        tags=("odd" if nodeNum & 1 else "even",))
+            self.tag_has[f"_{obj.dtsObjectIndex}"].append(node)
+            self.id += 1
+            nodeNum += 1
+            for propName, _propType in self.propNameTypes[1:]:
+                self.treeView.set(node, propName, str(obj.getProperty(propName)))
+            if isinstance(obj, XbrlGroup):
+                self.viewGroupContent(node, nodeNum, obj)
+            elif isinstance(obj, XbrlCube):
+                self.viewDims(node, nodeNum, obj)
+            elif isinstance(obj, (XbrlNetwork, XbrlDomain)):
+                self.viewRoots(node, nodeNum, obj)
+
+    def viewProps(self, parentNode, nodeNum, obj):
+        propView = obj.propertyView
+        node = self.treeView.insert(parentNode, "end",
+                                    f"_{self.id}_{obj.dtsObjectIndex}",
+                                    text=propView[0][1],
+                                    tags=("odd" if nodeNum & 1 else "even",))
+        self.tag_has[f"_{obj.dtsObjectIndex}"].append(node)
+        nodeNum += 1
+        self.id += 1
+        for i, propViewEntry in enumerate(propView[1:]):
+            if i >= len(self.colNames):
+                print(f"i problem {i}")
+            if len(propViewEntry) < 2:
+                print(f"propViewEntry problem {propViewEntry} class {type(obj).__name__}")
+            self.treeView.set(node, self.colNames[i], propViewEntry[1])
+        # process nested objects
+        for propName, propType in getattr(type(obj), "__annotations__", EMPTY_DICT).items():
+            childObj = getattr(obj, propName, None)
+            if isinstance(getattr(propType, "__origin__", None), type(Union)): # Optional[ ] type
+                if isinstance(propType.__args__[0], XbrlTaxonomyObject): # e.g. dateResolution object
+                    childObj = getattr(obj, propName, None)
+                    if childObj is not None:
+                        self.viewProps(node, nodeNum, childObj)
+            elif getattr(propType, "__origin__", None) in (set, OrderedSet) and issubclass(propType.__args__[0], XbrlTaxonomyObject):
+                if childObj is not None and len(childObj) > 0 and propName != "relationships":
+                    for childObjObj in childObj:
+                        self.viewProps(node, nodeNum, childObjObj)
+        return node
+
+    def viewGroupContent(self, parentNode, nodeNum, obj):
+        # related content for the Group object are under tagged content
+        for relatedObjQn in self.xbrlDts.groupContents.get(obj.name, ()):
+            relatedObj = self.xbrlDts.namedObjects.get(relatedObjQn)
+            if relatedObj is not None:
+                node = self.viewProps(parentNode, nodeNum, relatedObj)
+                nodeNum += 1
+                if isinstance(relatedObj, XbrlCube):
+                    self.viewDims(node, nodeNum, relatedObj)
+                elif isinstance(relatedObj, (XbrlNetwork, XbrlDomain)):
+                    self.viewRoots(node, nodeNum, relatedObj)
+
+    def viewDims(self, parentNode, nodeNum, obj):
+        for cubeDim in obj.cubeDimensions:
+            node = self.viewProps(parentNode, nodeNum, cubeDim)
+            nodeNum += 1
+            domName = getattr(cubeDim, "domainName", None)
+            if domName:
+                domObj = self.xbrlDts.namedObjects.get(domName)
+                if domObj is not None:
+                    domNode = self.viewProps(node, nodeNum, domObj)
+                    nodeNum += 1
+                    self.viewRoots(domNode, nodeNum, domObj)
+
+    def viewRoots(self, parentNode, nodeNum, obj):
+        for qn in obj.relationshipRoots:
+            rootObj = self.xbrlDts.namedObjects.get(qn)
+            if rootObj is not None:
+                node = self.treeView.insert(parentNode, "end",
+                                            f"_{self.id}_{rootObj.dtsObjectIndex}",
+                                            text=str(rootObj.getProperty("label", self.labelrole, self.lang, "")),
+                                            tags=("odd" if nodeNum & 1 else "even",))
+                self.id += 1
+                nodeNum += 1
+                for relObj in obj.relationshipsFrom.get(qn, ()):
+                    self.viewRelationships(node, nodeNum, obj, relObj, set())
+
+    def viewRelationships(self, parentNode, nodeNum, obj, relObj, visited):
+        target = relObj.target
+        qnObj = self.xbrlDts.namedObjects.get(target)
+        if qnObj is not None:
+            loop = target in visited
+            txt = self.xbrlDts.labelValue(relObj.target, self.labelrole, self.lang)
+            if loop:
+                txt = "(loop) " + txt
+            node = self.treeView.insert(parentNode, "end",
+                                        f"_{self.id}_{qnObj.dtsObjectIndex}",
+                                        text=txt,
+                                        tags=("odd" if nodeNum & 1 else "even",))
+            self.id += 1
+            nodeNum += 1
+            if not loop:
+                visited.add(target)
+                for relTgtObj in obj.relationshipsFrom.get(relObj.target, ()):
+                    self.viewRelationships(node, nodeNum, obj, relTgtObj, visited)
+                visited.remove(target)
+
+    def treeviewEnter(self, *args):
+        self.blockSelectEvent = 0
+
+    def treeviewLeave(self, *args):
+        self.blockSelectEvent = 1
+
+    def treeviewSelect(self, event):
+        if self.blockSelectEvent == 0 and self.blockViewModelObject == 0:
+            self.blockViewModelObject += 1
+            #self.modelXbrl.viewModelObject(self.nodeToObjectId[self.treeView.selection()[0]])
+            selection = self.treeView.selection()
+            if selection is not None and len(selection)>0:
+                self.xbrlDts.viewTaxonomyObject(selection[0])
+            self.blockViewModelObject -= 1
+
+    def viewModelObject(self, txmyObj):
+        if self.blockViewModelObject == 0:
+            self.blockViewModelObject += 1
+            try:
+                items = self.tag_has.get(f"_{txmyObj.dtsObjectIndex}")
+                if items:
+                    for item in items:
+                        if self.treeView.exists(item):
+                            self.treeView.see(item)
+                            self.treeView.selection_set(item)
+                            break
+            except (AttributeError, KeyError, ValueError):
+                    self.treeView.selection_set(())
+            self.blockViewModelObject -= 1

arelle/plugin/OimTaxonomy/XbrlAbstract.py

@@ -0,0 +1,16 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING, Set
+
+from arelle.ModelValue import QName
+from arelle.PythonUtil import OrderedSet
+from .XbrlProperty import XbrlProperty
+from .XbrlTypes import XbrlTaxonomyType, QNameKeyType
+from .XbrlTaxonomyObject import XbrlReferencableTaxonomyObject
+
+class XbrlAbstract(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required) The name is a QName that uniquely identifies the abstract object.
+    properties: OrderedSet[XbrlProperty] # (optional) ordered set of property objects used to specify additional properties associated with the concept using the property object. Only immutable properties as defined in the propertyType object can be added to a concept.

arelle/plugin/OimTaxonomy/XbrlConcept.py

@@ -0,0 +1,67 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+
+from typing import TYPE_CHECKING, TypeAlias, Optional, Any
+from decimal import Decimal
+
+from arelle.ModelValue import QName
+from arelle.PythonUtil import OrderedSet
+from arelle.XbrlConst import xsd
+from .XbrlProperty import XbrlProperty
+from .XbrlTypes import XbrlTaxonomyType, QNameKeyType
+from .XbrlTaxonomyObject import XbrlTaxonomyObject, XbrlReferencableTaxonomyObject
+
+XbrlUnitTypeType: TypeAlias = "XbrlUnitType"
+
+class XbrlConcept(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required) The name is a QName that uniquely identifies the concept object.
+    dataType: QName # (required) Indicates the dataType of the concept. These are provided as a QName based on the datatypes specified in the XBRL 2.1 specification and any custom datatype defined in the taxonomy.
+    periodType: str # (required) Indicates the period type of the concept. The property values can be either instant or duration. If the concept can be an atemporal value it must be defined as a duration. (i.e. the value does not change with the passage of time)
+    enumerationDomain: Optional[QName] # (optional) Used to specify enumerated domain members that are associated with a domain defined in the taxonomy.
+    nillable: Optional[bool] # (optional) Used to specify if the concept can have a nill value. The default value is true.
+    properties: OrderedSet[XbrlProperty] # (optional) ordered set of property objects used to specify additional properties associated with the concept using the property object. Only immutable properties as defined in the propertyType object can be added to a concept.
+
+class XbrlDataType(XbrlReferencableTaxonomyObject):
+    taxonomy: XbrlTaxonomyType
+    name: QNameKeyType # (required) The name is a QName that uniquely identifies the datatype object.
+    baseType: QName # (required) The base type is a QName that uniquely identifies the base datatype the datatype is based on.
+    enumeration: OrderedSet[Any] # (optional) Defines an ordered set of enumerated values of the datatype if applicable
+    minInclusive: Optional[Decimal] # (optional) Defines a decimal value to indicate a min inclusive cardinal value for a type. Only applies to types based on float, double and decimal.
+    maxInclusive: Optional[Decimal] # (optional) Defines a decimal value to indicate a max inclusive cardinal value for a type. Only applies to types based on float, double and decimal.
+    minExclusive: Optional[Decimal] # (optional) Defines a decimal value to indicate a min exclusive cardinal value for a type. Only applies to types based on float, double and decimal.
+    maxExclusive: Optional[Decimal] # (optional) Defines a decimal value to indicate a max exclusive cardinal value for a type. Only applies to types based on float, double and decimal.
+    totalDigits: Optional[int] # (optional) Defines an int value to indicate total digits of a value. Only applies to types based on float, double and decimal.
+    fractionDigits: Optional[int] # (optional) Defines an int of digits to the right of the decimal place. Only applies to types based on float, double and decimal.
+    length: Optional[int] # (optional) Defines an int value used to define the length of a string value.
+    minLength: Optional[int] # (optional) Defines an int used to define minimum length of a string value.
+    maxLength: Optional[int] # (optional) Defines an int used to define maximum length of a string value.
+    whiteSpace: Optional[str] # (optional) Defines a string one of preserve, replace or collapse.
+    patterns: set[str] # (optional) Defines a string as a single regex expressions. At least one of the regex patterns must match. (Uses XML regex)
+    unitTypes: OrderedSet[XbrlUnitTypeType] # unitType comprising a dataType expressed as a value of the datatype. For example xbrli:flow has unit datatypes of xbrli:volume and xbrli:time
+
+    def xsBaseType(self, dts, visitedTypes=None): # find base types thru dataType hierarchy
+        if not visitedTypes: visitedTypes = set() # might be a loop
+        if self.baseType.namespaceURI == xsd:
+            return self.baseType.localName
+        elif self not in visitedTypes:
+            visitedTypes.add(self)
+            baseTypeObj = dts.namedObjects.get(self.baseType)
+            if isinstance(baseTypeObj, XbrlDataType):
+                return baseTypeObj.xsBaseType(dts, visitedTypes)
+            visitedTypes.remove(self)
+        return None
+
+    def xsFacets(self):
+        facets = {}
+        for facet in ("enumeration", "minInclusive", "maxInclusive", "minExclusive", "maxExclusive", "totalDigits", "fractionDigits", "length", "minLength", "maxLength", "whiteSpace", "patterns"):
+            value = getattr(self, facet, None)
+            if value is not None and not(isinstance(value, (set,list,OrderedSet)) and not value):
+                facets[facet] = value
+        return facets
+
+class XbrlUnitType(XbrlTaxonomyObject):
+    dataTypeNumerator: Optional[XbrlDataType] # (optional) Defines the numerator datatype of of the datatype
+    dataTypeDenominator: Optional[XbrlDataType] # (optional) Defines the denominator datatype used by a unit used to define a value of the datatype
+    dataTypeMutiplier: Optional[XbrlDataType] # (optional) Defines a mutiplier datatype used by a unit used to define a value of the datatype

arelle/plugin/OimTaxonomy/XbrlConst.py

@@ -0,0 +1,261 @@
+"""
+See COPYRIGHT.md for copyright information.
+"""
+import regex as re
+from arelle.ModelValue import qname
+from arelle.XbrlConst import xsd
+
+# MERGE TO arelle.XbrlConst when promoting plugin to infrastructure
+
+oimTaxonomyDocTypePattern = re.compile(r"\s*\{.*\"documentType\"\s*:\s*\"https://xbrl.org/[0-9]{4}/taxonomy\"", flags=re.DOTALL)
+oimTaxonomyDocTypes = (
+        "https://xbrl.org/2025/taxonomy",
+    )
+
+xbrl = "https://xbrl.org/2025"
+
+qnStdLabel = qname(xbrl, "xbrli:label")
+qnXsDate = qname(xsd, "xs:date")
+qnXsDateTime = qname(xsd, "xs:dateTime")
+qnXsDuration = qname(xsd, "xs:duration")
+qnXsQName = qname(xsd, "xs:QName")
+
+qnXbrlLabelObj = qname(xbrl, "xbrl:labelObject")
+
+objectsWithProperties = {
+    qname(xbrl, "xbrl:taxonomyObject"),
+    qname(xbrl, "xbrl:conceptObject"),
+    qname(xbrl, "xbrl:abstractObject"),
+    qname(xbrl, "xbrl:cubeObject"),
+    qname(xbrl, "xbrl:dimensionObject"),
+    qname(xbrl, "xbrl:domainObject"),
+    qname(xbrl, "xbrl:entityObject"),
+    qname(xbrl, "xbrl:groupObject"),
+    qname(xbrl, "xbrl:networkObject"),
+    qnXbrlLabelObj,
+    qname(xbrl, "xbrl:memberObject"),
+    qname(xbrl, "xbrl:referenceObject"),
+    qname(xbrl, "xbrl:relationshipObject"),
+    }
+
+xbrlTaxonomyObjects = {
+    "documentInfo": {
+        "documentType": oimTaxonomyDocTypes[0],
+        "namespaces": {
+            "xbrl": xbrl,
+            "xbrli": "https://xbrl.org/2025/instance",
+            "xs": xsd
+        }
+    },
+    "taxonomy": {
+        "name": "xbrl:BuiltInCoreObjectsTaxonomy",
+        "frameworkName": "types",
+        "version": "2025",
+        "resolved": False,
+        "dataTypes": [
+            {
+                "name": "xs:string",
+                "baseType": "xs:string"
+            },
+            {
+                "name": "xs:boolean",
+                "baseType": "xs:boolean"
+            },
+            {
+                "name": "xs:decimal",
+                "baseType": "xs:decimal"
+            },
+            {
+                "name": "xs:float",
+                "baseType": "xs:float"
+            },
+            {
+                "name": "xs:double",
+                "baseType": "xs:double"
+            },
+            {
+                "name": "xs:duration",
+                "baseType": "xs:duration"
+            },
+            {
+                "name": "xs:dateTime",
+                "baseType": "xs:dateTime"
+            },
+            {
+                "name": "xs:time",
+                "baseType": "xs:time"
+            },
+            {
+                "name": "xs:date",
+                "baseType": "xs:date"
+            },
+            {
+                "name": "xs:gYearMonth",
+                "baseType": "xs:gYearMonth"
+            },
+            {
+                "name": "xs:gYear",
+                "baseType": "xs:gYear"
+            },
+            {
+                "name": "xs:gMonthDay",
+                "baseType": "xs:gMonthDay"
+            },
+            {
+                "name": "xs:gDay",
+                "baseType": "xs:gDay"
+            },
+            {
+                "name": "xs:gMonth",
+                "baseType": "xs:gMonth"
+            },
+            {
+                "name": "xs:hexBinary",
+                "baseType": "xs:hexBinary"
+            },
+            {
+                "name": "xs:base64Binary",
+                "baseType": "xs:base64Binary"
+            },
+            {
+                "name": "xs:anyURI",
+                "baseType": "xs:anyURI"
+            },
+            {
+                "name": "xs:QName",
+                "baseType": "xs:QName"
+            },
+            {
+                "name": "xs:NOTATION",
+                "baseType": "xs:NOTATION"
+            },
+            {
+                "name": "xs:normalizedString",
+                "baseType": "xs:string"
+            },
+            {
+                "name": "xs:token",
+                "baseType": "xs:normalizedString"
+            },
+            {
+                "name": "xs:language",
+                "baseType": "xs:token"
+            },
+            {
+                "name": "xs:NMTOKEN",
+                "baseType": "xs:token"
+            },
+            {
+                "name": "xs:NMTOKENS",
+                "baseType": "xs:NMTOKEN"
+            },
+            {
+                "name": "xs:Name",
+                "baseType": "xs:token"
+            },
+            {
+                "name": "xs:NCName",
+                "baseType": "xs:Name"
+            },
+            {
+                "name": "xs:ID",
+                "baseType": "xs:NCName"
+            },
+            {
+                "name": "xs:IDREF",
+                "baseType": "xs:NCName"
+            },
+            {
+                "name": "xs:IDREFS",
+                "baseType": "xs:IDREF"
+            },
+            {
+                "name": "xs:ENTITY",
+                "baseType": "xs:IDREF"
+            },
+            {
+                "name": "xs:ENTITIES",
+                "baseType": "xs:ENTITY"
+            },
+            {
+                "name": "xs:integer",
+                "baseType": "xs:decimal"
+            },
+            {
+                "name": "xs:nonPositiveInteger",
+                "baseType": "xs:integer",
+                "maxInclusive": 0
+
+            },
+            {
+                "name": "xs:negativeInteger",
+                "baseType": "xs:nonPositiveInteger",
+                "maxInclusive": -1
+            },
+            {
+                "name": "xs:long",
+                "baseType": "xs:integer"
+            },
+            {
+                "name": "xs:int",
+                "baseType": "xs:long",
+                "maxInclusive": 2147483647,
+                "minInclusive":  -2147483648
+            },
+            {
+                "name": "xs:short",
+                "baseType": "xs:int",
+                "maxInclusive": 32767,
+                "minInclusive":  -32768
+            },
+            {
+                "name": "xs:byte",
+                "baseType": "xs:short",
+                "maxInclusive": 127,
+                "minInclusive":  -128
+            },
+            {
+                "name": "xs:nonNegativeInteger",
+                "baseType": "xs:integer",
+                "minInclusive":  0
+            },
+            {
+                "name": "xs:unsignedLong",
+                "baseType": "xs:nonNegativeInteger",
+                "maxInclusive": 18446744073709551615
+            },
+            {
+                "name": "xs:unsignedInt",
+                "baseType": "xs:unsignedInt",
+                "maxInclusive": 4294967295
+            },
+            {
+                "name": "xs:unsignedShort",
+                "baseType": "xs:unsignedInt",
+                "maxInclusive": 65535
+            },
+            {
+                "name": "xs:unsignedByte",
+                "baseType": "xs:unsignedShort",
+                "maxInclusive": 255
+            },
+            {
+                "name": "xs:positiveInteger",
+                "baseType": "xs:nonNegativeInteger",
+                "minInclusive":  1
+            },
+            {
+                "name": "xs:yearMonthDuration",
+                "baseType": "xs:duration"
+            },
+            {
+                "name": "xs:dayTimeDuration",
+                "baseType": "xs:duration"
+            },
+            {
+                "name": "xs:dateTimeStamp",
+                "baseType": "xs:dateTime"
+            }
+        ]
+    }
+}