Corrigendum

The following problems with the specification dated April 2011 have been rectified as described below.

1. Problem

Various parts of the the documentation refer to stand-alone concepts, which were part of earlier draft releases but ultimately excluded from the final release of the standard.

Rectification

The documentation has been updated to remove this reference. This documentation includes:

• Concepts entry for Element Documentation of StructuresType (table beginning line 226).
• ConceptsType (line 270).

1. Problem

The ComponentMap element in the complex type StructureMapType has a maximum occurrence of 1. Therefore, it is not possible to completely map all components of a structure.

Rectification

The documentation of the StructureMapType has been updated to reflect that maximum occurrence of "unbounded" (line 2508).

1 Introduction

The structure namespace contains the definition of all structural metadata constructs. These constructs are intended to be very tightly coupled with the information model to ease the burden of implementers on translating the information from the XML messages into objects based on the information model.

The conformance with the information was achieved through derivation by extensions, restrictions, and substitutions. Because of some the limitations of XML Schema in these areas, it was often necessary to create intermediate type which frmed the basis of the final types which make up the information that is actually exchanged in SDMX messages. The intermediate types are all abstract, so they are not explicitly used in a message. They do however serve the purpose of creating a strong relation of the schemas to the information model.

2 Schema Documentation

2.1 Structure Namespace

http://www.sdmx.org/resources/sdmxml/schemas/v2_1/structure

2.1.1 Summary

Referenced Namespaces:

Contents:
47 Global Elements
199 Complex Types
10 Simple Types

2.1.2 Global Elements

Structures (StructuresType): Structures contains constructs for all structural metadata components.

Item (ItemType): Item is an abstract element that serves as a substitution head for all items in an item scheme, including those items nested within other items. Concrete instances of this must use a concrete instance of ItemType.

Substitutions: Category, Code, Concept, Organisation, Agency, DataConsumer, DataProvider, OrganisationUnit, ReportingCategory, Transformation, VtlMapping, NamePersonalisation, Ruleset, UserDefinedOperator, CustomType

Grouping (GroupingType): Grouping is an abstract element that serves as a substitution head for all structure groupings. Groupings contain a collection of component lists for a structure. Concrete instances of this must use a concrete instance of GroupingType.

Substitutions: DataStructureComponents, MetadataStructureComponents

ComponentList (ComponentListType): ComponentList is an abstract element that serves as a substitution head for all component lists. Concrete instances of this must use a concrete instance of ComponentListType.

Substitutions: AttributeList, DimensionList, Group, MeasureList, MetadataTarget, ReportStructure

Component (ComponentType): Component is an abstract element that serves as a substitution head for all components. Concrete instances of this must use a concrete instance of ComponentType.

Substitutions: Attribute, ReportingYearStartDay, Dimension, TimeDimension, MeasureDimension, GroupDimension, PrimaryMeasure, KeyDescriptorValuesTarget, DataSetTarget, ConstraintContentTarget, ReportPeriodTarget, IdentifiableObjectTarget, MetadataAttribute

Category (CategoryType): Category represents a set of nested categories which describe a simple classification hierarchy.

Substitution For: Item

Code (CodeType): Code describes a code in a codelist. In addition to the identification and description of the code, basic presentational information is also available. Presentational information not present may be added through the use of annotations.

Substitution For: Item

Concept (ConceptType): Concept describes the details of a concept within a concept scheme.

Substitution For: Item

DataStructureComponents (DataStructureComponentsType): DataStructureComponents defines the grouping of the sets of metadata concepts that have a defined structural role in the data structure definition. Note that for any component or group defined in a data structure definition, its id must be unique. This applies to the identifiers explicitly defined by the components as well as those inherited from the concept identity of a component. For example, if two dimensions take their identity from concepts with same identity (regardless of whether the concepts exist in different schemes) one of the dimensions must be provided a different explicit identifier. Although there are XML schema constraints to help enforce this, these only apply to explicitly assigned identifiers. Identifiers inherited from a concept from which a component takes its identity cannot be validated against this constraint. Therefore, systems processing data structure definitions will have to perform this check outside of the XML validation. There are also three reserved identifiers in a data structure definition; OBS_VALUE, TIME_PERIOD, and REPORTING_PERIOD_START_DAY. These identifiers may not be used outside of their respective defintions (PrimaryMeasure, TimeDimension, and ReportingYearStartDay). This applies to both the explicit identifiers that can be assigned to the components or groups as well as an identifier inherited by a component from its concept identity. For example, if an ordinary dimension (i.e. not the time dimension) takes its concept identity from a concept with the identifier TIME_PERIOD, that dimension must provide a different explicit identifier.

Substitution For: Grouping

AttributeList (AttributeListType): AttributeList describes the attribute descriptor for the data structure definition. It is a collection of metadata concepts that define the attributes of the data structure definition.

Substitution For: ComponentList

Attribute (AttributeType): Attribute describes the definition of a data attribute, which is defined as a characteristic of an object or entity.

Substitution For: Component

ReportingYearStartDay (ReportingYearStartDayType): ReportingYearStartDay is a specialized data attribute which provides important context to the time dimension. If the value of the time dimension is one of the standard reporting periods (see common:ReportingTimePeriodType) then this attribute is used to state the month and day that the reporting year begins. This provides a reference point from which the actual calendar dates covered by these periods can be determined. If this attribute does not occur in a data set, then the reporting year start day will be assumed to be January 1.

Substitution For: Component

DimensionList (DimensionListType): DimensionList describes the key descriptor for the data structure definition. It is an ordered set of metadata concepts that, combined, classify a statistical series, such as a time series, and whose values, when combined (the key) in an instance such as a data set, uniquely identify a specific series.

Substitution For: ComponentList

Dimension (DimensionType): Dimension describes the structure of a dimension, which is defined as a statistical concept used (most probably together with other statistical concepts) to identify a statistical series, such as a time series, e.g. a statistical concept indicating certain economic activity or a geographical reference area.

Substitution For: Component

TimeDimension (TimeDimensionType): TimeDimension is a special dimension which designates the period in time in which the data identified by the full series key applies.

Substitution For: Component

MeasureDimension (MeasureDimensionType): MeasureDimension is a special type of dimension which defines multiple measures in a key family. This is represented as any other dimension in a unless it is the observation dimension. It takes it representation from a concept scheme, and this scheme defines the measures and their representations. When data is formatted with this as the observation dimension, these measures can be made explicit or the value of the dimension can be treated as any other dimension. If the measures are explicit, the representation of the observation will be specific to the core representation for each concept in the representation concept scheme. Note that it is necessary that these representations are compliant (the same or derived from) with that of the primary measure.

Substitution For: Component

Group (GroupType): Group describes a group descriptor in a data structure definition. It is a set metadata concepts (and possibly their values) that define a partial key derived from the key descriptor in a data structure definition.

Substitution For: ComponentList

GroupDimension (GroupDimensionType): GroupDimension is a component which contains only a reference to a dimension in the key descriptor (DimensionList). Although it is conventional to declare dimensions in the same order as they are declared in the ordered key, there is no requirement to do so - the ordering of the values of the key are taken from the order in which the dimensions are declared. Note that the id of a dimension may be inherited from its underlying concept - therefore this reference value may actually be the id of the concept.

Substitution For: Component

MeasureList (MeasureListType): MeasureList describes the measure descriptor for a key family. It contains a single metadata concepts that define the primary measures of a data structure.

Substitution For: ComponentList

PrimaryMeasure (PrimaryMeasureType): PrimaryMeasure defines the structure of the primary measure, which is the concept that is the value of the phenomenon to be measured in a data set. Although this may take its semantic from any concept, this is provided a fixed identifier (OBS_VALUE) so that it may be easily distinguished in data messages.

Substitution For: Component

MetadataStructureComponents (MetadataStructureComponentsType): MetadataStructureComponents defines the grouping of the sets of the components that make up the metadata structure definition. All components and component list (target identifiers, identifier components, report structures, and metadata attributes) in the structure definition must have a unique identification.

Substitution For: Grouping

MetadataTarget (MetadataTargetType): MetadataTarget is a collection of target objects which when taken together describe a structure which defines the key of an object type to which metadata may be attached and serve to disambiguate reference metadata set reports.

Substitution For: ComponentList

KeyDescriptorValuesTarget (KeyDescriptorValuesTargetType): KeyDescriptorValuesTarget is target object which references a data key for the purpose of attach reference metadata to portions of data. A data key is a set of dimension references and values for those dimension. This component on its own is not of much use, as the data key only has local references to the dimensions. Therefore it is typical that this is used in combination with some sort of reference to the data (either a data set reference or a reference to the underlying structure, structure usage, or provision agreement of the data.

Substitution For: Component

DataSetTarget (DataSetTargetType): DataSetTarget is target object which references a data set for the purpose of attaching reference metadata data. A data set reference is a full reference to a data provider and an identifier for the data set.

Substitution For: Component

ConstraintContentTarget (ConstraintContentTargetType): ConstraintContentTarget is target object which references an attachment constraint for the purpose of attaching reference metadata data to data key sets or cube regions defined by the constraint.

Substitution For: Component

ReportPeriodTarget (ReportPeriodTargetType): ReportPeriodTarget is target object which specifies a reporting period to which a metadata report applies.

Substitution For: Component

IdentifiableObjectTarget (IdentifiableObjectTargetType): IdentifiableObjectTarget is target object which references an Identifiable object as defined in the SDMX Information Model. The reference must be complete (i.e. a URN or a complete set of reference fields). For an item object, it is possible to define a local representation of an item scheme from which the item must be referenced.

Substitution For: Component

ReportStructure (ReportStructureType): ReportStructure defines a report structure, which comprises a set of metadata attributes that can be defined as a hierarchy, for reporting reference metadata about a target object. The identification of metadata attributes must be unique at any given level of the report structure. Although there are XML schema constraints to help enforce this, these only apply to explicitly assigned identifiers. Identifiers inherited from a concept from which a metadata attribute takes its identity cannot be validated against this constraint. Therefore, systems processing metadata structure definitions will have to perform this check outside of the XML validation.

Substitution For: ComponentList

MetadataAttribute (MetadataAttributeType): MetadataAttribute defines the a metadata attribute, which is the value of an attribute, such as the instance of a coded or uncoded attribute in a metadata structure definition.

Substitution For: Component

Organisation (OrganisationType): Organisation is an abstract substitution head for a generic organisation.

Substitution For: Item

Substitutions: Agency, DataConsumer, DataProvider, OrganisationUnit

Agency (AgencyType): Agency is an organisation which maintains structural metadata such as statistical classifications, glossaries, key family structural definitions, and metadata structure definitions..

Substitution For: Organisation

DataConsumer (DataConsumerType): DataConsumer describes an organisation using data as input for further processing.

Substitution For: Organisation

DataProvider (DataProviderType): DataProvider describes an organisation that produces data or reference metadata.

Substitution For: Organisation

OrganisationUnit (OrganisationUnitType): OrganisationUnit describes a generic organisation, which serves not predefined role in SDMX.

Substitution For: Organisation

ReportingCategory (ReportingCategoryType): ReportingCateogry defines a reporting category, which is used to group structure usages into useful sub-packages.

Substitution For: Item

ItemAssociation (ItemAssociationType): ItemAssociation is an abstract description of the relation between two items for the purpose of mapping.

Substitutions: OrganisationMap, CategoryMap, CodeMap, ConceptMap, ReportingCategoryMap

OrganisationMap (OrganisationMapType): OrganisationMap relates a source organisation to a target organisation.

Substitution For: ItemAssociation

CategoryMap (CategoryMapType): CategoryMap defines the structure of a map which identifies relationships between categories in different category schemes.

Substitution For: ItemAssociation

CodeMap (CodeMapType): CodeMap defines the structure of a map which identifies relationships between codes in different codelists.

Substitution For: ItemAssociation

ConceptMap (ConceptMapType): ConceptMap defines the structure of a map which identifies relationships between concepts in different concept schemes.

Substitution For: ItemAssociation

ReportingCategoryMap (ReportingCategoryMapType): ReportingCategoryMap defines the structure of a map which identifies relationships between reporting categories in different reporting taxonomies.

Substitution For: ItemAssociation

Transformation (TransformationType): Transformation describes the details of a single transformation within a transformation scheme.

Substitution For: Item

VtlMapping (VtlMappingType): VtlMapping details a mapping between SDMX and VTL transformation.

Substitution For: Item

NamePersonalisation (NamePersonalisationType): NamePersonalisation details a name personalisation that is used in a transformation.

Substitution For: Item

Ruleset (RulesetType): Ruleset details a ruleset within a ruleset scheme.

Substitution For: Item

UserDefinedOperator (UserDefinedOperatorType): UserDefinedOperator details a user defined operators within a user defined operator scheme.

Substitution For: Item

CustomType (CustomTypeType): CustomType details a custom type within a custom type scheme.

Substitution For: Item

2.1.3 Complex Types

StructuresType: StructuresType describes the structure of the container for all structural metadata components. The structural components may be explicitly detailed, or referenced from an external structure document or registry service. Best practices dictate that, at a minimum, any structural component that is referenced by another structural component be included by reference.

Content:

OrganisationSchemes?, Dataflows?, Metadataflows?, CategorySchemes?, Categorisations?, Codelists?, HierarchicalCodelists?, Concepts?, MetadataStructures?, DataStructures?, StructureSets?, ReportingTaxonomies?, Processes?, Constraints?, ProvisionAgreements?, CustomTypes?, VtlMappings?, NamePersonalisations?, Rulesets?, Transformations?, UserDefinedOperators?

Element Documentation:

OrganisationSchemesType: OrganisationSchemesType describes the structure of the organisation schemes container. It contains one or more organisation scheme, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
(AgencyScheme | DataConsumerScheme | DataProviderScheme | OrganisationUnitScheme)+

Element Documentation:

DataflowsType: DataflowsType describes the structure of the data flows container. It contains one or more data flow, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
Dataflow+

Element Documentation:

MetadataflowsType: MetadataflowsType describes the structure of the metadata flows container. It contains one or more metadata flow, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
Metadataflow+

Element Documentation:

CategorySchemesType: CategorySchemesType describes the structure of the category schemes container. It contains one or more category scheme, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
CategoryScheme+

Element Documentation:

CategorisationsType: CategorisationsType describes the structure of the categorisations container. It contains one or more categorisation of a specific object type, which can be explicitly detailed or referenced from an external structure document or registry service. This container may contain categorisations for multiple types of structural objects.

Content:
Categorisation+

Element Documentation:

CodelistsType: CodelistsType describes the structure of the code lists container. It contains one or more code list, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
Codelist+

Element Documentation:

HierarchicalCodelistsType: HierarchicalCodelistsType describes the structure of the hierarchical code lists container. It contains one or more hierarchical code list, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
HierarchicalCodelist+

Element Documentation:

ConceptsType: ConceptsType describes the structure of the concepts container. It contains one or more concept schemes, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
ConceptScheme*

Element Documentation:

MetadataStructuresType: MetadataStructuresType describes the structure of the metadata structure definitions container. It contains one or more metadata structure definition, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
MetadataStructure+

Element Documentation:

DataStructuresType: DataStructuresType describes the structure of the data structure definitions container. It contains one or more data structure definition, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
DataStructure+

Element Documentation:

StructureSetsType: StructureSetsType describes the structure of the structure sets container. It contains one or more structure set, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
StructureSet+

Element Documentation:

ReportingTaxonomiesType: ReportingTaxonomiesType describes the structure of the reporting taxonomies container. It contains one or more reporting taxonomy, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
ReportingTaxonomy+

Element Documentation:

ProcessesType: ProcessesType describes the structure of the processes container. It contains one or more process, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
Process+

Element Documentation:

ConstraintsType: ConstraintsType describes the structure of the constraints container. It contains one or more constraint, which can be explicitly detailed or referenced from an external structure document or registry service. This container may contain both attachment and content constraints.

Content
(AttachmentConstraint | ContentConstraint)+

Element Documentation:

ProvisionAgreementsType: ProvisionAgreementsType describes the structure of the provision agreements container. It contains one or more provision agreement, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
ProvisionAgreement+

Element Documentation:

CustomTypesType: CustomTypesType describes the structure of the custom type schemes container. It contains one or more custom type scheme, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
CustomTypeScheme+

Element Documentation:

VtlMappingsType: VtlMappingsType describes the structure of the VTL mappings schemes container. It contains one or more VTL mapping schemes, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
VtlMappingScheme+

Element Documentation:

NamePersonalisationsType: NamePersonalisationsType describes the structure of the name personalisation schemes container. It contains one or more name personalisation scheme, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
NamePersonalisationScheme+

Element Documentation:

RulesetsType: RulesetsType describes the structure of the ruleset schemes container. It contains one or more ruleset scheme, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
RulesetScheme+

Element Documentation:

TransformationsType: TransformationsType describes the structure of the transformations container. It contains one or more transformation schemes, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
TransformationScheme+

Element Documentation

UserDefinedOperatorsType: UserDefinedOperatorsType describes the structure of the user defined operator schemes container. It contains one or more user defined operator scheme, which can be explicitly detailed or referenced from an external structure document or registry service.

Content:
UserDefinedOperatorScheme+

Element Documentation:

IdentifiableType: IdentifiableType is an abstract base type for all identifiable objects.

Derivation:

• com:AnnotableType (extension)
  • dentifiableType

Attributes:
id?, urn?, uri?

Conten:
com:Annotations?

Attribute Documentation:

Element Documentation:

NameableType: NameableType is an abstract base type for all nameable objects.

Derivation:

• com:AnnotableType (extension)
  • IdentifiableType (extension)
    • NameableType

Attributes:
id?, urn?, uri?

Content:
com:Annotations?, com:Name+, com:Description*

Attribute Documentation:

Element Documentation:

VersionableType: VersionableType is an abstract base type for all versionable objects.

Derivation:

• com:AnnotableType (extension)
  • IdentifiableType (extension)
    • NameableType (extension)
      • VersionableType

Attributes:
id?, urn?, uri?, version?, validFrom?, validTo?

Content:
com:Annotations?, com:Name+, com:Description*

Attribute Documentation:

Element Documentation:

MaintainableBaseType: MaintainableBaseType is an abstract type that only serves the purpose of forming the base for the actual MaintainableType. The purpose of this type is to restrict the VersionableType to require the id attribute.

Derivation:

• com:AnnotableType (extension)
  • IdentifiableType (extension)
    • NameableType (extension)
      • VersionableType (restriction)
        • MaintainableBaseType

Attributes:
id, urn?, uri?, version?, validFrom?, validTo?

Content:
com:Annotations?, com:Name+, com:Description*

Attribute Documentation:

Element Documentation:

MaintainableType: MaintainableType is an abstract base type for all maintainable objects.

Derivation:

• com:AnnotableType (extension)
  • IdentifiableType (extension)
    • NameableType (extension)
      • VersionableType (restriction)
        • MaintainableBaseType (extension)
          • MaintainableType

Attributes:
id, urn?, uri?, version?, validFrom?, validTo?, agencyID, isFinal?, isExternalReference?, serviceURL?, structureURL?

Content:
com:Annotations?, com:Name+, com:Description*

Attribute Documentation:

Element Documentation:

ItemSchemeType: ItemSchemeType is an abstract base type for all item scheme objects. It contains a collection of items. Concrete instances of this type should restrict the actual types of items allowed within the scheme.

Derivation:
com:AnnotableType (extension)
 IdentifiableType (extension)
   NameableType (extension)
    VersionableType (restriction)
          MaintainableBaseType (extension)
                MaintainableType (extension)
                      ItemSchemeType

Attributes:
id, urn?, uri?, version?, validFrom?, validTo?, agencyID, isFinal?, isExternalReference?, serviceURL?, structureURL?, isPartial?

Content:
com:Annotations?, com:Name+, com:Description*, Item*

Attribute Documentation:

Element Documentation:

ItemBaseType: ItemBaseType is an abstract base type that forms the basis for the ItemType. It requires that at least an id be supplied for an item.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (restriction)
   ItemBaseType

Attributes:
id, urn?, uri?

Content:
com:Annotations?, com:Name+, com:Description*

Attribute Documentation:

Element Documentation:

ItemType: ItemType is an abstract base type for all items with in an item scheme. Concrete instances of this type may or may not utilize the nested item, but if so should restrict the actual types of item allowed.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (restriction)
    ItemBaseType (extension)
          ItemType

Attributes:
id, urn?, uri?

Content:
com:Annotations?, com:Name+, com:Description*, (Parent | Item+)?

Attribute Documentation:

Element Documentation:

UnnestedItemType: UnnestedItemType is an abstract base type for all items with in an item scheme that do not contain nexted items.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NmeableType (restriction)
    ItemBaseType (extension)
          ItemType (restriction)
                UnnestedItemType

Attributes:
id, urn?, uri?

Content:
com:Annotations?, com:Name+, com:Description*

Attribute Documentation:

Element Documentation:

StructureType: StructureType is an abstract base type for all structure objects. Concrete instances of this should restrict to a concrete grouping.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (extension)
    VersionableType (restriction)
          MaintainableBaseType (extension)
                MaintainableType (extension)
                      StructureType

Attributes:
id, urn?, uri?, version?, validFrom?, validTo?, agencyID, isFinal?, isExternalReference?, serviceURL?, structureURL?

Content:
com:Annotations?, com:Name+, com:Description*, Grouping?

Attribute Documentation:

Element Documentation:

GroupingType: GroupType is an abstract base type for specific structure groupings. It contains a collection of component lists. Concrete instances of this should restrict to specific concrete component lists.

Content:
ComponentList*

Element Documentation:

ComponentListType: ComponentListType is an abstract base type for all component lists. It contains a collection of components. Concrete types should restrict this to specific concrete components.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
ComponentListType

Attributes:
id?, urn?, uri?

Content:
com:Annotations?, Component*

Attribute Documentation:

Element Documentation:

ComponentBaseType: ComponentBaseType is an abstract type that only serves the purpose of forming the base for the actual ComponentType. It only restricts the format of the id attribute to the NCNameIDType.

Derivation:
com:AnnotableType (extension)
IdentifiableType (restriction)
ComponentBaseType

Attributes:
id?, urn?, uri?

Content:
com:Annotations?

Attribute Documentation:

Element Documentation:

ComponentType: ComponentType is an abstract base type for all components. It contains information pertaining to a component, including an optional reference to a concept, an optional role played by the concept, an optional text format description, and an optional local representation.

Derivation:
com:AnnotableType (extension)
IdentifiableType (restriction)
ComponentBaseType (extension)
ComponentType

Attributes:
id?, urn?, uri?

Content:
com:Annotations?, ConceptIdentity?, LocalRepresentation?

Attribute Documentation:

Element Documentation:

StructureUsageType: StructureUsageType is an abstract base type for all structure usages. It contains a reference to a structure. Concrete instances of this type should restrict the type of structure referenced.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (extension)
 VersionableType (restriction)
     MaintainableBaseType (extension)
         MaintainableType (extension)
             StructureUsageType

Attributes:
id, urn?, uri?, version?, validFrom?, validTo?, agencyID, isFinal?, isExternalReference?, serviceURL?, structureURL?

Content:
com:Annotations?, com:Name+, com:Description*, Structure?

Attribute Documentation:

Element Documentation:

RepresentationType: RepresentationType is an abstract type that defines a representation. Because the type of item schemes that are allowed as the an enumeration vary based on the object in which this is defined, this type is abstract to force that the enumeration reference be restricted to the proper type of item scheme reference.

Content:
(TextFormat | (Enumeration, EnumerationFormat?))

Element Documentation:

TextFormatType: TextFormatType defines the information for describing a full range of text formats and may place restrictions on the values of the other attributes, referred to as "facets".

Attributes:
textType?, isSequence?, interval?, startValue?, endValue?, timeInterval?, startTime?, endTime?, minLength?, maxLength?, minValue?, maxValue?, decimals?, pattern?, isMultiLingual?

Content:
{Empty}

Attribute Documentation:

BasicComponentTextFormatType: BasicComponentTextFormatType is a restricted version of the TextFormatType that restricts the text type to the representations allowed for all components except for target objects.

Derivation:
TextFormatType (restriction)
   BasicComponentTextFormatType

Attributes:
textType?, isSequence?, interval?, startValue?, endValue?, timeInterval?, startTime?, endTime?, minLength?, maxLength?, minValue?, maxValue?, decimals?, pattern?, isMultiLingual?

Content:
{Empty}

Attribute Documentation:

SimpleComponentTextFormatType: SimpleComponentTextFormatType is a restricted version of the BasicComponentTextFormatType that does not allow for multi-lingual values.

Derivation:
TextFormatType (restriction)
 BasicComponentTextFormatType (restriction)
    SimpleComponentTextFormatType

Attributes:
textType?, isSequence?, interval?, startValue?, endValue?, timeInterval?, startTime?, endTime?, minLength?, maxLength?, minValue?, maxValue?, decimals?, pattern?

Content:
{Empty}

Attribute Documentation:

CodededTextFormatType: CodededTextFormatType is a restricted version of the SimpleComponentTextFormatType that only allows factets and text types applicable to codes. Although the time facets permit any value, an actual code identifier does not support the necessary characters for time. Therefore these facets should not contain time in their values.

Derivation:
TextFormatType (restriction)
 BasicComponentTextFormatType (restriction)
    SimpleComponentTextFormatType (restriction)
         CodededTextFormatType

Attributes:
textType?, isSequence?, interval?, startValue?, endValue?, timeInterval?, startTime?, endTime?, minLength?, maxLength?, minValue?, maxValue?, pattern?

Content:
{Empty}

Attribute Documentation:

NonFacetedTextFormatType: NonFacetedTextFormatType is a restricted version of the SimpleComponentTextFormatType that does not allow for any facets.

Derivation:
TextFormatType (restriction)
 BasicComponentTextFormatType (restriction)
    SimpleComponentTextFormatType (restriction)
         NonFacetedTextFormatType

Attributes:
textType?

Content:
{Empty}

Attribute Documentation:

TimeTextFormatType: TimeTextFormat is a restricted version of the SimpleComponentTextFormatType that only allows time based format and specifies a default ObservationalTimePeriod representation and facets of a start and end time.

Derivation:
TextFormatType (restriction)
 BasicComponentTextFormatType (restriction)
    SimpleComponentTextFormatType (restriction)
         TimeTextFormatType

Attributes:
textType?, startTime?, endTime?

Content:
{Empty}

Attribute Documentation:

CategorisationType: CategorisationType is defines the structure for a categorisation. A source object is referenced via an object reference and the target category is referenced via the target category.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (extension)
   VersionableType (restriction)
        MaintainableBaseType (extension)
             MaintainableType (extension)
                       CategorisationType

Attributes:
id, urn?, uri?, version?, validFrom?, validTo?, agencyID, isFinal?, isExternalReference?, serviceURL?, structureURL?

Content:
com:Annotations?, com:Name+, com:Description*, (Source, Target)?

Attribute Documentation:

Element Documentation:

CategorySchemeType: CategorySchemeType describes the structure of a category scheme. A category scheme is the descriptive information for an arrangement or division of categories into groups based on characteristics, which the objects have in common. This provides for a simple, leveled hierarchy or categories.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (extension)
 VersionableType (restriction)
      MaintainableBaseType (extension)
            MaintainableType (extension)
                 ItemSchemeType (restriction)
                            CategorySchemeType

Attributes:
id, urn?, uri?, version?, validFrom?, validTo?, agencyID, isFinal?, isExternalReference?, serviceURL?, structureURL?, isPartial?

Content:
com:Annotations?, com:Name+, com:Description*, Category*

Attribute Documentation:

Element Documentation:

CategoryType: CategoryType describes the details of a category. A category is defined as an item at any level in a classification. The Category element represents a set of nested categories which are child categories.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (restriction)
 ItemBaseType (extension)
       ItemType (restriction)
                  CategoryType

Attributes:
ёёid, urn?, uri?

Content:

com:Annotations?, com:Name+, com:Description*, Category*

Attribute Documentation:

Element Documentation:

CodelistType: CodelistType defines the structure of a codelist. A codelist is defined as a list from which some statistical concepts (coded concepts) take their values.

Derivation:

com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (extension)
 VersionableType (restriction)
      MaintainableBaseType (extension)
          MaintainableType (extension)
               ItemSchemeType (restriction)
                          CodelistType

Attributes:
id, urn?, uri?, version?, validFrom?, validTo?, agencyID, isFinal?, isExternalReference?, serviceURL?, structureURL?, isPartial?

Content:
com:Annotations?, com:Name+, com:Description*, Code*

Attribute Documentation:

Element Documentation:

CodeType: CodeType describes the structure of a code. A code is defined as a language independent set of letters, numbers or symbols that represent a concept whose meaning is described in a natural language. Presentational information not present may be added through the use of annotations.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (restriction)
 ItemBaseType (extension)
     ItemType (restriction)
                CodeType

Attributes:
id, urn?, uri?

Content:
com:Annotations?, com:Name+, com:Description*, Parent?

Attribute Documentation:

Element Documentation:

ConceptSchemeType: ConceptSchemeType describes the structure of a concept scheme. A concept scheme is the descriptive information for an arrangement or division of concepts into groups based on characteristics, which the objects have in common. It contains a collection of concept definitions, that may be arranged in simple hierarchies.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (extension)
VersionableType (restriction)
    MaintainableBaseType (extension)
       MaintainableType (extension)
           ItemSchemeType (restriction)
                     ConceptSchemeType

Attributes:
id, urn?, uri?, version?, validFrom?, validTo?, agencyID, isFinal?, isExternalReference?, serviceURL?, structureURL?, isPartial?

Content:
com:Annotations?, com:Name+, com:Description*, Concept*

Attribute Documentation:

Element Documentation:

ConceptBaseType: ConceptBaseType is an abstract base type the forms the basis of the ConceptType by requiring a name and id, and restricting the content of the id.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (restriction)
ItemBaseType (extension)
    ItemType (restriction)
        ConceptBaseType

Attributes:
id, urn?, uri?

Content:
com:Annotations?, com:Name+, com:Description*, Parent?

Attribute Documentation:

Element Documentation:

ConceptType: ConceptType describes the details of a concept. A concept is defined as a unit of knowledge created by a unique combination of characteristics. If a concept does not specify a TextFormat or a core representation, then the representation of the concept is assumed to be represented by any set of valid characters (corresponding to the xs:string datatype of W3C XML Schema).

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (restriction)
ItemBaseType (extension)
    ItemType (restriction)
        ConceptBaseType (extension)
                  ConceptType

Attributes:
id, urn?, uri?

Content:
com:Annotations?, com:Name+, com:Description*, Parent?, CoreRepresentation?, ISOConceptReference?

Attribute Documentation:

Element Documentation:

ConceptRepresentation: ConceptRepresentation defines the core representation that are allowed for a concept. The text format allowed for a concept is that which is allowed for any non-target object component.

Derivation:

RepresentationType (restriction)
  ConceptRepresentation

Content:
(TextFormat | (Enumeration, EnumerationFormat?))

Element Documentation:

ISOConceptReferenceType: ISOConceptReferenceType provides a reference to and ISO 11179 concept.

Content:
ConceptAgency, ConceptSchemeID, ConceptID

Element Documentation:

ConstraintBaseType: ConstraintBaseType is an abstract base type that forms the basis of the main abstract ConstraintType. It requires that a name be provided.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (extension)
VersionableType (restriction)
    MaintainableBaseType (extension)
         MaintainableType (restriction)
              ConstraintBaseType

Attributes:
id, urn?, uri?, version?, validFrom?, validTo?, agencyID, isFinal?, isExternalReference?, serviceURL?, structureURL?

Content:
com:Annotations?, com:Name+, com:Description*

Attribute Documentation:

Element Documentation:

ConstraintType: ConstraintType is an abstract base type that specific types of constraints (content and attachment) restrict and extend to describe their details. The inclusion of a key or region in a constraint is determined by first processing the included key sets, and then removing those keys defined in the excluded key sets. If no included key sets are defined, then it is assumed the all possible keys or regions are included, and any excluded key or regions are removed from this complete set.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (extension)
VersionableType (restriction)
    MaintainableBaseType (extension)
        MaintainableType (restriction)
             ConstraintBaseType (extension)
                  ConstraintType

Attributes:
id, urn?, uri?, version?, validFrom?, validTo?, agencyID, isFinal?, isExternalReference?, serviceURL?, structureURL?

Content:
com:Annotations?, com:Name+, com:Description*, ConstraintAttachment?, (DataKeySet | MetadataKeySet | CubeRegion | MetadataTargetRegion)*

Attribute Documentation:

Element Documentation:

AttachmentConstraintType: AttachmentConstraintType describes the details of an attachment constraint by defining the data or metadata key sets or component regions that attributes or reference metadata may be attached in the constraint attachment objects.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (extension)
   VersionableType (restriction)
       MaintainableBaseType (extension)
          MaintainableType (restriction)
              ConstraintBaseType (extension)
                  ConstraintType (restriction)
                               AttachmentConstraintType

Attributes:
id, urn?, uri?, version?, validFrom?, validTo?, agencyID, isFinal?, isExternalReference?, serviceURL?, structureURL?

Content:
com:Annotations?, com:Name+, com:Description*, ConstraintAttachment?, (DataKeySet | MetadataKeySet)*

Attribute Documentation:

Element Documentation:

ContentConstraintBaseType: ContentConstraintBaseType is an abstract base type that forms the basis for the ContentConstraintType.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (extension)
 VersionableType (restriction)
      MaintainableBaseType (extension)
           MaintainableType (restriction)
                ConstraintBaseType (extension)
                    ConstraintType (restriction)
                          ContentConstraintBaseType

Attributes:
id, urn?, uri?, version?, validFrom?, validTo?, agencyID, isFinal?, isExternalReference?, serviceURL?, structureURL?

Content:
com:Annotations?, com:Name+, com:Description*, ConstraintAttachment?, (DataKeySet | MetadataKeySet | CubeRegion | MetadataTargetRegion)*

Attribute Documentation:

Element Documentation:

ContentConstraintType: ContentConstraintType describes the details of a content constraint by defining the content regions, key sets, or release information for the constraint attachment objects. Note that if the constraint is for a data provider, then only release calendar information is relevant, as there is no reliable way of determining which key family is being used to frame constraints in terms of cube regions or key sets.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (extension)
  VersionableType (restriction)
      MaintainableBaseType (extension)
          MaintainableType (restriction)
              ConstraintBaseType (extension)
                   ConstraintType (restriction)
                       ContentConstraintBaseType (extension)
                                   ContentConstraintType

Attributes:
id, urn?, uri?, version?, validFrom?, validTo?, agencyID, isFinal?, isExternalReference?, serviceURL?, structureURL?, type?

Content:
com:Annotations?, com:Name+, com:Description*, ConstraintAttachment?, (DataKeySet | MetadataKeySet | CubeRegion | MetadataTargetRegion)*, ReleaseCalendar?, ReferencePeriod?

Attribute Documentation:

Element Documentation:

ReleaseCalendarType: ReleaseCalendarType describes information about the timing of releases of the constrained data. All of these values use the standard "P7D" - style format.

Content:
Periodicity, Offset, Tolerance

Element Documentation:

KeySetType: KeySetType is an abstract base type for defining a collection of keys.

Attributes:
isIncluded

Content:
Key+

Attribute Documentation:

Element Documentation:

DataKeySetType: DataKeySetType defines a collection of full or partial data keys (dimension values).

Derivation:
KeySetType (restriction)
  DataKeySetType

Attributes:
isIncluded

Content:
Key+

Attribute Documentation:

Element Documentation:

MetadataKeySetType: MetadataKeySetType defines a collection of metadata keys (identifier component values).

Derivation:
KeySetType (restriction)
  MetadataKeySetType

Attributes:
isIncluded

Content:
Key+

Attribute Documentation:

Element Documentation:

ConstraintAttachmentType: ConstraintAttachmentType describes a collection of references to constrainable artefacts.

Content:
(DataProvider | DataSet+ | MetadataSet+ | SimpleDataSource+ | (DataStructure+, QueryableDataSource*) | (MetadataStructure+, QueryableDataSource*) | (Dataflow+, QueryableDataSource*) | (Metadataflow+, QueryableDataSource*) | (ProvisionAgreement+, QueryableDataSource*))

Element Documentation:

AttachmentConstraintAttachmentType: AttachmentConstraintAttachmentType defines the structure for specifying the object to which an attachment constraints applies.

Derivation:
ConstraintAttachmentType (restriction)
  AttachmentConstraintAttachmentType

Content:
(DataSet+ | MetadataSet+ | SimpleDataSource+ | DataStructure+ | MetadataStructure+ | Dataflow+ | Metadataflow+ | ProvisionAgreement+)

Element Documentation:

ContentConstraintAttachmentType: ContentConstraintAttachmentType defines the structure for specifying the target object(s) of a content constraint.

Derivation:
ConstraintAttachmentType (restriction)
  ContentConstraintAttachmentType

Content:
(DataProvider | DataSet | MetadataSet | SimpleDataSource | (DataStructure+, QueryableDataSource*) | (MetadataStructure+, QueryableDataSource*) | (Dataflow+, QueryableDataSource*) | (Metadataflow+, QueryableDataSource*) | (ProvisionAgreement+, QueryableDataSource*))

Element Documentation:

DataStructureType: DataStructureType describes the structure of a data structure definition. A data structure definition is defined as a collection of metadata concepts, their structure and usage when used to collect or disseminate data.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
NameableType (extension)
 VersionableType (restriction)
     MaintainableBaseType (extension)
          MaintainableType (extension)
               StructureType (restriction)
                           DataStructureType

Attributes:
id, urn?, uri?, version?, validFrom?, validTo?, agencyID, isFinal?, isExternalReference?, serviceURL?, structureURL?

Content:
com:Annotations?, com:Name+, com:Description*, DataStructureComponents?

Attribute Documentation:

Element Documentation:

DataStructureComponentsBaseType: DataStructureComponentsBaseType is an abstract base type the serves as the basis for the DataStructureComponentsType. This type is necessary to allow for valid substitutions of component lists.

Derivation:
GroupingType (restriction)
DataStructureComponentsBaseType

Content:
{Empty}

DataStructureComponentsType: DataStructureComponentsType describes the structure of the grouping to the sets of metadata concepts that have a defined structural role in the data structure definition. At a minimum at least one dimension and a primary measure must be defined.

Derivation:
GroupingType (restriction)
DataStructureComponentsBaseType (extension)
   DataStructureComponentsType

Content:
DimensionList, Group*, AttributeList?, MeasureList

Element Documentation:

AttributeListBaseType: AttributeListBaseType is an abstract base type used as the basis for the AttributeListType.

Derivation:
com:AnnotableType (extension)
   IdentifiableType (extension)
      ComponentListType (restriction)
       AttributeListBaseType

Attributes:
id?, urn?, uri?

Content:
com:Annotations?

Attribute Documentation:

Element Documentation:

AttributeListType: AttributeListType describes the attribute descriptor for the data structure definition.

Derivation:
com:AnnotableType (extension)
IdentifiableType (extension)
ComponentListType (restriction)
 AttributeListBaseType (extension)
           AttributeListType

Attributes:
id?, urn?, uri?

Content:
com:Annotations?, (Attribute | ReportingYearStartDay)+

Attribute Documentation:

Element Documentation:

AttributeBaseType: AttributeBaseType is an abstract base type that serves as the basis for the AttributeType. It restricts the text format base to a text format valid for data components (that does not allow for XHTML representation). The local representation is restricted to the values defined in codelist. The concept role is restricted to the values valid for a data attribute.

Derivation:
com:AnnotableType (extension)
IdentifiableType (restriction)
ComponentBaseType (extension)
 ComponentType (restriction)
     AttributeBaseType

Attributes:
id?, urn?, uri?

Content:
com:Annotations?, ConceptIdentity, LocalRepresentation?

Attribute Documentation:

Element Documentation:

AttributeType: AttributeType describes the structure of a data attribute, which is defined as a characteristic of an object or entity. The attribute takes its semantic, and in some cases it representation, from its concept identity. An attribute can be coded by referencing a code list from its coded local representation. It can also specify its text format, which is used as the representation of the attribute if a coded representation is not defined. Neither the coded or uncoded representation are necessary, since the attribute may take these from the referenced concept. An attribute specifies its relationship with other data structure components and is given an assignment status. These two properties dictate where in a data message the attribute will be attached, and whether or not the attribute will be required to be given a value. A set of roles defined in concept scheme can be assigned to the attribute.

Derivation:
com:AnnotableType (extension)
IdentifiableType (restriction)
ComponentBaseType (extension)
ComponentType (restriction)
    AttributeBaseType (extension)
               AttributeType

Attributes:
id?, urn?, uri?, assignmentStatus

Content:
com:Annotations?, ConceptIdentity, LocalRepresentation?, ConceptRole*, AttributeRelationship

Attribute Documentation:

Element Documentation:

AttributeRelationshipType: AttributeRelationshipType defines the structure for stating the relationship between an attribute and other data structure definition components.

Content:
(None | (Dimension+, AttachmentGroup*) | Group | PrimaryMeasure)

Element Documentation:

ReportingYearStartDayType: ReportingYearStartDayType defines the structure of the reporting year start day attribute. The reporting year start day attribute takes its semantic from its concept identity (usually the REPORTING_YEAR_START_DAY concept), yet is always has a fixed identifier (REPORTING_YEAR_START_DAY). The reporting year start day attribute always has a fixed text format, which specifies that the format of its value is always a day and month in the ISO 8601 format of 'MM-DD'. As with any other attribute, an attribute relationship must be specified. this relationship should be carefully selected as it will determin what type of data the data structure definition will allow. For example, if an attribute relationship of none is specified, this will mean the data sets conforming to this data structure definition can only contain data with standard reporting periods where the all reporting periods have the same start day. In this case, data reported as standard reporting periods from two entities with different fiscal year start days could not be contained in the same data set.

Derivation:
com:AnnotableType (extension)
IdentifiableType (restriction)
ComponentBaseType (extension)
ComponentType (restriction)
   AttributeBaseType (extension)
             AttributeType (restriction)
                  ReportingYearStartDayType

Attributes:
id?, urn?, uri?, assignmentStatus

Content:
com:Annotations?, ConceptIdentity, LocalRepresentation, AttributeRelationship

Attribute Documentation:

Element Documentation:

ReportingYearStartDayRepresentationType: ReportingYearStartDayRepresentationType defines the representation for the reporting year start day attribute. Enumerated values are not allowed and the text format is fixed to be a day and month in the ISO 8601 format of 'MM-DD'.

Derivation:
RepresentationType (restriction)
DataStructureRepresentationType (restriction)
   SimpleDataStructureRepresentationType (restriction)
      ReportingYearStartDayRepresentationType

Content:
TextFormat

Element Documentation:

ReportingYearStartDayTextFormatType: ReportingYearStartDayTextFormatType is a restricted version of the NonFacetedTextFormatType that fixes the value of the text type to be DayMonth. This type exists solely for the purpose of fixing the representation of the reporting year start day attribute.

Derivation:
TextFormatType (restriction)
 BasicComponentTextFormatType (restriction)
   SimpleComponentTextFormatType (restriction)
      NonFacetedTextFormatType (restriction)
         ReportingYearStartDayTextFormatType

Attributes:
textType?

Content:
{Empty}

Attribute Documentation: