1 Status

This Public Working Draft has been approved for publication by the XBRL Standards Board for the purpose of obtaining feedback. It is not recommended for use in production systems, and may change significantly prior to finalisation.

2 Introduction

The XBRL v2.1 specification and XBRL Dimensions v1.0 specifications define an XML-based syntax for business reporting, along with accompanying metadata definitions known as taxonomies. While XML is the original format for XBRL, there is increasing demand to work with XBRL data in alternative formats.

This specification introduces a syntax-independent model for representing XBRL objects. The model captures the full range of semantic information encoded in the XML syntax of XBRL v2.1, and removes format-specific constructs. This enables consistent interpretation and use of XBRL models across multiple syntactic representations, supporting simpler, more portable implementations and greater accessibility for a broader range of users and technologies.

2.1 Scope

This document defines an XBRL model that encapsulates both the traditional XBRL taxonomy and OIM Report Model.

2.2 Terminology

The key words MUST, MUST NOT, REQUIRED, SHALL, SHALL NOT, SHOULD, SHOULD NOT, RECOMMENDED, MAY, and OPTIONAL, in this specification, are to be interpreted as described in IETF RFC 2119.

The keywords expanded name, NCName and QName are to be interpreted as described in the XML Names specification.

2.2.1 Defined terms for the XBRL Model

An XBRL model is a collection of XBRL objects that can be represented as a collection of XBRL modules or a single Compiled Model. An XBRL model is the complete set of objects that define a taxonomy or instance. An XBRL model can be represented as a single file or as a collection of files. An XBRL model can be extended by importing other models.

A XBRL module is the primary building block used to define models. A module defines XBRL objects within a single namespace. XBRL modules can refer to objects in different namespaces, using an import taxonomy object. All objects defined using the name property in a XBRL module are defined using the same namespace. A XBRL module can be imported by other modules or compiled into a compiled model. A module is identified with a documentType of https://xbrl.org/PWD/2026-09-01/module. A module is required to define a documentNamespacePrefix property in the documentInfo object, and all objects defined in the module are in the namespace defined by the documentNamespacePrefix.

A resolved model is a XBRL model in which all import taxonomy objects and extending objects have been processed and all references to external objects have been resolved. A resolved model is complete in the sense that it contains all objects necessary to fully interpret the model. A resolved model is not a compiled model as a compiled model is a serialisation format.

A compiled model is a fully resolved model that includes all objects defined in the entry module and all imported models. A compiled model is the result of processing an entry module and all its imports. The compiled model includes all objects that are discovered by processing all import taxonomy objects and extending objects defined in XBRL modules. A compiled model cannot include an import taxonomy object, an extending object or a documentNamespacePrefix property. An XBRL compiled model can be imported and extended by an XBRL module. A compiled model when serialized is identified with a documentType of https://xbrl.org/PWD/2026-09-01/compiled.

A label bundle module is a XBRL module that is used to provide an additional layer of presentational and annotational information to an existing XBRL model. Its primary purpose is to allow defining labels in different languages that can be layered on existing XBRL models. A label bundle module is restricted to defining label objects and indicates the XBRL model that it can be associated with. A label bundle module has a documentType of https://xbrl.org/PWD/2026-09-01/labelBundle.

A reference bundle module is a XBRL module that is used to provide an additional layer of reference information to an existing XBRL model. Its primary purpose is to allow defining references that can be layered on existing XBRL models. A reference bundle module is restricted to defining reference objects and indicates the XBRL model that it can be associated with. A reference bundle module has a documentType of https://xbrl.org/PWD/2026-09-01/referenceBundle.

A structurally valid document is a document that does not contain an object structure error. In the case of a JSON document the document must conform to the constraints defined in Section 3.2.

2.3 Documentation conventions

2.3.1 Definitions

Green text denotes a definition of the term in bold font. For example:

An example term is defined by this text.

2.3.2 Non-normative notes

Text in a blue box denotes a non-normative explanatory note:

This is non-normative commentary.

2.3.3 Error codes

QNames in parenthetical red text after a "MUST" or "MUST NOT" statement prescribe standardised error codes to be used if the preceding condition is violated. For example,

The example property MUST be defined (eg:exampleErrorCode).

"MUST" or "MUST NOT" statements that do not have a prescribed error code are not automatically enforceable, and processors are not required to detect violations.

2.3.4 Draft notes

Text in a dark blue box denotes a non-normative editorial note with information for reviewers of this draft specification.

This is a draft note.

2.4 Namespaces and namespace prefixes

This specification makes use of QName notation to refer to XML expanded names (the combination of a namespace URI and a local name) make use of abbreviated forms for these identifiers. This specification defines a number of prefixes as being reserved prefixes.

A reserved prefix is any prefix defined in the table below:

2.5 Object definitions

This specification defines a set of object types. Each object type has a set of named properties. The type of each property is specified in the format "(Model type / JSON type)".

The model type is:

• The name of another object type.
• An XML Schema built-in datatype, identified by a QName, apart from the types disallowed by the OIM specification.
• A model defined datatype, identified by a QName.
• The phrase object type reference, where object type is the name of a referenceable object type, indicating that the value is a QName that references model objects of the specified object type.
• The phrase object type QName, denoting that the value MUST be the object type QName of an object type defined in this specification (oimte:unknownObjectTypeQName);
• A collection type, specified by one of the above types, and prefixed with one of:
  • set of
  • non-empty set of
  • ordered set of
  • non-empty ordered set of

Where a collection type is stated as being non-empty, the collection MUST contain at least one item (oimte:invalidEmptySet). The evaluation of an empty set occurs when validating the XBRL module or compiled model. The evaluation of an empty set is performed at the document level and not the XBRL model level.

The JSON type is one or more JSON primitive types: string, array, object, or number.

The description of each named property indicates if the property is optional or required. For extensible objects additional usage constraints are defined in the definition. The definition identifies if the base object or extending object is optional, required or prohibited.

3 Validation

3.1 Object structure constraints

An object structure error is an error that occurs when an object does not conform to the structural requirements defined for that object type. Structural errors include the absence of required properties, the presence of properties that are not defined for the object type, and the conformity of property values to their specified types.

Where the specification defines an object structure error the processor raises the corresponding syntax error, dependent on the syntactic format that the model is expressed in. For example if the syntax is JSON then an invalid JSON Structure error is raised.

3.2 JSON representation constraints

The XBRL Model has a standard serialisation in JSON format. Files in this format MUST conform to the constraints in this section.

JSON documents MUST be valid JSON as defined in [RFC 8259] (oime:invalidJSON).

To ensure interoperability, all objects in JSON documents conforming to this specification MUST have unique keys (oime:invalidJSON).

JSON documents MUST use UTF-8 character encoding (oime:invalidJSON). Although a Unicode Byte Order Mark (BOM) MAY be included, it is neither required nor recommended.

This specification defines a model type and JSON type for each object property.

Values in a JSON document MUST conform to the specified JSON type (oimte:invalidJSONStructure)

Properties marked as "required" MUST be present whenever the containing object is present (oimte:invalidJSONStructureMissingRequiredProperty).

Objects cannot contain properties that are not defined for the object type (oimte:invalidJSONStructure).

3.3 Object name constraints

All namespace prefixes used in a XBRL module MUST be defined in the namespaces property of the document info object of the module (oimce:unboundPrefix).

All referenceable objects within an XBRL model MUST have a unique name property value within the XBRL model (oimte:duplicateObjects).

All referenceable objects objects defined in an XBRL Model with a documentType property of https://xbrl.org/PWD/2026-09-01/module MUST be in the namespace defined by the documentNamespacePrefix property of the document info object of the module (oimte:objectNamespaceMismatch).

XBRL modules MUST NOT have a documentNamespacePrefix that is a reserved prefix, or which maps to a namespace URI with a host component in the xbrl.org domain unless it is published by XBRL International.

3.4 Object reference constraints

Objects in an XBRL model may refer to other objects in the model using a QName value that refers to the name property of another object.

The term reference means that the value, or values in the case of collection types, of the specified property correspond to the name property of model objects of the specified object type.

The term referenced object means a referenceable object that is the subject of a reference.

Where a value is specified as being a reference:

• a referenceable object MUST exist in the model with that value as its name or be defined as an implied object (oimte:invalidQNameReference); and
• a referenced object MUST have the specified type (oimte:invalidObjectType).

Objects defined in an XBRL module with a reserved prefix (such as 'xbrl', 'xs', 'xbrlr') MUST only be bound to the namespace URI prescribed for that alias in the reserved prefix section of the specification, and MUST NOT be used as the namespace prefix for non specification defined object names in an XBRL Model (oimce:invalidURIForReservedAlias).

3.5 Duplicate Item constraints

Items included in a set or ordered set must have no repeating items. (oimte:duplicateItemsInSet)

3.6 Implied object resolution

For such identifiers, a XBRL module or compiled model MAY reference member objects or entity object that are not explicitly defined in an imported XBRL module. A QName whose namespace URI is registered as an implied object namespace that resolves to an implied object whose domain class is determined by the namespace binding. An implied object is treated as a fully valid object of the appropriate domain class. A processor MUST raise oimte:invalidObjectType for a QName whose prefix maps to an implied object namespace and the object does not match the expected object type defined by the implied object.

An implied object namespace MUST still be declared in the namespaces map of the document info object. The implied object mechanism exempts the requirement to define the object explicitly, but does not exempt the requirement to declare the prefix (oimce:unboundPrefix).

The prefix for an implied object namespace becomes a reserved prefix and MUST NOT be used to define objects in an XBRL module (oimce:invalidURIForReservedAlias).

The implied object defines the mapping of implied object namespaces to their domain classes.

4 Document management and content

4.1 XBRL document structure

An XBRL document consists of the following two objects:

documentInfo (documentInfo object / object)

(required) A document info object. This object describes the structure of a JSON document file, and that documentInfo is a document-level envelope that is not part of the compiled XBRL model.

xbrlModel (xbrl:xbrlModelObject / object)

(required) An XBRL Model object.

In JSON documents, the documentInfo object MUST appear before the xbrlModel object (oimte:invalidJSONStructure). Processors MUST validate document structure before processing model content, and the documentInfo object provides the namespace prefix map and other metadata required to interpret QName values in the xbrlModel. Placing documentInfo first ensures that a processor can resolve prefixes in document order without backtracking.

4.2 DocumentInfo

The document info object provides document-level information about the document. The document info object is a document-level envelope that is not part of the XBRL model. Every document (whether a module, a compiled model or a label bundle module) comprises a documentInfo object. The document info object is not semantic content that comprises the XBRL Model. The document info object is required to resolve the QName prefix to the namespace URI defined in the namespace map.

The object has the following properties:

documentType (xs:anyURI / string)

(required) A URI that represents the type of model document. This indicates if the model is a compiled model, a XBRL module, a label bundle module or a reference bundle module. A compiled model is indicated by the URI https://xbrl.org/PWD/2026-09-01/compiled, aXBRL module is indicated by the URI https://xbrl.org/PWD/2026-09-01/module, a label bundle module is indicated by the URI https://xbrl.org/PWD/2026-09-01/labelBundle, and a reference bundle module is indicated by the URI https://xbrl.org/PWD/2026-09-01/referenceBundle. The documentType property is not part of the XBRL model, but is a document level construct that indicates the type of document being processed. The value of documentType MUST be one of the four specified URIs, and processors MUST raise an error if an unrecognized URI is encountered (oimte:invalidDocumentType).

• compiled : Indicates a single model where all objects are defined within a single model and no external modules or models are imported. A compiled model cannot import and/or define a property of extends. A documentNamespacePrefix property is not permitted for a compiled model.

• module : Indicates a modular format where model objects can be defined in external models that are imported using the import taxonomy object. All objects defined must be in the namespace of the documentNamespacePrefix. A documentNamespacePrefix property is required for an XBRL module.

• labelBundle : Indicates a label bundle format comprising only label objects.

• referenceBundle : Indicates a reference bundle format comprising only reference objects.

namespaces (xbrl:namespaceObject / object)

(required) A prefix map object defining the prefix map for QNames, SQNames and xbrlr:prefixedContent values in a model.

documentNamespacePrefix (xs:NCName / string)

(optional) A NCName that identifies the namespace prefix of the document.

importMapping (xbrl:importMappingObject / object)

(optional) An import mapping object providing a mapping from an XBRL model object QName to the URL location of the model, used for import resolution.

sourceMappings (non-empty set of xbrl:factSourceMappingObject objects / array)

(optional) A set of fact source mapping objects listing the mapping between fact source object QNames and their source document URL locations. Although sourceMappings is excluded from the model (see Excluded properties), it is not removed from the document. A compiled model MUST retain the sourceMappings property in its documentInfo whenever the model contains fact value source objects or fact value anchor objects that reference an external source file via a source QName (oimte:missingSourceMapping).

description (xs:string / string)

(optional) A string that provides a description of the XBRL module.

The documentNamespacePrefix property is required if the model type is an XBRL module.

4.2.1 Document info constraints

If a documentNamespacePrefix property is defined in the document info object, the value of documentNamespacePrefix MUST be a prefix string that is defined as a key in the namespaces property of the document info object (oimte:documentNamespacePrefixNotDefined).

If the documentType property is https://xbrl.org/PWD/2026-09-01/module or https://xbrl.org/PWD/2026-09-01/labelBundle then the documentNamespacePrefix property MUST be defined (oimte:documentNamespaceNotDefined).

If the documentType property is https://xbrl.org/PWD/2026-09-01/compiled then:

• The documentNamespacePrefix property MUST NOT be defined (oimte:documentNamespaceDefinedForCompiledModel); and
• The importMapping property MUST NOT be defined (oimte:importMappingDefinedForCompiledTaxonomy).

4.2.2 Namespaces object

The namespaces object is a prefix map object that resolves the prefix component of a QName or SQName to a URI. The object has a QName of xbrl:namespaceObject.

The namespaces object consists of a set of prefix URI pairs.

{prefix} (xs:anyURI / string)

(required) The name of the key is a NCName prefix or URI alias and the value is the URI of the namespace associated with the URI alias.

The prefix map is a URI map that MUST conform to the constraints defined for the URI map object.

• A URI alias MUST NOT be empty, and MUST be valid NCNames (oimce:invalidURIAlias).
• A URI MUST NOT be bound to more than one URI alias within the map (oimce:multipleAliasesForURI).
• A URI alias MUST NOT be bound to more than one URI within the map (oimce:multipleURIsForAlias).
• A reserved URI alias MUST only be bound to the URI prescribed for that URI alias (oimce:invalidURIForReservedAlias).
• URIs MUST be valid according to the xs:anyURI datatype, and the encoded URI MUST be an absolute URI Reference IETF RFC 3986 (oimce:invalidURI).
• A URI for which a reserved prefix is prescribed MUST NOT be bound to any other URI alias (oimce:invalidAliasForReservedURI)

 "namespaces": {
            "exp":  "http://example.com/taxonomy",
            "lei": "http://standards.iso.org/iso/17442",
            "xbrl": "https://xbrl.org/PWD/2026-09-01",
            "iso4217": "http://www.xbrl.org/2003/iso4217",
            "utr": "https://xbrl.org/PWD/2026-09-01/utr",
            "xbrlr":"https://xbrl.org/PWD/2026-09-01/report",
            "xs": "http://www.w3.org/2001/XMLSchema",
            "ref":"https://xbrl.org/PWD/2026-09-01/ref"  
            }

4.2.3 Import mapping object

The import mapping object is a JSON object where each key is the QName of an XBRL Model object and each value is a single URL string identifying the location of the document that defines that model. The importMapping provides the processor with the file locations needed to resolve xbrlModelName references in import taxonomy objects.

The import mapping object has a QName of xbrl:importMappingObject.

Import mappings MUST NOT be defined for built-in models (oimte:illegalImportMappingForBuiltInTaxonomy).

The import mapping object consists of a set of model QName to URL pairs.

Any QName (xs:anyURI / string)

Provides a mapping from an XBRL Model object to a URL providing the location of the document containing that model.

 "importMapping": {
   "exp:SampleTaxonomy": "../examples/exampleTaxonomy.json",
   "xbrla:accountingModule": "../spec-taxonomies/xbrla.json"
  }

4.2.3.1 Import mapping object constraints

When a processor resolves an xbrlModelName reference that appears in importedTaxonomies, it must look up the QName in the import mapping object to obtain the URL, and retrieve and process the model at that URL.

If no importMapping key exists in the XBRL module for a xbrlModelName QName defined in an import taxonomy object that is not a built-in model, the processor MUST raise an error (oimte:taxonomyNotFound).

The import mapping objects defined in all the XBRL modules comprising a model MUST have the same URL corresponding to each xbrlModelName (oimte:inconsistentTaxonomyURL).

The document retrieved from the URL MUST be a structurally valid document.

Processors are not required to load or validate importMapping entries for model QNames that are not referenced in an import taxonomy object.

4.2.4 Fact source mapping object

The fact source mapping Object identifies a data source document and the fact source object QName reference. The object provides a sourceName (the fact source object) and a url (the location of the source document). The object enables processors to locate the actual data files (such as CSV files, HTML files, or other data formats) associated with each fact source object. The object has a QName of xbrl:factSourceMappingObject.

The fact source mapping object has the following properties:

sourceName (xs:QName / string)

(required) The QName of the fact source object this entry maps to a source document. Each sourceName QName MUST appear at most once in the array (oimte:duplicateSourceNameProperty).

url (xs:anyURI / string)

(required) A URL string identifying the location of the source document referenced by the factSource.

"sourceMappings": [
    {
        "sourceName": "exp:QuarterlyFinancials",
        "url": "https://example.com/data/q4-2025.csv"
    },
    {
        "sourceName": "aapl:annualReport",
        "url": "https://example.com/reports/aapl-20240928.htm"
    }
]

4.2.5 Document type identification

A document is considered to have the XBRL model document type if it is a valid JSON document and the JSON Pointer /documentInfo/documentType resolves to one of the following strings:

https://xbrl.org/PWD/2026-09-01/module
https://xbrl.org/PWD/2026-09-01/compiled
https://xbrl.org/PWD/2026-09-01/labelBundle
https://xbrl.org/PWD/2026-09-01/referenceBundle

If a document does not have this document type, it MUST be processed according to the rules defined in the OIM Common specification. In such cases, the errors defined in this specification MUST NOT be raised—with the exception of (oime:invalidJSON), which MUST still be enforced.

4.2.6 Bundle module constraints.

A label bundle module or reference bundle module MUST define the documentNamespacePrefix property of the document info object (oimte:documentNamespacePrefixNotDefined).

A label bundle module MUST only contain label objects in the model object (oimte:invalidBundleModuleContent).

A reference bundle module MUST only contain reference objects in the model object (oimte:invalidBundleModuleContent).

A label bundle module or reference bundle module MUST define the referenceModel property of the model object (oimte:missingBundleModuleReferenceModel).

A label bundle module used as an entry module MUST validate that the QName value of the forObject property of all label objects references an object defined in the referenceModel (oimte:invalidQNameReference). The referencedModel is resolved to a resolved model and the forObject property of all label objects in the label bundle module must reference an object defined in that resolved model.

A reference bundle module used as an entry module MUST validate that the QName value of the forObject or forObjects property of all reference objects references an object defined in the referenceModel (oimte:invalidQNameReference). The referencedModel is resolved to a resolved model and the forObject or forObjects property of all reference objects in the reference bundle module must reference an object defined in that resolved model.

A label bundle module or reference bundle module imported by an importing model ignores the referenceModel of the bundle module and removes objects in the bundle module that do not reference objects defined in the importing model. See forObject removal for details.

A referenceModel MUST NOT be defined for a documentType that does not represent a label bundle module or reference bundle module (oimte:invalidReferenceModelDocumentType).

5 Structural elements

An XBRL model consists of a set of model objects.

A model object is an object used to define an XBRL model.

All model objects in the model have an object type.

An object type is identified by an object type QName.

A referenceable object type is an object type that has a QName name property. Referenceable object types are indicated by "true" in the "referenceable" column in the above table.

A referenceable object is an object of a referenceable object type.

5.1 Model-defined properties

A model-defined property is an additional property associated with a model object. Model-defined properties are defined by the property type object, and instantiated using the property object.

Model-defined properties are specified using the properties property on the relevant model object and are supported on most object types.

5.2 XBRL model object

The XBRL model object is the container object that includes all other model objects that comprise a model. This includes what the XBRL 2.1 specification called taxonomy and instance components.

The XBRL model object has an object type QName of xbrl:xbrlModelObject.

5.2.1 XBRL model object properties

An XBRL Model object represents an entire model. It is a container for all the components of the model.

The properties of the XBRL Model object are as follows:

name (xs:QName / string)

(required) The name is a QName that uniquely identifies the XBRL Model object.

frameworkName (xs:string / string)

(optional) The framework name of the model such as "US-GAAP" that indicates the broad XBRL model family. The framework name stays consistent between regular releases of the same model domain.

version (xs:string / string)

(optional) Used to identify the version of the model. The version string SHOULD follow semantic versioning principles using the format major.minor.patch (e.g., "2024.1.0"). Where:

• major: Indicates significant changes that may include breaking changes or major structural updates (e.g., annual releases like "2024", "2025")
• minor: Indicates feature additions or enhancements that maintain backward compatibility
• patch: Indicates bug fixes, corrections, or minor updates that maintain backward compatibility

For simple annual releases, a year value may be used (e.g., "2024"). The version string MAY include additional metadata such as release candidate or build identifiers (e.g., "2024.1.0-rc1" or "2024.1.0+build.123").

modelType (xbrl:modelTypeObject reference / string)

(optional) A QName that indicates the specific model type object. Specification-defined model type objects include xbrl:report and xbrl:taxonomy.

duplicateFactsInModel (xs:string / string)

(optional) A string value that indicates if the model validates duplicate facts. It can be one of the following: no duplicates, complete duplicates,consistent duplicates, or inconsistent duplicates. If no string value is provided the default value is inconsistent duplicates. The value of duplicateFactsInModel sets the default value of duplicateFactsInCube. The value of duplicateFactsInCube has precedence over duplicateFactsInModel (see Section 8.10.2)

headings (non-empty set of xbrl:headingObject objects / array)

(optional) set of heading objects.

concepts (non-empty set of xbrl:conceptObject objects / array)

(optional) set of concept objects.

domainClasses (non-empty set of xbrl:domainClassObject objects / array)

(optional) set of domain class objects.

dimensions (non-empty set of xbrl:dimensionObject objects / array)

(optional) set of dimension objects.

domainNetworks (non-empty set of xbrl:domainNetworkObject objects / array)

(optional) set of domain network objects.

members (non-empty set of xbrl:memberObject objects / array)

(optional) set of member objects.

properties (non-empty set of xbrl:propertyObject objects / array)

(optional) set of property objects that specifies model-defined properties associated with the model.

labels (non-empty set of xbrl:labelObject objects / array)

(optional) set of label objects.

references (non-empty set of xbrl:referenceObject objects / array)

(optional) set of reference objects.

cubes (non-empty set of xbrl:cubeObject objects / array)

(optional) set of cube objects.

entities (non-empty set of xbrl:entityObject objects / array)

(optional) set of entity objects.

units (non-empty set of xbrl:unitObject objects / array)

(optional) set of unit objects.

facts (non-empty set of xbrl:factObject objects / array)

(optional) set of fact objects.

footnotes (non-empty set of xbrl:footnoteObject objects / array)

(optional) set of footnote objects.

factSources (non-empty set of xbrl:factSourceObject objects / array)

(optional) set of fact source objects.

factMaps (non-empty set of xbrl:factMapObject objects / array)

(optional) set of fact map objects.

JSONTemplateMaps (non-empty set of xbrl:JSONTemplateMapObject objects / array)

(optional) set of JSONTemplateMap objects that define mappings between JSON templates and model objects for the purpose of transforming between JSON data sources and XBRL models.

XMLTemplateMaps (non-empty set of xbrl:XMLTemplateMapObject objects / array)

(optional) set of XMLTemplateMap objects that define mappings between XML templates and model objects for the purpose of transforming between XML data sources and XBRL models.

groups (non-empty set of xbrl:groupObject objects / array)

(optional) set of group objects.

groupContents (non-empty set of xbrl:groupContentObject objects / array)

(optional) set of group content objects that link a group QName to a list of network or cube objects.

groupTree (xbrl:groupTreeObject / object)

(optional) A group tree object that defines the hierarchical organization of groups within the model. Unlike groupContents which links groups to networks and cubes, groupTree organizes the groups themselves into a tree structure. The root of the group tree is xbrl:rootSource, which acts as a virtual root (not rendered as a node) whose targets are the top-level groups. Only one group tree object is allowed per model.

networks (non-empty set of xbrl:networkObject objects / array)

(optional) set of network objects.

dataTypes (non-empty set of xbrl:dataTypeObject objects / array)

(optional) set of dataType objects.

collectionTypes (non-empty set of xbrl:collectionTypeObject objects / array)

(optional) set of collection type objects.

factLocatorTypes (non-empty set of xbrl:factLocatorTypeObject objects / array)

(optional) set of fact locator type objects that define the types of locators that can be used to reference facts in external data sources.

propertyTypes (non-empty set of xbrl:propertyTypeObject objects / array)

(optional) set of property type objects.

labelTypes (non-empty set of xbrl:labelTypeObject objects / array)

(optional) set of label type objects.

referenceTypes (non-empty set of xbrl:referenceTypeObject objects / array)

(optional) set of reference type objects.

relationshipTypes (non-empty set of xbrl:relationshipTypeObject objects / array)

(optional) set of relationship type objects.

modelTypes (non-empty set of xbrl:modelTypeObject objects / array)

(optional) set of model type objects.

cubeTypes (non-empty set of xbrl:cubeTypeObject objects / array)

(optional) set of cube type objects.

tableTemplates (non-empty set of xbrl:tableTemplateObject objects / array)

(optional) set of table template objects.

layouts (xbrl:layoutObject / object)

(optional) A set of layout objects that defines the layout of a data structure that conforms with a XBRL model. The layout object defines how facts in a model are rendered in a form or user interface.

transforms (non-empty set of xbrl:transformObject objects / array)

(optional) set of transform objects.

importedTaxonomies (non-empty set of xbrl:importTaxonomyObject objects / array)

(optional) set of import taxonomy objects that can comprise the QName of the XBRL model object to be imported, an object type or a model object referenced by its QName.

referenceModel (xbrl:xbrlModelObject reference / string)

(optional) A QName that references a XBRL model object. The referenceModel property is only used with a module that has a documentType of https://xbrl.org/PWD/2026-09-01/labelBundle or https://xbrl.org/PWD/2026-09-01/referenceBundle. The referenceModel property uses the import mapping object to locate the referenced taxonomy for validating label bundle module label objects or reference bundle module reference objects.

finalTaxonomy (xbrl:finalTaxonomyObject / object)

(optional) An object that indicates those components of the model that are final and cannot be amended or added by an importing model.

namespacePrefixes (non-empty set of xbrl:namespacePrefixObject objects / array)

(optional) A set of namespace prefix objects that define the preferred namespace prefixes for a given namespace URI.

impliedObjects (non-empty set of xbrl:impliedObject objects / array)

(optional) A set of implied objects that defines objects that are implied by the model but not explicitly defined.

5.3 Heading object

A heading object defines objects that have no reportable value, but are components of the concept dimension. Heading objects are used to define headers and to organize concepts into hierarchies on the concept core dimension.

The heading object has an object type QName of xbrl:headingObject.

5.3.1 Heading object properties

The heading object has the following explicit properties:

name (xs:QName / string)

(required) The name is a QName that uniquely identifies the heading object.

properties (non-empty set of xbrl:propertyObject objects / array)

(optional) A set of property objects that specifies model-defined properties associated with the heading object.

5.3.2 Heading object constraints

An heading object MUST NOT be defined as a dimension member on a fact (oimte:invalidFactDimensionMember).

5.4 Concept object

A concept object defines objects that can appear on the concept core dimension. All concept objects have an associated datatype that indicates the type of the value property of a fact value object defined by the concept object. The datatype property of the concept object defines the type of fact value associated with the concept. The concept object must have a periodType property that defines the date types of the period type dimension that can be used with a fact.

The concept object has an object type QName of xbrl:conceptObject.

5.4.1 Concept properties

The concept object has the following explicit properties:

name (xs:QName / string)

(required) The name is a QName that uniquely identifies the concept object.

dataType (xbrl:dataTypeObject reference / string)

(required) Specifies the datatype of the value. The value MUST be a QName referencing one of:

• a built-in XML Schema simple type as defined in XML Schema datatypes;
• a datatype defined in this specification (see Section 11.1.2);
• a custom datatype defined in the taxonomy model using the datatype object; or
• a collection type object defined in the taxonomy model.

The QName MUST resolve to a datatype object or collection type object present in the taxonomy model, or to a built-in XML Schema datatype. (see Section 11.1)

If the referenced QName is not a datatype object or collection type object, processors MUST raise an error (oimte:invalidObjectType).

periodType (xbrl:periodType / string)

(required) Indicates the period type of the concept. The value can be either instant, duration or none. An instant represents values that are measured at a point in time. (This is equivalent to a measurement at a point in time) A duration represents values measured over a period in time. none represents values that do not change with the passage of time. A value of none prohibits facts being reported with a xbrl:period dimension.

nillable (xs:boolean / boolean)

(optional) Used to specify if the concept can have a nil value. The default value is false.

enumerationDomain (xbrl:domainNetworkObject reference / string)

(optional) Specifies a domain network object that restricts the valid QName values for the concept. The value MUST be a QName referencing a domain network object defined in the taxonomy model. When specified, valid fact values for this concept MUST be QNames that resolve to target objects defined in the domain.

properties (non-empty set of xbrl:propertyObject objects / array)

(optional) set of property objects that specifies model-defined properties associated with the concept object.

{
    "name": "exp:Revenue",
    "dataType": "xbrlr:monetary",
    "periodType": "duration",
    "nillable": true,
    "properties": [
        { "property": "xbrla:balance", "value": "credit"}
    ]
},

5.5 Member object

A member object is an extensible object that adds dimensional context to a fact object. Its meaning and use is defined by its domain classes and property objects. A member object can be used on taxonomy defined dimensions where the domainClass property of the dimension is included in the member's domainClasses property. The domainClasses of a member object are used to define the meaning of the member within the context of the taxonomy, allowing it to be grouped with members of the same class and to restrict the use of properties to classes of members.

The member object has an object type QName of xbrl:memberObject.

5.5.1 Member object properties

The properties of the member object are:

name (xs:QName / string)

(optional) The name is a QName that uniquely identifies the member object.

• base object : (required)
• extending object : (prohibited)

domainClasses (non-empty set of xbrl:domainClassObject references / array)

(optional) a set of QNames that reference domain class objects that define the member. This allows the member to be used in multiple dimensions that reference different domain classes. If the member is defined in a domain relationship with a domain class root that is not included in the domainClasses property of the member, an error MUST be raised (oimte:invalidDomainClassReference).

• base object : (optional)
• extending object : (optional)

extends (xbrl:memberObject reference / string)

(optional) Names the member object to be extended. The extends property adds additional domainClasses and properties to the member object by extension.

• base object : (prohibited)
• extending object : (required)

isExtensible (xs:boolean / boolean)

(optional) If set to false, the member is non-extensible and no importing model may augment it using extends. If set to true or omitted, the member may be extended. The default value is true.

• base object : (optional)
• extending object : (optional)

properties (non-empty set of xbrl:propertyObject objects / array)

(optional) a set of property objects that specifies model-defined properties associated with the member object using the property object.

• base object : (optional)
• extending object : (optional)

{
  "name": "exp:England",
  "domainClasses": ["exp:CountryDomainClass"]
}

5.5.2 Member object constraints

The domainClasses set of the member object MUST NOT contain a domainClass of xbrl:conceptDomain, xbrl:entityDomain, xbrl:periodDomain, xbrl:languageDomain or xbrl:unitDomain (oimte:invalidDomainClassReference).

5.6 Domain class object

The domain class object is an extensible object that identifies the domain networks and members that are used with a dimension.

A dimension can be associated with different domain network objects in different cubes, but all such domain network objects must have the same domain class as the dimension. Member objects can belong to one or more domain classes. A member object's domain classes restrict the domain network objects that a member can be associated with.

The domain class object has an object type QName of xbrl:domainClassObject.

Multiple domain network objects may use the same domain class object. When defining a dimension object, the associated domain class object specifies which domain network objects are compatible with that <<>. This enables the identification and grouping of related dimensional domain network objects.

The core dimensions have pre-defined domain class objects:

• The built-in concept dimension xbrl:concept has a domain class object of xbrl:conceptDomain.
• The built-in entity dimension xbrl:entity has a domain class object of xbrl:entityDomain.
• The built-in unit dimension xbrl:unit has a domain class object of xbrl:unitDomain.
• The built-in language dimension xbrl:language has a domain class object of xbrl:languageDomain. The language domain is a typed domain — its values are BCP 47 language tag strings (e.g. "en", "fr-CA") rather than named model objects.

The built-in domain class objects of xbrl:conceptDomain and xbrl:languageDomain are only used with the concept core dimension, and language respectively.

The xbrl:entityDomain can be associated with a taxonomy defined dimension that represents a domain of legal entities such as a business acquisition dimension or business combination dimension. This allows the definition of domain networks that are specific to legal entities.

The xbrl:unitDomain can be associated with a taxonomy defined dimension that represents a domain of units such as debt denominated in different currency units. This allows the definition of domain networks that are specific to units.

A domain class object MAY be used as the root of multiple domain network objects.

{
    "name": "exp:CountryDomainClass",
    "allowedDomainItem": "xbrl:memberObject"
}

5.6.1 Domain class object properties

The properties of the domain class object are:

name (xs:QName / string)

(required) A QName that uniquely identifies the domain class object.

baseDomainClass (xbrl:domainClassObject reference / string)

(optional) The QName of a domain class object that is the base domain class for the defined domain class. The model-defined properties of the base domain class are inherited by this domain class, as described in Section 5.6.3.

allowedDomainItem (object type or datatype object reference / string)

(required) An object type QName or datatype object that can be used by dimensions associated with this domain class object. The object type QName is either xbrl:entityObject, xbrl:unitObject, xbrl:memberObject, xbrl:conceptObject or a datatype object QName. In the case of an object type QName, the objects defined in a domain network object with this domain class object as a root must be of this object type QName (see Section 5.8). In the case of a datatype object QName, this constrains the domain class values to this datatype object (see Section 5.10).

properties (non-empty set of xbrl:propertyObject objects / array)

(optional) a set of property objects that specifies model-defined properties associated with the domain class object.

"domainClasses" : [
            {
                "name": "exp:debtSecuritiesDomainClass",
                "baseDomainClass" : "exp:securitiesDomainClass",
                "allowedDomainItem": "xbrl:memberObject"
            }
],
"members" : [
            {
                "name":"exp:USTBillsDue2027",
                "domainClasses" : ["debtSecuritiesDomainClass"]  
            }
]

5.6.2 Domain class object constraints

A domain class object MUST NOT be used as a relationship object target property in a domain network object.(oimte:invalidDomainRelationshipTarget).

If the allowedDomainItem property of a domain class object defines a datatype (e.g., xs:string, xs:decimal), then the domain class object is considered a typed domain, and domain network objects MUST NOT be defined that use this domain class object. (oimte:domainClassMismatchWithDomain).

The allowedDomainItem property of a domain class object MUST have a value of either xbrl:entityObject, xbrl:unitObject, xbrl:memberObject, xbrl:conceptObject or a datatype object (oimte:invalidObjectType).

The built-in domain class objects of xbrl:conceptDomain MUST only be used with the concept core dimension (oimte:invalidConceptDomainClass).

The built-in domain class objects of xbrl:languageDomain MUST only be used with the language core dimension (oimte:invalidLanguageDomainClass).

If the baseDomainClass property is defined the allowedDomainItem value for the domain class object MUST be the same as the allowedDomainItem value for the base domain class object if an object type QName is referenced (oimte:inconsistentBaseDomainClass).

If the baseDomainClass property is defined the allowedDomainItem value for the domain class object MUST be the same or a subtype of the allowedDomainItem value for the base domain class object if an datatype object is referenced (oimte:inconsistentBaseDomainClass).

5.6.3 Domain class object inheritance

A domain class object can have a baseDomainClass property. When defined the domain class object will inherit the properties of the base domain class object. This includes the values of any model-defined properties of the base domain class object. The allowedDomainItem property of the domain class object must match the value of the base domain class object if a object type QName is defined. If the allowedDomainItem property is a datatype the datatpe must match or be derived from the base datatype object.

Any member objects associated with a domain class object using the domainClasses property of the member object are also implicitly included in the base domain class object.

All definitional model-defined properties on the baseDomainClass are inherited by the domain class object. The properties array of the domain class object are merged with that of the baseDomainClass, so that the domain class object inherits all base definitional model-defined properties and may declare additional definitional model-defined properties of its own. Where a definitional model-defined properties appears on both the baseDomainClass and the domainClass, the domainClass's property value MUST match the baseDomainClass. Non-definitional properties are not inherited.

5.7 Dimension object

A dimension object defines a taxonomy defined dimension or a core dimension. Taxonomy defined dimensions and core dimensions have an associated domain class object that defines the values that may be reported against the dimension.

The dimension object has an object type QName of xbrl:dimensionObject.

A taxonomy defined dimension is a dimension that is defined in the model. Taxonomy defined dimensions are explicitly declared in the model and can be referenced by cubes and facts. They are distinct from core dimensions which are defined in the xbrl namespace.

A core dimension is a dimension that is defined by this specification. These are xbrl:concept, xbrl:period, xbrl:entity, xbrl:unit and xbrl:language.

5.7.1 Properties of the dimension object

name (xs:QName / string)

(required) The QName of the dimension object.

domainClass (xbrl:domainClassObject reference / string)

(required) A reference to a domain class object.

cubeTypes (non-empty set of cube type object references / array)

(optional) a non-empty set of references to a cube type object that the dimension can only apply to. Can reference built-in cube types or taxonomy defined cube types. For example xbrla:eventCube, xbrla:referenceCube. If not defined the dimension can be applied to any cube type.

properties (non-empty set of xbrl:propertyObject objects / array)

(optional) a set of property objects that specifies model-defined properties associated with the dimension object.

{
    "name": "exp:CountryDimension",
    "domainClass": "exp:CountryDomainClass"
},

5.7.2 Dimension object constraints

The dimension MUST only be used on cubes where the cubeType of the cube object matches one of the cube types defined in the cubeTypes set (oimte:dimensionCubeTypeMismatch). If the cube object has no cubeType value defined it defaults to an open cube.

The xbrl:conceptDomain MUST only be used as the domainClass property on the concept dimension xbrl:concept (oimte:invalidConceptDomainClass).

The xbrl:languageDomain MUST only be used as the domainClass property on the language dimension xbrl:language (oimte:invalidLanguageDomainClass).

5.8 Domain Network object

The domain network object is an extensible object that defines a hierarchical network of concept objects, entity objects, unit objects or member objects. A domain network consists of relationship objects that determine the hierachy of the domain network. The domain network object can be referenced by the cube dimension object to define the untyped dimension values of a fact object or to define enumeration domains.

The domain network object has an object type QName of xbrl:domainNetworkObject.

An enumeration domain is a domain network object that is referenced by a concept object or property object to restrict a fact object value or a model-defined property value to a specific set of allowable QName values.

The domain network object has a root property that associates a domain class object with the domain network object. If no root is defined, the root is derived from resolving the relationship objects to determine the single root.

The relationshipTypeName property is not defined for a domain network object as the property of xbrl:domain-member is inherent to the domain network object versus a network object where it would have to be defined.

5.8.1 Importing domain network objects

Importing models cannot remove the objects defined in the relationship objects of the domain network object. Model objects may be imported and reassembled in a domain network object defined in an importing model.

Importing models can add relationship objects to an existing domain network object by referencing the name of the domain network object with the extends property to add relationship objects to the target domain network object.

5.8.2 Domain Network object properties

The properties of the domain network object are:

name (xs:QName / string)

(optional) The QName that uniquely identifies the domain network object.

• base object : (required)
• extending object : (prohibited)

root (xbrl:domainClassObject reference / string)

(optional) A reference to a domain class object that uniquely identifies the root of the domain network object.

• base object : (required)
• extending object : (prohibited)

relationships (non-empty set of xbrl:relationshipObject objects / array)

(optional) A non empty set of relationship objects that associate model objects with the domain network object.

• base object : (optional)
• extending object : (optional)

extends (xbrl:domainNetworkObject reference / string)

(optional) Names the domain network object that the defined domain network relationships are appended to. The items in the domain network with this property are appended to the end of the relationships defined in the target domain network object. This property cannot be used with the name property or the root property. (see Section 5.8) The QName MUST resolve to an existing domain network object; if the QName resolves to an object of a different type, processors MUST raise an error (oimte:invalidObjectType).

• base object : (prohibited)
• extending object : (required)

isExtensible (xs:boolean / boolean)

(optional) If set to false, the domain network is considered complete and non-extensible, meaning that no importing model may add further relationships or members. If set to true or omitted, the domain network may be extended by an importing model. The default value is true.

• base object : (optional)
• extending object : (optional)

properties (non-empty set of xbrl:propertyObject objects / array)

(optional) a set of property objects that specifies model-defined properties associated with the domain network object.

• base object : (optional)
• extending object : (optional)

{
    "name": "exp:DomainOfCommonwealthCountries",
    "root": "exp:CountryDomainClass",
    "relationships": [
        {
            "source": "exp:CountryDomainClass",
            "target": "exp:Australia"
        },
        {
            "source": "exp:CountryDomainClass",
            "target": "exp:Canada"
        },
        {
            "source": "exp:CountryDomainClass",
            "target": "exp:England"
        }
    ]
}

Domain network objects include the QName of a domain class object for the root property. Multiple domain networks can be defined with the same domain class object and the same root QName.

5.8.3 Domain Network object constraints

A domain class object QName MUST NOT be defined as a target in any relationship object contained in a domain network object (oimte:invalidDomainRelationshipTarget).

A domain network object's set of relationships MUST include a domain class object as a source in the domain network (oimte:missingDomainClassSource).

A domain network object's set of relationships MUST resolve to a single root in the domain network. (oimte:multipleDomainClasses)

If the root property has a QName of xbrl:conceptDomain then the objects used as a source in the relationships of the domain network object MUST be either a concept object, a heading object or be xbrl:conceptDomain (oimte:invalidDomainNetworkObject).

If the root property has a QName of xbrl:conceptDomain then the objects used as a target in the relationships of the domain network object MUST be either a concept object or an heading object (oimte:invalidDomainNetworkObject).

A domain network object with a root property of xbrl:entityDomain MUST only have a relationship object source property that is either an entity object or a domain class object. (oimte:invalidDomainNetworkObject)

A domain network object with a root property of xbrl:entityDomain MUST only have a relationship object target property that is an entity object. (oimte:invalidDomainNetworkObject)

A domain network object with a root property of xbrl:unitDomain MUST only have a relationship object source property that is either a unit object or a domain class object. (oimte:invalidDomainNetworkObject)

A domain network object with a root property of xbrl:unitDomain MUST only have a relationship object target property that is a unit object. (oimte:invalidDomainNetworkObject)

If the root property is NOT xbrl:conceptDomain, xbrl:entityDomain, xbrl:unitDomain or xbrl:languageDomain then the objects used as a target in the relationships of the domain network object MUST NOT be concept objects or unit objects unless expressly permitted by the allowedDomainItem of the domain class object represented by the root property (oimte:invalidDomainTarget).

The root property MUST contain a QName of a domain class object. (oimte:invalidDomainClass)

A domain network objects relationship objects MUST only include target objects that are defined in the allowedDomainItem of the domain class object>, except for heading objects that are always permitted in a domain network whose root is xbrl:conceptDomain, irrespective of the value of allowedDomainItem (oimte:invalidDomainNetworkObject).

A domain network objects relationship objects MUST only include domain source objects that are defined in the allowedDomainItem property, are a domain class object, or are a heading object in a domain network object whose root is xbrl:conceptDomain (oimte:invalidDomainNetworkObject).

The name and extends properties MUST NOT both appear in a domain network object (oimte:invalidJSONStructure).

Relationships in the domain network object MUST have a target object of either a concept object, a member object, an entity object, a heading object or a unit object. (oimte:invalidDomainRelationshipTarget)

If a model's documentType is defined as https://xbrl.org/PWD/2026-09-01/compiled then the extends MUST NOT be defined (oimte:extendedTargetNameDefinedForCompiledTaxonomy).

5.9 Cube object

A cube object is an extensible object that defines a multidimensional framework to contain facts. A cube specifies which dimensions and members are included, and which can be constrained to exclude specific facts. The multidimensional spaces defined by a cube can be empty, sparsely or densely packed with facts. A fact can exist in one or more cubes. A cube defines all dimensions (including core dimensions) to accurately identify all facts associated with the cube. A cube can contain facts with fewer dimensions than those defined by the cube. Facts with dimensions not defined in the cube are not included within the cube. Cubes can be used to identify collections of facts that are grouped together such as facts in a Statement of Operating Activity or a listing of inventory held.

The cube object has an object type QName of xbrl:cubeObject.

A cube defines all dimensions (e.g. incl period, entity, units) to accurately identify all facts associated with the cube.

A cube object may include an optional cubeType property that identifies the type of cube object being represented. This value must match either a defined cube type object or specification-defined cube object. Depending on the cubeType core dimensions may or may not be included. For example, a report cube will always include the period, concept, entity and unit dimensions, whereas an event cube will only include the concept core dimension.

A cube object includes all facts that match the dimensions and member objects defined in the taxonomy, as well as the concept core dimension and concept objects, the unit core dimension and unit objects, entity core dimension and entity objects and period core dimension with matching typed values.

A cube can contain facts that have fewer dimensions than those defined in the cube. A fact can appear in the cube without one or more dimensions as long as each of the cube dimension objects has the property optional set to true for the dimensions missing from the fact. Valid facts in a cube without all the dimensions defined in the cube are called an optional dimension value.

A fact cannot appear in a cube object if it includes a dimension that is not defined within the cube object.

An exclude cube is a cube object used to remove facts from another cube. It is defined in the taxonomy and specified using the excludeCubes property. The intersection of facts in the exclude cube object and the defined cube object are removed from the resulting cube. This intersection may include all, some, or none of the facts.

A cube object can define zero or more excludeCubes. When multiple exclude cubes are specified, the facts removed are the union of all intersections between the defined cube and each exclude cube.

5.9.1 Cube properties

The cube object has the following properties:

name (xs:QName / string)

(optional) The name property is a QName that uniquely identifies the cube object.

• base object : (required)
• extending object : (prohibited)

cubeType (xbrl:cubeTypeObject reference / string)

(optional) The cubeType property identifies the type of cube being defined. This must match a defined cube type object or specification defined cube object.

• base object : (optional)
• extending object : (prohibited)

cubeDimensions (non-empty set of xbrl:cubeDimensionObject objects / array)

(optional) A set of cube dimension objects that identify the dimensions and associated domains used on the cube.

• base object : (required)
• extending object : (prohibited)

cubeNetworks (non-empty set of xbrl:networkObject references / array)

(optional) A set of QName references to a network object, that are directly related to the cube.

• base object : (optional)
• extending object : (optional)

excludeCubes (non-empty set of xbrl:cubeObject references / array)

(optional) A set of cube object QNames that remove the facts of the exclude cube from the facts of the defined cube. The resulting cube includes all facts that are in the defined cube but not in any of the exclude cubes. Exclude cubes must have a cubeType of xbrl:negativeCube. Exclude cubes cannot be used to exclude facts from another exclude cube.

• base object : (optional)
• extending object : (prohibited)

requiredCubes (non-empty set of xbrl:cubeObject references / array)

(optional) A set of QName references to a cube object, that indicate facts in the cube that are required to be present. This allows defining a cube object to indicate cells or groups of cells that must be present in the cube. The extends property can be used to add requiredCubes to an existing cube. A cube which has a type of xbrl:negativeCube cannot be included in the requiredCubes property. The requiredCubes property can reference itself, which means all facts in the cube are required to be present, except those facts that are excluded by the excludeCubes property. If facts defined by requiredCubes are absent from the cube, then no error is raised.

• base object : (optional)
• extending object : (optional)

duplicateFactsInCube (xs:string / string)

(optional) A string value that indicates if the cube validates duplicate facts. It can be one of the following: no duplicates, complete duplicates,consistent duplicates, or inconsistent duplicates. If no string value is provided the default value is the value defined for duplicateFactsInModel. If no value is defined for duplicateFactsInModel, the default value is inconsistent duplicates. If an inconsistent duplicate fact exists in a model it must match the dimension values of at least one cube in the model that allows inconsistent duplicates. If a consistent duplicate fact exists in a model it must match the dimension values of at least one cube in the model that allows consistent duplicates or inconsistent duplicates (see Section 8.10.2)

• base object : (optional)
• extending object : (prohibited)

properties (non-empty set of xbrl:propertyObject objects / array)

(optional) A set of property objects that specifies model-defined properties associated with the cube using the property object.

• base object : (optional)
• extending object : (optional)

extends (xbrl:cubeObject reference / string)

(optional) Names the cube object that the defined cube properties are appended to. The items in the cube with this property are appended to the end of the properties defined in the target cube object. This property cannot be used in conjunction with the name, cubeType and cubeDimensions properties. The ability to extend a cube can be used to add cubeNetworks, properties and requiredCubes (see Section 5.9).

• base object : (prohibited)
• extending object : (required)

isExtensible (xs:boolean / boolean)

(optional) Defines whether the cube object can be extended by another cube object. Defaults to true.

• base object : (optional)
• extending object : (optional)

{
    "name": "exp:IncomeStatementCube",
    "cubeType": "xbrl:reportCube",
    "cubeDimensions": [
        { "dimension": "xbrl:concept", "domainNetwork": "exp:IncomeStatementConcepts" },
        { "dimension": "xbrl:period" },
        { "dimension": "xbrl:entity" },
        { "dimension": "xbrl:unit" }
    ],
    "isExtensible": false
}

5.9.2 Cube object constraints

The cubeType property MUST be a QName of a cube type object. (oimte:invalidObjectType)

The requiredCubes set and excludeCubes set MUST contain cube type objects. (oimte:invalidObjectType)

The cubeDimensions property MUST NOT include more than one cube dimension object with the same dimension property. (oimte:duplicateDimensionsInCube)

The defined cube MUST NOT be defined in the set of excludeCubes within the same cube object. (oimte:excludeCubeSelfReference)

The cubeNetworks property MUST only reference the QNames of network objects (oimte:invalidObjectType).

The cubeNetworks property MUST reference network objects that exist in the XBRL Model. (oimte:invalidQNameReference)

The excludeCubes property MUST reference cube objects that exists in the XBRL Model that have a cube type of xbrl:negativeCube. (oimte:invalidNegativeCubeReference)

If the model type object includes fact objects the processor MUST report an error if the dimensional value defined by a requiredCube does not include a fact in the cube object (oimte:factMissingFromCube).

If a cube is included in the requiredCubes property of another cube object, an error MUST be raised if any dimensional space in the required cube object is not a dimensional space in the base cube object. (oimte:requiredCubeDimensionalSpaceMissingFromCube)

If the same cube appears in both the excludeCubes and requiredCubes properties, an error MUST be raised (oimte:excludeCubeCannotBeRequiredCube).

A cube with cubeType of xbrl:negativeCube MUST NOT specify the excludeCubes property. (oimte:excludeCubesOnNegativeCube)

If the same dimensional space appears in both the excludeCubes and requiredCubes properties, an error MUST be raised. (oimte:excludeCubeSharesDimensionalSpaceWithRequiredCube)

The extends property of a cube object MUST reference the QName of an existing cube object. If the QName does not resolve to a cube object, processors MUST raise an error (oimte:invalidObjectType).

5.10 Cube dimension object

The cube dimension object associates a dimension with a specific cube object. Each cube object must contain at least one or more cube dimension objects. Specific cube types defined by the cubeType property restrict what dimension objects can appear in the cube. The cube dimension object can optionally define the QName of a specific domain network object to constrain which members are allowed in the cube. Whether a dimension is typed or explicit is determined by whether the associated domain has a domainDataType property. The cube dimension object defines if fact values without a dimensional qualifier (optional dimension value) are included in the cube. The cube dimension object may define period dimension properties that constrain the facts accordingly.

The cube dimension object has an object type QName of xbrl:cubeDimensionObject.

The facts contained in a cube are those facts that match the dimensions and members defined in the cube object. The fact dimension values must match the members of the cube dimension.

Where a taxonomy defined dimension is defined with NO domainNetwork property, then a fact with any member and that dimension, will appear in the cube with that dimension.

Where a concept dimension is defined with NO domainNetwork property then a fact with any concept will appear in the cube.

An error MUST be raised if the domainDataType property is used with the concept dimension (oimte:invalidDataTypeForDomainClass).

Where a period dimension is defined with the domainNetwork property then an error MUST be raised. (oimte:domainNetworkUsedOnPeriodDimension)

Where a unit dimension is defined with NO domainNetwork and NO domainDataType properties then a fact with any unit will appear in the cube.

Where an entity dimension is defined with NO domainNetwork and NO domainDataType properties then a fact with any entity will appear in the cube.

5.10.1 Cube dimension object properties

The cube dimension object has the following properties:

dimension (xbrl:dimensionObject reference / string)

(required) The QName of the dimension object that identifies the dimension. For the core dimensions the QNames of xbrl:concept, xbrl:period, xbrl:entity, xbrl:unit and xbrl:language are used. (see Section 5.7)

domainNetwork (xbrl:domainNetworkObject reference / string)

(optional) The QName of the domain network object that identifies the domain associated with the dimension. The domainNetwork property can only be used to define an explicit domain. Only one explicit domain can be associated with a dimension. The domain referenced MUST have the same root as the dimension's domainClass. (oimte:invalidCubeDimensionDomainName)(see Section 5.8).

domainDataType (xbrl:dataTypeObject reference / string)

(optional) A reference to a datatype object that indicates the datatype that can be represented on the fact object for this dimension. This property allows a typed domain class object to be associated with a dimension. The referenced datatype object object MUST either match the dimensions domain class object allowedDomainItem property value or be derived from the base datatype of the datatype object. (oimte:invalidDataTypeForDomainClass).

typedSort (xs:string / string)

(optional) A string value that indicates the sort order of the typed domain. The values can be either asc or desc. This indicates the viewing order of the values using a typed domain. The typedSort property MUST NOT be used with an explicit domain (domains without domainDataType). (oimte:invalidTypedSortOnExplicitDomain) The typedSort can be used with the period domain. The sort order is applied to each period constraint defined in periodConstraints. If there are two period constraints the first for instant and the second for duration and a typedSort of asc then all instant dates appear first ascending, then all duration dates appear second in ascending order.

optional (xs:boolean / boolean)

(optional) Indicates whether facts that do not carry a value for this dimension are included in the cube. The default value is false. When set to true, facts that omit this dimension are included in the cube. For the period core dimension, this includes forever facts and facts with no period dimension. For the unit dimension, this includes facts with no unit, such as strings or dates. For the entity core dimension, this includes facts with no entity value. This property cannot be used on the concept core dimension. The property value is ignored for the concept core dimension.

periodConstraints (non-empty ordered set of xbrl:periodConstraintObject objects / array)

(optional only for period core dimension) Defines an ordered set of period constraint objects to restrict fact values in a cube to fact values with a specified period.

[
    {
        "dimension": "xbrl:concept",
        "domainNetwork": "exp:IncomeStatementConcepts"
    },
    {
        "dimension": "xbrl:period",
        "periodConstraints": [
            {
                "onOrAfter": { "context": "exp:PeriodStart" },
                "onOrBefore": { "context": "exp:PeriodEnd" }
            }
        ]
    }
]

If a typedSort property is provided and a domainDataType property is not provided, processors MUST raise an object structure error.

5.10.2 Cube dimension object constraints

The periodConstraints property MUST only be used where the dimension property has a QName value of xbrl:period. (oimte:invalidPeriodConstraintDimension)

The optional property MUST NOT be used with a dimension of xbrl:concept (oimte:invalidOptionalPropertyOnConceptDimension)

A dimension with a QName of xbrl:concept MUST be defined in a cube object. (oimte:cubeMissingConceptDimension)

The dimension property must reference a dimension object. (oimte:invalidObjectType)

The domainNetwork property MUST NOT be used when the dimension property is xbrl:period. (oimte:domainNetworkUsedOnPeriodDimension)

The domainDataType property MUST NOT be used when the dimension property is xbrl:period. (oimte:domainUsedOnPeriodDimension)

If the domainNetwork property is specified, the referenced domain's root MUST match the dimension's domainClass. (oimte:invalidCubeDimensionDomainName)

The domainNetwork property must be a valid domain network object QName defined in the taxonomy model. (oimte:invalidObjectType)

If the dimension property is xbrl:entity and the domainDataType property is specified, it MUST be xs:QName. (oimte:invalidDataTypeForDomainClass)

A cube MUST NOT include multiple cube dimension objects with the same dimension attribute. (oimte:duplicateDimensionsInCube)

A cube dimension object MUST comply with the dimension restrictions defined by the cubeType property (oimte:invalidTaxonomyDefinedDimension).

5.11 Period constraint object

The period constraint object defines the period constraints that are applied to the core period dimension. These period constraint properties are used to select those facts whose periods match the periods defined in the period constraint object. If a facts period dimension matches all the defined properties then it is included in the cube.

The period constraint object has an object type QName of xbrl:periodConstraintObject.

5.11.1 Period constraint object properties

The period constraint object has the following properties:

periodType (xbrl:periodType / string)

(optional) Used to indicate if the period is an instant or a duration.

timeSpan (xs:duration / string)

(optional) Defines a duration of time using the XML duration type to define a duration of time. The duration of the time span maps to facts with the same duration.

periodPattern (string / string)

(optional) Defines a date or duration pattern that selects dates or durations. For an instant the pattern to select all dates in December is YYYY-12-DD. For a duration the pattern to select all year end durations is YYYY-01-01/YYYY-01-01T00:00:00. The pattern uses the following symbols:

• YYYY - four digit year
• MM - two digit month
• DD - two digit day
• hh - two digit hour
• mm - two digit minute
• ss - two digit second
• T - date time separator
• eom - end of month wildcard
• / - used to separate start and end dates for durations

To indicate the end of month use the wildcard eom. For example, to select all durations that end on the last day of February use the pattern YYYY-MM-DD/YYYY-02-eom. For any duration period that starts at the start of a month and ends at the end of month use YYYY-MM-01/YYYY-MM-eom.

endDate (xbrl:dateResolutionObject / object)

(optional) Defines an end date for a duration fact and the date of an instant fact. Values can be provided as a literal date value, a fact with a date value, or the date context value of a date.

startDate (xbrl:dateResolutionObject / object)

(optional) Defines a start date for a duration fact and the date of an instant fact. Values can be provided as a literal date value, a fact with a date value, or the date context value of a date.

onOrAfter (xbrl:dateResolutionObject / object)

(optional) Defines a datetime where all instant facts on or after the date are included in the cube. Duration facts which start at or after the specified datetime are included in the cube.

onOrBefore (xbrl:dateResolutionObject / object)

(optional) Defines a datetime where all instant facts before or on the date are included in the cube. Duration facts which end at or before the specified datetime are included in the cube.

{
    "onOrAfter": { "context": "exp:ReportingPeriodStart" },
    "onOrBefore": { "context": "exp:ReportingPeriodEnd" }
}

{
    "endDate": { "value": "2024-12-31" },
    "timeSpan": "P1Y"
}

5.11.2 Period constraint object constraints

The timeSpan property MUST NOT be used with both the endDate and startDate properties (oimte:redundantTimeSpanProperty).

The periodPattern property MUST NOT be used with the timeSpan, endDate or startDate properties if it represents a duration. (oimte:redundantPeriodPatternProperty).

If the periodType property is instant then the timeSpan and startDate properties MUST NOT be defined (oimte:instantWithDurationProperties).

All period constraints in the object are considered to be an AND.

Separate period constraint objects are defined as OR.

5.12 Date resolution object

The endDate, startDate, onOrAfter and onOrBefore property are defined using the date resolution object that resolves the properties of the object to a specific date or set of dates. The date can be dependent on the fact values in an XBRL report, the context date values in an XBRL report, a literal date value or a date derived using a time shift based on one of the previous date properties.

The date resolution object has an object type QName of xbrl:dateResolutionObject.

5.12.1 Date resolution properties

The date resolution object has the following properties:

conceptName (xbrl:conceptObject reference / string)

(optional) Identifies the QName of a concept object that has an xs:date or xs:dateTime datatype or derived from xs:date or xs:dateTime datatype. The fact values of the concept object in a report resolves to a set of dates used to determine the date resolution value. If no fact value exists for the concept object in the report then the property is ignored, and no date constraint is enforced on the cube.

context (xs:string / string)

(optional) Identifies the QName of a concept object with a suffix of @start or @end. Facts in a report resolve to a set of dates or durations associated with the period dimension of the resolved facts. The context string indicates if the end date or start date of the facts period dimension values (context) is used as the date resolution object value. The @ symbol following the QName identifies if the end date or start date of the context or contexts is used. The context end or start dates of the fact values can resolve to a single date or a set of dates. If no value exists in the report then the property is ignored. The context suffix following the QName must be either @end or @start. If an @ value is not provided then the suffix defaults to @end. For a fact that is an instant the @start and @end suffix will return the same value. If the fact has no period dimension then the property is ignored.

dateProperty (object reference / string)

(optional) References a date or duration value defined as a property of an object. Identifies the QName of a model object and the property object associated with the reference object and uses @start or @end suffix if a duration i.e. exp:myExtTaxonomy.xbrl:reportPeriod@end. The dateProperty can only reference a model-defined property of the object. If the value of the property is a date then the @end or@start suffix is ignored. If the property value cannot be resolved to a date or duration then the property is ignored. If both the context property and the dateProperty property are provided the dateProperty property takes precedence unless the value of the property cannot be resolved to a date.

value (xs:dateTime / string)

(optional) A value representing the date time. The date time values used in this representation MUST be valid according to the xs:dateTime datatype and MUST be in the canonical lexical representation.

timeShift (xs:duration / string)

(optional) Defines a time duration shift from the date derived from either the value, context or conceptName properties. The duration of the time shift is defined using the XML duration type to define a duration of time. A negative operator deducts the timeShift from the resolved date. If the context or conceptName resolves to a set of dates the time shift is applied to all dates in the set. A value of P1Y will shift the date forward by one year, -P1M will shift the date back by one month, P1D will shift the date by one day. The timeShift property can be used with any of the other properties to shift the date value returned by the property. The timeShift property cannot be the only property defined.

{ "conceptName": "exp:FiscalYearEnd" }

{ "value": "2024-12-31" }

{ "context": "exp:ReportingPeriodEnd", "timeShift": "P1D" }

5.12.2 Date resolution constraints

The conceptName property is required if no context or value property is provided. If not provided, processors MUST raise an object structure error. If both conceptName and context or value properties are provided, processors MUST raise an object structure error.

The context property is required if no conceptName or value property is provided. If not provided, processors MUST raise an object structure error. If both context and value properties are provided, processors MUST raise an object structure error.

The value property is required if no conceptName or context property is provided. If not provided, processors MUST raise an object structure error.

The datatype of the concept object referenced by the conceptName property MUST be xs:date or xs:dateTime or derived from xs:date or xs:dateTime. (oimte:invalidConceptDataType)

The concept object referenced by the conceptName property MUST be a concept Object. (oimte:invalidObjectType )

The context property MUST reference a concept object. (oimte:invalidObjectType )

Only one of the properties conceptName or context or value or dateProperty MUST be present. (oimte:mutuallyExclusiveDateResolutionProperty)

The timeShift property MUST be used with either conceptName or context or value or dateProperty (oimte:redundantTimeShiftProperty).

5.12.3 Date resolution behavior

If a date is resolved using a concept name the value of all unique fact date values are returned. If there is more than one date then each unique date fact MUST create iterations of allowable date constraints on the cube.

If the conceptName property is used in conjunction with the timeShift property and multiple unique date facts are present then the value of the timeShift is applied to each fact to return a set of dates.

If the context property is used in conjunction with the timeShift property and multiple unique date contexts are present then the value of the timeShift is applied to each context to return a set of dates.

5.13 Property object

The property object instantiates a model-defined property.

The property object has an object type QName of xbrl:propertyObject.

The property value is constrained by the datatype of the property type object, which may be a scalar type or a collection type object. The property type object may also restrict the object types that a property can be used with.

The following object types support model-defined properties:

• XBRL Model object
• concept object
• cube object
• heading object
• member object
• dimension object
• entity object
• network object
• group object
• cube object
• domain network object
• domain class object
• relationship object
• label object
• reference object
• fact source object
• fact object

5.13.1 Property object properties

property (xbrl:propertyTypeObject reference / string)

(required) The name of the property type object that defines the property.

value

(required) The value of the property.

{
    "name": "exp:Assets",
    "dataType": "xbrlr:monetary",
    "periodType": "instant",
    "nillable": true,
    "properties": [
        { "property": "xbrla:balance", "value": "debit"}
    ]
},

5.13.2 Property object constraints

An object that adds a property that is not included in the allowedObjects set of the property type object MUST raise an error (oimte:disallowedObjectProperty).

If a property value does not conform to its expected datatype the processor MUST raise an error (oimte:propertyValueDataTypeMismatch).

5.14 Label object

The label object defines a label that can be associated with an object. A label is associated with a QName of the object. Multiple labels can be associated with an object. Labels can be distinguished by label type and language.

The label object has an object type QName of xbrl:labelObject.

A label is associated with one object by defining the QName of the object. Labels can be of different types. Standard label types are defined in the XBRL specification and in the label defined in a taxonomy. Label types can be defined in a taxonomy using the label type object.

5.14.1 Label object properties

forObject (xs:QName / string)

(required) Defines the QName of the object that this label is associated with.

labelType (xbrl:labelTypeObject reference / string)

(required) A QName representing the label type of the label. This can be a taxonomy defined label type or a standard XBRL label type defined in specification.

language (xs:string / string)

(required) Defines the language of the label using a valid BCP 47 language code.

value (xs:string / string)

(required) The text of the label.

{
    "forObject": "exp:Revenue",
    "labelType": "xbrl:label",
    "language": "en",
    "value": "Revenue"
}

{
    "forObject": "exp:Revenue",
    "labelType": "xbrl:verboseLabel",
    "language": "en",
    "value": "Total Revenue from Continuing Operations"
}

5.14.2 Label object constraints

The value for language MUST be a valid BCP 47 language code (oimte:invalidLanguage).

A label's forObject property MUST resolve to an model object QName or object type QName defined in the XBRL Model (oimte:invalidQNameReference).

A label object MUST NOT be defined for an object if the labelType property of the label object references a label type object whose allowedObjects property value does not include that object's type (oimte:disallowedObjectLabelType). The label type object defines a non-empty set of allowable objects using the allowedObjects property. If the allowedObjects property is not defined, then the label type object allows labels for all objects.

The value of the label MUST conform to the contentConstraints object defined by its labelType (oimte:invalidLabelValue).

Duplicate labels MUST NOT be defined in the XBRL Model. Duplicate labels are labels with the same forObject, labelType and language properties. (oimte:duplicateLabelObject)..

5.15 Reference object

The reference object is an extensible object that defines a reference that can be associated with one or more objects. A reference is associated with a QName of the object. Multiple references can be associated with an object and multiple objects can be associated with a reference. References are distinguished by their QName.

The reference object has an object type QName of xbrl:referenceObject.

A reference can be associated with one or more objects by defining the QNames of the objects it is associated with in the forObjects property. References can be of different types. Standard reference types are defined in the XBRL specification. Reference types can also be defined in a taxonomy using the reference type object.

5.15.1 Reference object properties

name (xs:QName / string)

(optional) The name is a QName that uniquely identifies the reference object.

• base object : (required)
• extending object : (prohibited)

extends (xbrl:referenceObject reference / string)

(optional) The name of the reference object that the defined forObjects set should be appended to. The forObjects set in the reference with this property are appended to the forObjects set defined in the target reference object. This property cannot be used in conjunction with the name, referenceType and language properties. The QName MUST resolve to an existing reference object; if the QName resolves to an object of a different type, processors MUST raise an error (oimte:invalidObjectType). If the extends is defined either a QName value MUST be provided in the forObjects set or a property object value for the properties set. oimte:invalidJSONStructureMissingRequiredProperty

• base object : (prohibited)
• extending object : (required)

isExtensible (xs:boolean / boolean)

(optional) If set to false, the reference is non-extensible and no importing model may augment it using extends. If set to true or omitted, the reference may be extended. The default value is true.

• base object : (optional)
• extending object : (optional)

forObjects (non-empty set of model object QName references / array)

(optional) Defines a set of model object QName references that the reference is associated with.

• base object : (optional)
• extending object : (optional)

referenceType (xbrl:referenceTypeObject reference / string)

(optional) A QName representing the reference type of the reference. This can be a taxonomy defined reference or a standard XBRL reference included in the specification.

• base object : (optional)
• extending object : (prohibited)

language (xs:string / string)

(optional) Defines the language of the reference using a valid BCP 47 language code.

• base object : (optional)
• extending object : (prohibited)

properties (non-empty set of xbrl:propertyObject objects / array)

(optional) A set of property objects used to identify the properties of the reference. The order of the properties is defined by the orderedProperties attribute of the reference type object.

• base object : (optional)
• extending object : (optional)

{
    "name": "exp:RevenueIAS18Ref",
    "forObjects": ["exp:Revenue"],
    "referenceType": "ref:StandardReference",
    "properties": [
        { "property": "ref:Publisher", "value": "IASB" },
        { "property": "ref:Name", "value": "IAS 18" },
        { "property": "ref:Paragraph", "value": "7" },
        { "property": "ref:IssueDate", "value": "2003-12-01" }
    ]
}

5.15.2 Reference object constraints

The name property is required unless the extends property references an existing reference object. If neither name nor extends is provided, processors MUST raise an object structure error. If both name and extends are provided, processors MUST raise an object structure error.

The referenceType property is required unless the extends property references an existing reference object. If neither referenceType nor extends is provided, processors MUST raise an object structure error. If both referenceType and extends are provided, processors MUST raise an object structure error.

The forObjects property is required if the extends property is defined and the properties property is not defined. If neither forObjects nor properties is provided when extends is defined, processors MUST raise an object structure error.

The properties property is required if the extends property is defined and the forObjects property is not defined, processors MUST raise an object structure error.

The language property cannot be defined if the extends property is defined, processors MUST raise an object structure error.

The extends property of a reference object MUST reference the QName of an existing reference object. If the QName does not resolve to a reference object, processors MUST raise an error (oimte:invalidObjectType).

If the extends property is used the language property MUST NOT be defined. (oimte:invalidJSONStructureInvalidPropertyDefined)

A reference MUST NOT be defined for an object that is not allowed by its referenceType (oimte:disallowedObjectReferenceType).

The reference object MUST include all properties defined by the requiredProperties property of the reference type object in the properties array (oimte:missingRequiredProperty).

The language property of the reference must be a valid BCP 47 language code (oimte:invalidLanguage).

6 Object extension

Certain object types support extension, meaning that they can be modified by another model object.

An extensible object is an object of an object type that supports extensibility via the extends property. The following object types are extensible:

• domain network objects
• cube objects
• reference objects
• fact objects
• table template objects
• network objects
• member objects

A base object is an extensible object that has been defined with a name property or has had all extends properties resolved.

An extending object is an extensible object that has an extends property.

The term extends refers to the relationship between an extending object and the base object that it references using the extends property.

An extending object expands a base object by contributing additional relationships, set components or properties to the base object. An extensible object with isExtensible: false, cannot be extended. The content of the extending object is merged into the base object during compilation, resulting in a single combined definition that includes all contributions from both the base and extending objects. An XBRL module may define multiple extending objects referencing the same base object, and their contributions are all merged. A compiled model does not contain any extends properties, as all extending objects are resolved during the compilation process.

6.1 Extensible object constraints

The following constraints apply to extensible objects:

The base object referenced by the extends property of an extending object MUST NOT have a value of false for its isExtensible property (oimte:illegalExtensionOfNonExtensibleObject).

7 Built-in models

A built-in model is an XBRL model defined by this specification.

The built-in models are:

• xbrl:core - the core model (see Appendix E)
• xbrlr:dataTypes — the built-in datatypes model (see Section 11.1.2).
• xs:XMLSchemaTypes — the built-in XML schema types model.
• utr:units — the built-in units model.
• xbrltt:transforms — the built-in transforms model.
• ref:referenceProperties — the built-in reference properties model.
• iso4217:currencyUnits — the built-in ISO 4217 currency units model.
• xbrla:accounting - the built-in accounting properties model.
• xbrlm:base - the built-in model that collates the core XBRL data models.

The built-in models MAY be imported into other models using the import taxonomy object, but MUST NOT be included in an import mapping object (see Section 4.2.3).

8 Structural Report Elements

8.1 Entity object

The entity object defines entities in the taxonomy that represent a legal or reporting entity. Entities are defined using an SQName that includes the scheme and the identifier.

The entity object has an object type QName of xbrl:entityObject.

Entity objects can restrict the fact values of a cube or to indicate relationships between entities in a network object.

To include facts with entities, not defined as entity objects, in a cube the xbrl:entity cube dimension object must not have a domainNetwork property defined.

Entities defined in an OIM report with the same SQName as entities defined in the taxonomy, are considered to be the same entity.

Entities are defined as an entity object. Entities cannot be defined as members.

8.1.1 Entity object properties

The entity object has the following properties:

name (xbrl:SQName / string)

(required) The SQName that identifies the entity.

properties (non-empty set of xbrl:propertyObject objects / array)

(optional) A set of property objects that specifies model-defined properties associated with the entity object.

{
    "name": "exp:ExampleCorp"
}

8.1.2 Entity object constraints

The entity object MUST NOT be included in any domain network object relationship that does not have a domain root of xbrl:entityDomain. (oimte:invalidFactDimensionMember)

8.2 Unit object

The unit object defines units in the taxonomy that represent a unit of measure. Unit objects can be used on the unit dimension as part of the unit domain xbrl:unitDomain or dimension members on the unit dimension xbrl:unit of fact objects.

The unit object has an object type QName of xbrl:unitObject.

Information about the unit such as the description, the label, the symbol and the measurement standard is defined using labels or references.

The unit definition defines a composite unit definition that supports comparing units defined as a QName and units defined using a unit string representation. A fact with a unit dimension using a unit string representation resolves to the corresponding unit object defined in the taxonomy.

8.2.1 Unit object properties

The unit object has the following properties:

name (xs:QName / string)

(required) The unit QName that identifies the unit so it can be referenced by other objects.

dataType (xbrl:dataTypeObject reference / string)

(required) Specifies the datatype of the value. The value MUST be a QName referencing (oimte:invalidQNameReference):

• a built-in XML Schema simple type as defined in XML Schema datatypes;
• a datatype defined in this specification; (See Appendix E - Built-in Datatypes); or
• a custom datatype defined in the taxonomy model using the datatype object.

The QName MUST resolve to a datatype object present in the taxonomy model, or to a built-in XML Schema datatype. (see Section 11.1)

compositeUnitRepresentation (non-empty set of xs:string / array)

(optional) A set of unit string representations that are equivalent to the defined unit. Multiple unit string representations can be defined for a defined unit. For example cubic feet could be represented as two composite unit representations of utr:ft*utr:ft*utr:ft and utr:ft*utr:sqft.

{
    "unitObjects": [
        {
            "name": "exp:cubicFoot",
            "dataType": "xbrlr:decimal",
            "compositeUnitRepresentation": [
                "utr:ft*utr:ft*utr:ft",
                "utr:ft*utr:sqft"
            ]
        },
        {
            "name": "exp:kilometresPerHour",
            "dataType": "xbrlr:decimal",
            "compositeUnitRepresentation": [
                "utr:km/utr:h"
            ]
        }
    ]
}

8.2.2 Unit object constraints

A unit object MUST have a dataType property that references a datatype that is a numeric datatype (oimte:invalidUnitDataType)

The unit object compositeUnitRepresentation MUST NOT reference the unit defined in the name property of the same unit object. (oimte:unitDataTypeUsedInDefinition)

{
    "name": "exp:USD",
    "dataType": "xbrlr:monetary",
    "compositeUnitRepresentation": ["exp:USD"]
}

The unit object compositeUnitRepresentation MUST resolve each unit string representation to valid unit object QNames (oimce:invalidUnitStringRepresentation) as defined in Open Information Model Common Definitions 1.0

8.3 Fact object

The fact object is an extensible object that defines a fact. A fact represents the value associated with the intersection of dimensions in a multidimensional space. A fact object can exist without a value, or a reference to a value, but represents the definition of the fact and its associated dimensions. The dimensions include core dimensions and taxonomy defined dimensions. A fact object can be referenced by labels, references, and relationships. Properties can be added to facts using the property object.

The fact object has an object type QName of xbrl:factObject.

A fact's datatype is the datatype of the concept object identified by the fact's xbrl:concept dimension.

A fact's base datatype is the XML Schema primitive type from which the fact's datatype is derived.

A fact is nillable if the concept object identified by the fact's xbrl:concept dimension has a value of true for the nillable property.

A numeric fact is a fact object with a datatype that is derived from the XML Schema types of xs:decimal, xs:double or xs:float.

A non-numeric fact is any fact object that is not a numeric fact.

A text fact is a fact object with a datatype that is derived from the XML Schema type of xs:string, but which is not one of, or a type derived from one of, the following types:

• xs:language
• xs:Name
• xbrlr:noLangToken
• xbrlr:noLangString

A non-text fact is any fact object that is not a text fact.

The text fact definition identifies those fact objects to which the xbrl:language dimension is applicable.

A fact's period type is the value of the periodType attribute of the concept object identified by the fact's concept dimension, and is either duration, instant or none.

8.3.1 Fact object properties

The fact object has the following properties:

name (xbrl:SQName / string)

(optional) The fact SQName that identifies the fact so it can be referenced by other objects. It is an SQName that allows the local name to start with a number.

• base object : (required)
• extending object : (prohibited)

factValues (non-empty set of xbrl:factValueObject objects / array)

(optional) A set of fact value objects that identify the values of the fact object.

• base object : (optional)
• extending object : (optional)

factDimensions (xbrl:factDimensionObject / object)

(optional) A fact dimensions object representing a set of dimension objects and associated values representing members of that dimension objects domain class object.

• base object : (required)
• extending object : (prohibited)

factQualifier (xbrl:factQualifierObject / object)

(optional) A fact qualifier object, that indicates additional dimensional members that are valid for the fact.

• base object : (optional)
• extending object : (optional)

properties (non-empty set of xbrl:propertyObject objects / array)

(optional) A set of property objects that specifies model-defined properties associated with the fact object.

• base object : (optional)
• extending object : (optional)

extends (xbrl:factObject reference / string)

(optional) References the fact object that the defined fact properties should be appended to. The items in the fact with this property are appended to the end of the properties defined in the target fact object. This property cannot be used in conjunction with the name and factDimensions properties. The ability to extend a fact can be used to add factValues and properties to an existing fact. The SQName MUST resolve to an existing fact object; if the SQName resolves to an object of a different type, processors MUST raise an error (oimte:invalidObjectType).

• base object : (prohibited)
• extending object : (required)

isExtensible (xs:boolean / boolean)

(optional) If set to false, the fact is non-extensible and no importing model may augment it using extends. If set to true or omitted, the fact may be extended. The default value is true.

• base object : (optional)
• extending object : (optional)

{
    "name": "exp:RevenueAnnual2024",
    "factDimensions": {
        "xbrl:concept": "exp:Revenue",
        "xbrl:period": "2024-01-01/2024-12-31",
        "xbrl:entity": "exp:ExampleCorp",
        "xbrl:unit": "iso4217:GBP"
    },
    "factValues": [
        { "value": "1500000", "decimals": -3 }
    ]
}

8.4 Fact values object

The fact value object defines the value of a fact object. A fact can have multiple fact values. Each fact value is defined using the value property. This object has the QName of xbrl:factValueObject.

8.4.1 Fact value object properties

The fact value object has the following properties:

name (xbrl:SQName / string)

(required) The fact SQName that identifies the fact value so it can be referenced by other objects.

value (xs:anyType / any)

(optional) The value of the fact. This can be a numeric value, a string, or any other type of value that is valid for the fact.

decimals (xs:integer / number)

(optional) An integer providing the value of the decimals property, or absent if the value is infinitely precise or not applicable (for nil or non-numeric facts)

language (xs:language / string)

(optional) The language of the fact value, specified using the BCP 47 standard language code (e.g., "en" for English, "fr" for French).

reportSource (xbrl:factSourceObject reference/ string)

(optional) identifies the fact source object reference of the fact value. If no reportSource property is provided the document file encapsulating the model object is implied as the fact source. If no reportSource property is provided and the model is external to the source file then the fact source mapping object in the sourceMappings array of the document info object determines the location of the value.

transformation (xbrl:transformObject reference / string)

(optional) A transform object reference that defines the transformation to perform on the fact value. If no transformation is provided the value is used as it appears in the source document. The transformation property MUST NOT be defined if value is defined. If both the transformation property and value property are defined, the processor MUST raise an object structure error.

scale (xs:integer / number)

(optional) identifies a power of 10 to multiply source text number (such as when in billions) in the source document. The scale property MUST NOT be defined if the property value is defined. If a scale property and value property is defined the processors MUST raise an object structure error. If a value property is not defined and the scale property is not defined the value of scale defaults to zero.

sign ( xs:string / string)

(optional) identifies if the resulting numerical value is negative. Value must be "-" or not reported. The sign property MUST NOT be defined if value is defined.

escape ( xs:boolean / boolean)

(optional) If the escape attribute is true then value is the escaped representation for media with markup, e.g. html or pdf, otherwise the concatenation in document order of all descendant text content. If no value is provided the attribute defaults to false.

valueSources (non-empty ordered set of xbrl:factValueSourceObject objects / array)

(optional) An ordered set of fact value source objects that identify where the values are obtained from content of an embedding or accompanying document source. At least one of value or valueSources MUST be defined.

valueAnchors (non-empty ordered set of xbrl:factValueAnchorObject objects / array)

(optional) An ordered set of fact value anchor objects that identify corresponding content of an embedding document file (html, pdf or tabular) for cases where the value is provided in the value property instead of obtained from the content of the document file. For example, non-transformable values, such as a QName value, may correspond to prose text in the document file. Used by tools to highlight and detect mouse-over correspondence between fact values and document text. If both the valueSources and valueAnchors properties are provided, processors MUST raise an object structure error.

"sourceMappings": [
            {
                "sourceName": "aapl:aapl-20250927Source",
                "url": ""
            }
        ]

"sourceMappings": [
            {
                "sourceName": "aapl:aapl-20250927Source",
                "url": "../examples/aapl-20250927.htm"
            }
        ]

"factSources": [
            {
                "name": "exp:aapl-20250927Source",
                "factMapName": "exp:htmlElementFactMap"
            }
        ],
"factMaps": [
            {
                "name": "exp:htmlElementFactMap",
                "factLocatorType": "xbrl:htmlElementLocatorType"
            }
        ],

{
    "name": "aapl:fs_f-9",
    "factDimensions": {...},
    "factValues": [
        {
            "name": "aapl:f-9_val",
            "valueSources": [
                {"properties": [{"property": "xbrl:htmlElementId", "value": [ "f-9"]}]}
            ]
        }
    ]
}

{
    "name": "aapl:fs_f-9",
    "factDimensions": {...},
    "factValues": [
        {
            "name": "aapl:f-9_val",
            "reportSource": "aapl:aapl-20250927Source",
            "valueSources": [
                {"properties": [{"property": "xbrl:htmlElementId", "value": [ "f-9"]}]}
            ]
        }
    ]
}

8.4.2 Fact value object constraints

The fact value objects property value MUST be provided if the property valueSources is not provided. Processors must raise an object structure error.

If the value property is provided, it MUST be valid according to the datatype of the concept associated with the fact (oimte:factValueDataTypeMismatch).

If a value is provided for valueSources or valueAnchors then a value MUST be provided for factLocatorType as a property of the factMap associated with the factSource referenced in the sourceMappings of the document info object (oimte:factValueLocatorRequiredForValueSources).

8.5 Fact dimension object

The factDimensions object represents the dimensions associated with a fact. Each property of the object corresponds to a dimension. For core dimensions, the name of the property is either xbrl:concept, xbrl:period, xbrl:unit, or xbrl:entity. For taxonomy defined dimensions the property name is a dimension object QName. The object has a QName of xbrl:factDimensionObject.

8.5.1 Fact dimension object properties

The factDimensions object is a set of name/value pairs:

Any dimension QName (xbrl:dimensionObject reference / string)

(optional) Any dimensions on the fact are included as properties with a name corresponding to the {name} property of the dimension, expressed as a QName. The value is the {value} property of the dimension expressed either as a QName representing a xbrl:concept, an xbrl:period, an xbrl:unit, an xbrl:entity SQName, or a value conforming to the datatype of the dimension. (see Section 5.7)

A cube that defines a unit dimension with optional set to false will not include facts with unit values of xbrlr:pure, or numeric values with no unit.

{
    "xbrl:concept": "exp:Revenue",
    "xbrl:period": "2024-01-01/2024-12-31",
    "xbrl:entity": "exp:ExampleCorp",
    "xbrl:unit": "iso4217:GBP",
    "exp:SegmentDimension": "exp:NorthAmerica"
}

8.5.2 Fact dimension object constraints

8.5.2.1 Concept dimension

The factDimensions object MUST include a key value of xbrl:concept (oime:missingConceptDimension).

The xbrl:concept dimension MUST have a value that is a QName referencing a concept object defined in the model (oimte:invalidObjectType).

8.5.2.2 Period dimension

The xbrl:period is a time interval as defined in ISO 8601. The time interval MAY be zero-length (i.e. start and end at the same instant), denoting an instant in time. The time interval MAY be defined in local time (i.e. without a time zone designator) in which case processors MUST NOT assume a particular time zone, but MUST preserve the information that the time interval is in local time.

The factDimensions object MUST include a name of xbrl:period if the fact's period type is duration or instant (oime:missingPeriodDimension)

If a fact's period type is duration then the xbrl:period value MUST be a non-zero length time interval (oime:invalidPeriodDimension).

If a fact's period type is instant then the xbrl:period value MUST be a zero length time interval (oime:invalidPeriodDimension).

If a fact's period type is duration then the xbrl:period value MUST NOT have an end date that is before the start date. (oime:invalidPeriodDimension)

If a fact's period type is none then the xbrl:period MUST NOT be defined. (oime:invalidPeriodDimension)

Fact values without the period dimension defined MUST have use a concept object with a periodType value of none (oime:invalidPeriodDimension).

8.5.2.3 Unit dimension

The factDimensions object MUST include a name of xbrl:unit if the fact's datatype has a defined unit (see section Section 8.10.1 (oimte:factMissingUnitDimension)

The xbrl:unit dimension MUST NOT be present on a non-numeric facts (oime:misplacedUnitDimension).

• The datatype definition defines that the datatype is allowed on a unit object.

A unit of xbrlr:pure which is the domain value of xbrl:unit is equivalent to no unit.

If a xbrl:concept has a numeric datatype and no xbrl:unit is defined the unit dimension is treated as having a unit of xbrlr:pure.

Datatypes defined in the xs namespace MUST NOT be used as the datatype of a unit (oimte:invalidUnitDataType).

8.5.2.4 Model defined dimensions

A fact's dimension member MUST NOT be the domain class object for that dimension (oimte:invalidFactDimensionMember).

A taxonomy defined dimension value of a fact object MUST match the taxonomy defined dimensions domainClass with at least one of the domainClasses of the member object (for explicit dimensions) or MUST conform to the taxonomy defined dimensions datatype (for typed dimensions) (oimte:invalidFactDimensionMember). The match must include inferred domain classes of the member object that are inherited using the base domain class object see Section 5.6.3.

8.5.2.5 All dimensions

The set of dimensions defined for a fact MUST match the dimensions of at least one or more positive cubes (cubes that are not a negative cube) defined in the model (oimte:noFactSpaceForFact).

Facts whose dimensions match only an exclude cube MUST raise the error (oimte:noFactSpaceForFact).

The error oimte:noFactSpaceForFact is raised for a fact defined in a cube if an exclude cube also includes that fact. An exclude cube applied to a positive cube can thus make a fact invalid in the model.

8.6 Fact qualifier object

The factQualifier object represents the dimension properties associated with a fact that do not represent dimensions comprising a cube space for the fact. Each property of the object corresponds to a taxonomy defined dimension. The dimension properties of a fact qualifier cannot define core properties of xbrl:concept, xbrl:period, xbrl:unit, or xbrl:entity. This object can only define taxonomy defined dimensions where the property name is a dimension object QName. The object has a QName of xbrl:factQualifierObject.

8.6.1 Fact qualifier object properties

The factQualifier object is a set of name value pairs:

Any dimension QName (xbrl:dimensionObject reference / string)

(optional) Any dimensions on the fact are included as properties with a name corresponding to the {name} property of the dimension, expressed as a QName. The value is the {value} property of the dimension expressed either as a QName or a typed value for typed dimensions. (see Section 5.7)

8.6.2 Fact qualifier object constraint

A fact qualifier's dimension property member MUST NOT be the domain class object for that dimension. (oimte:invalidFactDimensionMember)

The dimension property member of a fact MUST be part of the dimension's domain (for explicit dimensions) or must conform to the dimension's datatype (for typed dimensions)(oimte:invalidFactDimensionMember).

A named pair in a fact qualifier object MUST NOT be defined as a pair in the fact dimension object for that fact (oimte:invalidFactQualifierDimensionMember).

The set of dimensions defined for a fact qualifier object does not need to be expressed in a cube, but if the combination of pairs in both the fact dimension object and fact qualifier object exist in a cube, then a fact value for a fact matching the combination of pairs MUST be the same (oimte:factInconsistentWithFactQualifier).

 "facts": [
            {
                "name": "exp:RevenueForWidgetSalesInUSFact",
                "factDimensions": {
                    "xbrl:concept": "exp:Revenue",
                    "xbrl:period": "2025-01-01T00:00:00/2026-01-01T00:00:00",
                    "xbrl:entity": "exp:Company1",
                    "xbrl:unit1": "iso4217:USD"
                },
                "factValues": [
                    {
                        "name": "exp:fv1",
                        "value": "500000"
                    }
                ],
                "factQualifiers": {
                    "exp:RegionSoldAxis": "exp:US",
                    "exp:ProductAxis": "exp:Widget",
                    "exp:RegionManufacturedAxis":"exp:CN"
                }
            }
 ]

8.7 Fact value source object

The fact value source object represents the source(s) of a fact value from an information store. The Fact value source object is used when the value of a fact is not directly provided in the value property of a fact value object, but instead is obtained by extracting and transforming content from an embedding or accompanying information source (html, pdf, XLSX etc). The fact value source object identifies the source of the content in the information store and any transformations that need to be applied to the extracted content to obtain the fact value.

The fact value source object has an object type QName of xbrl:factValueSourceObject.

8.7.1 Fact value source object properties

Each fact value source object in the valueSources property array may identify source text in an information store. The properties of a fact value source object depend on the storage format. (e.g. html, pdf, spreadsheet).

There may be multiple fact value source objects in any valueSources array, to identify multiple regions of source text in the information store, such as text split among paragraphs, pages, cells, form fields, etc. They aggregate by concatenation when present.

properties (non-empty set of xbrl:propertyObject objects / array)

(required) A set of property objects that specifies the interface properties defined by the locatorType for the fact source.

"valueSources": [
    {
        "properties": [
            {
                "property": "xbrl:htmlElementId",
                "value": ["f-73"]
            }
        ]
    }
],

8.8 Fact value anchor object

The fact value anchor object specifies the source(s) of a fact value from a document file's content for the purpose of tool visual actions. The fact value anchor object is used when the value of a fact is provided in the value property of a fact value object, but there is a need to identify corresponding content in an embedding document format (such as html, pdf, tabular etc.) for purposes of highlighting text or discovering mouse-over to corresponding fact values. The object name is xbrl:factValueAnchorObject.

The fact value anchor object has an object type QName of xbrl:factValueAnchorObject.

8.8.1 Fact value anchor object properties

Each fact value anchor object in the valueAnchors property array may identify source text in a document file. The properties of a fact value anchor object depend on the document file media (e.g. html, pdf, XLSX, ODS, Google Sheets etc.).

This property may be used by tools which highlight text in a document file corresponding to a fact, and may be used for mouse-over behavior to identify fact values which correspond to document file contents.

There may be multiple fact value anchor objects in any valueAnchors array, to identify multiple regions of source text in the document file, such as text split among paragraphs, pages, cells, form fields, etc. They identify non-contiguous text for purposes of highlighting text or discovering mouse-over to corresponding fact value objects.

properties (non-empty set of xbrl:propertyObject objects / array)

(required) A set of property objects used to specify the interface properties defined by the locatorType for the fact anchor.

8.9 File reference resolution

When a fact value source object or fact value anchor object is defined a fact source object MUST be defined. The following steps describe how a processor MUST determine the source document from model properties:

• If a reportSource property (QName) is specified in the fact value object, that QName is used to look up the corresponding QName in the sourceMappings array of the document info object.

• If no reportSource property is specified:

  • If the sourceMappings array contains exactly one entry, that entry's url is used as the source object.
  • If the sourceMappings array contains more than one entry, an error MUST be raised (oimte:factSourceResolutionFailed), as the processor cannot distinguish the relevant file.
  • If no sourceMappings is defined and no reportSource is specified, the report file encapsulating the XBRL module is used as the source.

If the processor fails to resolve a source document the processor MUST raise an error (oimte:factSourceResolutionFailed).

8.10 Fact validation

8.10.1 Fact unit validation

8.10.2 Duplicate fact validation

The model defines if duplicate facts are permitted. The validity of duplicate facts can be defined at the xbrl model object level or the cube object level. The xbrl model object property duplicateFactsInModel indicates if the model validates duplicate facts. A string value of no duplicates, <<oim:complete duplicates>>, <<oim:consistent duplicates>>, or <<oim:inconsistent duplicates>> defines the duplicates permitted. If no string value is provided the default value is inconsistent duplicates. The value of duplicateFactsInModel sets the default value of the cube object property duplicateFactsInCube. The allowable values for duplicateFactsInCube is the same as the allowable values for duplicateFactsInModel. The value of duplicateFactsInCube has precedence over the duplicateFactsInModel value of the xbrl model object.

The cube object defines if duplicate facts are valid or invalid for facts in that cube. If a cube does not specify a value for the property duplicateFactsInCube then the default value is taken from the duplicateFactsInModel property of the xbrl model object.

If duplicate facts exist in a model they must match the dimension values of at least one cube in the model that allows duplicate facts. If duplicate facts do not match at least one cube in the model that allows duplicate facts then the fact MUST be identified as invalid.(oime:disallowedDuplicateFacts)

8.11 Footnote object

The footnote object defines footnotes that can be associated with facts in a report. Footnotes provide additional context or information about the fact objects they are associated with.

The footnote object has an object type QName of xbrl:footnoteObject.

Relationships between facts are expressed using relationship objects between two facts. (see Section 11.4)

8.11.1 Footnote object properties

name (xs:SQName / string)

(required) The footnote object SQName that identifies the footnote so it can be referenced by other objects.

forObjects (non-empty set of xbrl:factObject references / array)

(required) A set of fact object QNames that are included in the footnote object. The set cannot be empty. The forObjects property allows a footnote to be associated with one or more facts. A fact can be associated with multiple footnotes by including its QName in multiple forObjects sets across different footnote objects.

content (xs:string / string)

(required) The content of the footnote.

language (xs:language / string)

(optional) The language of the footnote text, specified using the BCP 47 standard language code (e.g., "en" for English, "fr" for French). If this property is not defined, processors MAY inherit the language from the xbrl:defaultLanguage property of the enclosing XBRL model object, if that property is defined.

annotationType (xs:QName / string)

(optional) A string that indicates the type of footnote, such as "footnote", "endNote", "sideNote", etc. This property is intended for informational and rendering purposes and does not affect the validity of the footnote or its association with facts. The specific values and semantics of the annotationType property are not defined by the OIM specification and are left to tool implementations and user conventions.

{
    "name": "exp:RevenueNote1",
    "forObjects": ["exp:RevenueAnnual2024"],
    "language": "en",
    "content": "Revenue is recognised at the point of transfer of control of goods or services to the customer.",
    "annotationType": "xbrl:footnote"
}

9 Fact source elements

Facts can be defined in the model as an individual fact object or as a collection of facts called a fact source object. The model allows facts to be defined as either object. A fact object can be derived from a fact source and a fact source can be expressed as a collection of facts. The fact source object defines a collection of facts that are derived from a common data source, such as a CSV file, an Excel sheet, a JSON file, an XML file, or an XBRL instance. The fact source object references a fact map object that defines the structure and template for representing the data as fact objects. The fact source object also references the specific data source from which the facts are derived. This allows for efficient representation of large sets of facts without having to define each fact individually in the model.

9.1 Fact source object

A fact source object is a binding between a fact map object (which defines the structure and template to represent data as fact objects) and a specific data source from which the data representing fact objects is defined. A single fact map object can be reused across multiple fact source objects that reference different data sources.

The fact source object has an object type QName of xbrl:factSourceObject.

9.1.1 Fact source object properties

name (xs:QName / string)

(required) The name is a QName that uniquely identifies the fact source object.

factMapName (xbrl:factMapQName reference / string)

(required) The fact map name is a QName that references a fact map object defined in the taxonomy model (see Section 9.3)

cubeName (xbrl:cubeQName / string)

(optional) The cubeName is a QName that references a cube object. When provided, only facts that fall within the dimensional space of the cube are included in the result; facts with no dimensional membership in the cube are excluded. Constraints defined on the cube are applied to the generated facts. When omitted, facts are generated for the entire model without cube filtering. Multiple fact source objects can reference the same factMapName with different cubeName values, allowing the same template to define fact objects from the same data file, based on a different referenced cube. Multiple fact source objects can also reference the same cube, allowing facts from different data files to define different facts that are included in a single cube. The cube definition can be used to control how facts are validated based on the native format.

namespaceMaps (non-empty set of xbrl:namespaceMapObject / object)

(optional) A set of namespaceMap objects that maps the namespace of the model defined in a datasource to the namespace of an updated model. The namespaceMaps property is used for namespace migration: when importing facts from an older XBRL report where concepts used a different namespace (e.g., old:Revenue) into a model where those concepts have been updated to a new namespace (e.g., new:Revenue), the namespaceMaps entry tells the processor how to translate the old namespace to the new one during fact loading (see Section 9.2).

factIdentifierNamespacePrefix (xs:NCName / string)

(optional) The factIdentifierNamespacePrefix is the namespace prefix assigned to the fact objects defined in the fact source object. The factIdentifierNamespacePrefix defines the prefix of the fact object QName and fact value object QName generated from the fact source object. If the factIdentifierNamespacePrefix is not defined, the processor MUST use the namespace prefix of the model for the fact object and fact value object QName. This property is used when multiple fact sources are used to prevent fact QName duplicates. If the prefix is not defined in the document namespace object, the error oimce:unboundPrefix is raised.

properties (non-empty set of xbrl:propertyObject objects / array)

(optional) A set of property objects that specifies model-defined properties associated with the fact source object.

{
    "name": "exp:AnnualReport2024Facts",
    "factMapName": "xbrl:csvFactMap",
    "properties": [
        { "property": "exp:documentTitle", "value": "Annual Report 2024" }
    ]
}

9.1.2 Fact source object constraints

The namespace prefix defined for factIdentifierNamespacePrefix MUST be defined in the document namespace object (oimce:unboundPrefix).

9.2 Namespace map object

The namespaceMap object defines a redirection from one namespace to another namespace. This maps the namespaces of a data source to the namespaces defined in the taxonomy model.

The namespaceMap object has an object type QName of xbrl:namespaceMapObject.

9.2.1 Namespace map object properties

fromNamespacePrefix (xs:NCName / string)

(optional) The fromNamespacePrefix property is the original namespace prefix that is being redirected.

toNamespacePrefix (xs:NCName / string)

(required) The toNamespacePrefix property is the new namespace prefix that the fromNamespacePrefix is being redirected to. If no fromNamespacePrefix is specified, the toNamespacePrefix is used as the namespace for the fact source object irrespective of the namespace in the source.

{
    "fromNamespacePrefix": "expOld",
    "toNamespacePrefix": "expCurrent"
}

9.2.1.1 Namespace map object constraints

The namespace prefixes defined for fromNamespacePrefix and toNamespacePrefix MUST be defined in the document namespace object. (oimce:unboundPrefix)

The data source MUST be defined in an XBRL format.

9.3 Fact Map object

The fact map object defines the mapping between data available in underlying data format and how that format can be translated to fact objects. Maps can be defined for different data formats such as CSV, JSON, XML or other formats. The fact map object defines the mapping for a specific data format.

The fact map object has an object type QName of xbrl:factMapObject.

The result of applying a fact map to a fact source object in the specified format results in a set of fact objects.

This specification defines two built-in fact maps that processors MUST support without any explicit factMap definition in the taxonomy model:

• xbrl:xBRL-XML — maps facts and footnotes from an XBRL 2.1 XML instance document to fact objects and footnote objects. See xBRL-XML fact map.
• xbrl:xBRL-JSON — maps facts from an xBRL-JSON document to fact objects. See xBRL-JSON fact map.

Processors MAY support the following built-in fact map without explicit factMap definition in the taxonomy model:

• xbrl:inline-XBRL-1.1 — maps facts from an [Inline XBRL 1.1] document to fact objects including fact value source object properties for the source document. See Inline XBRL 1.1 fact map.

Model authors may define additional fact map objects for custom data formats using the templateName property to reference a table template object, jsonTemplateMap object, or xmlTemplateMap object.

A fact map object is a supplementary derivation mechanism for facts sourced from external documents. A fact map object is used when fact values are extracted from an external data source (CSV, XML, JSON) using the structure of the data source to determine the mapping. A taxonomy/report that provides all its facts as fact objects has no need for a fact map object.

9.3.1 Fact map object properties

name (xs:QName / string)

(required) The name is a QName that uniquely identifies the fact map object.

templateName (xs:QName / string)

(optional) The templateName is a QName that references a table template object, a JSON template map object or an XML template map object defined in the taxonomy model. The type of template object referenced by the templateName property determines the data format of the fact map. (see Section 9.4, Section 9.5 and Section 9.6)

factLocatorType (xbrl:factLocatorTypeObject reference / string)

(optional) A QName identifying the fact locator type object that provides the default locatorType for all fact value objects that reference this fact map via a fact source object. When present on the factMap entry, it overrides the need to specify locatorType on each individual factValue.

9.3.2 Built-in fact map objects

The specification defines specification-defined fact maps where the format of the XBRL facts is known. This includes XBRL facts defined using the XBRL 2.1 specification and facts defined using the xBRL-JSON specification. (see Section 16)

 "factSources": [
    {
        "name": "ext:getInstance",
        "factMapName": "xbrl:xBRL-XML"
    }
],