diff options
Diffstat (limited to 'Master/texmf-dist/source/latex/stex/schema/rnc/owl2-xml.rnc')
| -rw-r--r-- | Master/texmf-dist/source/latex/stex/schema/rnc/owl2-xml.rnc | 532 |
1 files changed, 532 insertions, 0 deletions
diff --git a/Master/texmf-dist/source/latex/stex/schema/rnc/owl2-xml.rnc b/Master/texmf-dist/source/latex/stex/schema/rnc/owl2-xml.rnc new file mode 100644 index 00000000000..cf0bb9c5774 --- /dev/null +++ b/Master/texmf-dist/source/latex/stex/schema/rnc/owl2-xml.rnc @@ -0,0 +1,532 @@ +# From: http://www.w3.org/TR/rdf-sparql-query/#grammar +# The entities implement productions [95] (PN_CHARS_BASE), [96] (PN_CHARS_U), [98] (PN_CHARS), [99] (PN_PREFIX), +# [100] (PN_LOCAL), [71] (PNAME_NS), [72] (PNAME_LN) and [68] (PrefixedName) +# +# PN_PREFIX is roughly equivalent to NCName. + +default namespace = "http://www.w3.org/2002/07/owl#" + +# The ontology +Prefix.type = + attribute name { + xsd:string { + pattern = + "([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-]|[-]|[⁰-]|[Ⰰ-]|[、-]|[豈-﷏]|[ﷰ-�]|[𐀀-])(([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-]|[-]|[⁰-]|[Ⰰ-]|[、-]|[豈-﷏]|[ﷰ-�]|[𐀀-]|_|\-|[0-9]|·|[̀-ͯ]|[‿-⁀]|\.)*([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-]|[-]|[⁰-]|[Ⰰ-]|[、-]|[豈-﷏]|[ﷰ-�]|[𐀀-]|_|\-|[0-9]|·|[̀-ͯ]|[‿-⁀] ))?|" + } + }, + attribute IRI { xsd:anyURI } +start |= Prefix +Prefix = element Prefix { Prefix.type } +Import.type = attribute specialAttrs { text } +start |= Import +Import = element Import { Import.type } +Ontology.type = + Prefix*, + Import*, + ontologyAnnotations, + Axiom*, + attribute ontologyIRI { xsd:anyURI }?, + attribute versionIRI { xsd:anyURI }?, + attribute specialAttrs { text } +start |= Ontology +Ontology = element Ontology { Ontology.type } +# Entities, anonymous individuals, and literals + +# Note that the "Entity" group does not have a corresponding abstract type. +# This is due to the fact that XML Schema does not support multiple inheritence. +# "owl:Class" is both an entity and a class expression. The authors of this schema +# determined it was more useful to be able to retrieve "owl:Class" in such queries +# as schema(*, owl:ClassExpression). +Entity = + Class + | Datatype + | ObjectProperty + | DataProperty + | AnnotationProperty + | NamedIndividual +# This is the type for the attribute. The complex type for the element is capitalized. +abbreviatedIRI = + xsd:string { + pattern = + "(((([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-]|[-]|[⁰-]|[Ⰰ-]|[、-]|[豈-﷏]|[ﷰ-�]|[𐀀-])(([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-]|[-]|[⁰-]|[Ⰰ-]|[、-]|[豈-﷏]|[ﷰ-�]|[𐀀-]|_|\-|[0-9]|·|[̀-ͯ]|[‿-⁀]|\.)*([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-]|[-]|[⁰-]|[Ⰰ-]|[、-]|[豈-﷏]|[ﷰ-�]|[𐀀-]|_|\-|[0-9]|·|[̀-ͯ]|[‿-⁀] ))?)?:)(([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-]|[-]|[⁰-]|[Ⰰ-]|[、-]|[豈-﷏]|[ﷰ-�]|[𐀀-]|_|[0-9])(([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-]|[-]|[⁰-]|[Ⰰ-]|[、-]|[豈-﷏]|[ﷰ-�]|[𐀀-]|_|\-|[0-9]|·|[̀-ͯ]|[‿-⁀]|\.)*([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-]|[-]|[⁰-]|[Ⰰ-]|[、-]|[豈-﷏]|[ﷰ-�]|[𐀀-]|_|\-|[0-9]|·|[̀-ͯ]|[‿-⁀]))?))|((([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-]|[-]|[⁰-]|[Ⰰ-]|[、-]|[豈-﷏]|[ﷰ-�]|[𐀀-])(([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-]|[-]|[⁰-]|[Ⰰ-]|[、-]|[豈-﷏]|[ﷰ-�]|[𐀀-]|_|\-|[0-9]|·|[̀-ͯ]|[‿-⁀]|\.)*([A-Z]|[a-z]|[À-Ö]|[Ø-ö]|[ø-˿]|[Ͱ-ͽ]|[Ϳ-]|[-]|[⁰-]|[Ⰰ-]|[、-]|[豈-﷏]|[ﷰ-�]|[𐀀-]|_|\-|[0-9]|·|[̀-ͯ]|[‿-⁀] ))?)?:)" + } +Class.type = + ClassExpression, + attribute IRI { xsd:anyURI }?, + attribute abbreviatedIRI { abbreviatedIRI }? +start |= Class +Class = element Class { Class.type } +Datatype.type = + DataRange, + attribute IRI { xsd:anyURI }?, + attribute abbreviatedIRI { abbreviatedIRI }? +start |= Datatype +Datatype = element Datatype { Datatype.type } +ObjectProperty.type = + ObjectPropertyExpression, + attribute IRI { xsd:anyURI }?, + attribute abbreviatedIRI { abbreviatedIRI }? +start |= ObjectProperty +ObjectProperty = element ObjectProperty { ObjectProperty.type } +DataProperty.type = + DataPropertyExpression, + attribute IRI { xsd:anyURI }?, + attribute abbreviatedIRI { abbreviatedIRI }? +start |= DataProperty +DataProperty = element DataProperty { DataProperty.type } +AnnotationProperty.type = + attribute IRI { xsd:anyURI }?, + attribute abbreviatedIRI { abbreviatedIRI }?, + attribute specialAttrs { text } +start |= AnnotationProperty +AnnotationProperty = element AnnotationProperty { AnnotationProperty.type } +Individual = attribute specialAttrs { text }, (NamedIndividual | AnonymousIndividual) +NamedIndividual.type = + Individual, + attribute IRI { xsd:anyURI }?, + attribute abbreviatedIRI { abbreviatedIRI }? +start |= NamedIndividual +NamedIndividual = element NamedIndividual { NamedIndividual.type } +AnonymousIndividual.type = + Individual, + attribute nodeID { xsd:NCName } +start |= AnonymousIndividual +AnonymousIndividual = + element AnonymousIndividual { AnonymousIndividual.type } +Literal.type = + attribute datatypeIRI { xsd:anyURI }, + attribute specialAttrs { text } +start |= Literal +Literal = element Literal { Literal.type } +# Declarations +Declaration.type = Axiom, Entity +start |= Declaration +Declaration = element Declaration { Declaration.type } +# Object property expressions +ObjectPropertyExpression = attribute specialAttrs { text }, (ObjectProperty | ObjectInverseOf) +ObjectInverseOf.type = ObjectPropertyExpression, ObjectProperty +start |= ObjectInverseOf +ObjectInverseOf = element ObjectInverseOf { ObjectInverseOf.type } +# Data property expressions +DataPropertyExpression = attribute specialAttrs { text }, DataProperty +# Data ranges +DataRange = attribute specialAttrs { text }, + (Datatype + | DataIntersectionOf + | DataUnionOf + | DataComplementOf + | DataOneOf + | DatatypeRestriction) +DataIntersectionOf.type = DataRange, DataRange+ +start |= DataIntersectionOf +DataIntersectionOf = element DataIntersectionOf { DataIntersectionOf.type } +DataUnionOf.type = DataRange, DataRange+ +start |= DataUnionOf +DataUnionOf = element DataUnionOf { DataUnionOf.type } +DataComplementOf.type = DataRange, DataRange +start |= DataComplementOf +DataComplementOf = element DataComplementOf { DataComplementOf.type } +DataOneOf.type = DataRange, Literal+ +start |= DataOneOf +DataOneOf = element DataOneOf { DataOneOf.type } +DatatypeRestriction.type = + DataRange, + Datatype, + element FacetRestriction { FacetRestriction }+ +start |= DatatypeRestriction +DatatypeRestriction = + element DatatypeRestriction { DatatypeRestriction.type } +FacetRestriction = + Literal, + attribute facet { xsd:anyURI }, + attribute specialAttrs { text } +# Class expressions +ClassExpression = attribute specialAttrs { text }, + (Class + | ObjectIntersectionOf + | ObjectUnionOf + | ObjectComplementOf + | ObjectOneOf + | ObjectSomeValuesFrom + | ObjectAllValuesFrom + | ObjectHasValue + | ObjectHasSelf + | ObjectMinCardinality + | ObjectMaxCardinality + | ObjectExactCardinality + | DataSomeValuesFrom + | DataAllValuesFrom + | DataHasValue + | DataMinCardinality + | DataMaxCardinality + | DataExactCardinality) +ObjectIntersectionOf.type = ClassExpression, ClassExpression+ +start |= ObjectIntersectionOf +ObjectIntersectionOf = + element ObjectIntersectionOf { ObjectIntersectionOf.type } +ObjectUnionOf.type = ClassExpression, ClassExpression+ +start |= ObjectUnionOf +ObjectUnionOf = element ObjectUnionOf { ObjectUnionOf.type } +ObjectComplementOf.type = ClassExpression, ClassExpression +start |= ObjectComplementOf +ObjectComplementOf = element ObjectComplementOf { ObjectComplementOf.type } +ObjectOneOf.type = ClassExpression, Individual+ +start |= ObjectOneOf +ObjectOneOf = element ObjectOneOf { ObjectOneOf.type } +ObjectSomeValuesFrom.type = + ClassExpression, ObjectPropertyExpression, ClassExpression +start |= ObjectSomeValuesFrom +ObjectSomeValuesFrom = + element ObjectSomeValuesFrom { ObjectSomeValuesFrom.type } +ObjectAllValuesFrom.type = + ClassExpression, ObjectPropertyExpression, ClassExpression +start |= ObjectAllValuesFrom +ObjectAllValuesFrom = + element ObjectAllValuesFrom { ObjectAllValuesFrom.type } +ObjectHasValue.type = ClassExpression, ObjectPropertyExpression, Individual +start |= ObjectHasValue +ObjectHasValue = element ObjectHasValue { ObjectHasValue.type } +ObjectHasSelf.type = ClassExpression, ObjectPropertyExpression +start |= ObjectHasSelf +ObjectHasSelf = element ObjectHasSelf { ObjectHasSelf.type } +ObjectMinCardinality.type = + ClassExpression, + ObjectPropertyExpression, + ClassExpression?, + attribute cardinality { xsd:nonNegativeInteger } +start |= ObjectMinCardinality +ObjectMinCardinality = + element ObjectMinCardinality { ObjectMinCardinality.type } +ObjectMaxCardinality.type = + ClassExpression, + ObjectPropertyExpression, + ClassExpression?, + attribute cardinality { xsd:nonNegativeInteger } +start |= ObjectMaxCardinality +ObjectMaxCardinality = + element ObjectMaxCardinality { ObjectMaxCardinality.type } +ObjectExactCardinality.type = + ClassExpression, + ObjectPropertyExpression, + ClassExpression?, + attribute cardinality { xsd:nonNegativeInteger } +start |= ObjectExactCardinality +ObjectExactCardinality = + element ObjectExactCardinality { ObjectExactCardinality.type } +DataSomeValuesFrom.type = ClassExpression, DataPropertyExpression+, DataRange +start |= DataSomeValuesFrom +DataSomeValuesFrom = element DataSomeValuesFrom { DataSomeValuesFrom.type } +DataAllValuesFrom.type = ClassExpression, DataPropertyExpression+, DataRange +start |= DataAllValuesFrom +DataAllValuesFrom = element DataAllValuesFrom { DataAllValuesFrom.type } +DataHasValue.type = ClassExpression, DataPropertyExpression, Literal +start |= DataHasValue +DataHasValue = element DataHasValue { DataHasValue.type } +DataMinCardinality.type = + ClassExpression, + DataPropertyExpression, + DataRange?, + attribute cardinality { xsd:nonNegativeInteger } +start |= DataMinCardinality +DataMinCardinality = element DataMinCardinality { DataMinCardinality.type } +DataMaxCardinality.type = + ClassExpression, + DataPropertyExpression, + DataRange?, + attribute cardinality { xsd:nonNegativeInteger } +start |= DataMaxCardinality +DataMaxCardinality = element DataMaxCardinality { DataMaxCardinality.type } +DataExactCardinality.type = + ClassExpression, + DataPropertyExpression, + DataRange?, + attribute cardinality { xsd:nonNegativeInteger } +start |= DataExactCardinality +DataExactCardinality = + element DataExactCardinality { DataExactCardinality.type } +# Axioms +Axiom = axiomAnnotations, attribute specialAttrs { text }, + (Declaration + | ClassAxiom + | ObjectPropertyAxiom + | DataPropertyAxiom + | DatatypeDefinition + | HasKey + | Assertion + | AnnotationAxiom) +# Class expression axioms +ClassAxiom = Axiom | SubClassOf | EquivalentClasses | DisjointClasses | DisjointUnion +SubClassOf.type = + ClassAxiom, + ClassExpression, + # This is the subexpression + ClassExpression + # This is the superexpression + +start |= SubClassOf +SubClassOf = element SubClassOf { SubClassOf.type } +EquivalentClasses.type = ClassAxiom, ClassExpression+ +start |= EquivalentClasses +EquivalentClasses = element EquivalentClasses { EquivalentClasses.type } +DisjointClasses.type = ClassAxiom, ClassExpression+ +start |= DisjointClasses +DisjointClasses = element DisjointClasses { DisjointClasses.type } +DisjointUnion.type = ClassAxiom, Class, ClassExpression+ +start |= DisjointUnion +DisjointUnion = element DisjointUnion { DisjointUnion.type } +# Object property axioms +ObjectPropertyAxiom = Axiom| + SubObjectPropertyOf + | EquivalentObjectProperties + | DisjointObjectProperties + | InverseObjectProperties + | ObjectPropertyDomain + | ObjectPropertyRange + | FunctionalObjectProperty + | InverseFunctionalObjectProperty + | ReflexiveObjectProperty + | IrreflexiveObjectProperty + | SymmetricObjectProperty + | AsymmetricObjectProperty + | TransitiveObjectProperty +SubObjectPropertyOf.type = + ObjectPropertyAxiom, + (# This is the subproperty expression or the property chain + ObjectPropertyExpression + | element ObjectPropertyChain { ObjectPropertyChain.type }), + ObjectPropertyExpression + # This is the superproperty expression + +start |= SubObjectPropertyOf +SubObjectPropertyOf = + element SubObjectPropertyOf { SubObjectPropertyOf.type } +ObjectPropertyChain.type = + ObjectPropertyExpression+, + attribute specialAttrs { text } +EquivalentObjectProperties.type = + ObjectPropertyAxiom, ObjectPropertyExpression+ +start |= EquivalentObjectProperties +EquivalentObjectProperties = + element EquivalentObjectProperties { EquivalentObjectProperties.type } +DisjointObjectProperties.type = + ObjectPropertyAxiom, ObjectPropertyExpression+ +start |= DisjointObjectProperties +DisjointObjectProperties = + element DisjointObjectProperties { DisjointObjectProperties.type } +ObjectPropertyDomain.type = + ObjectPropertyAxiom, ObjectPropertyExpression, ClassExpression +start |= ObjectPropertyDomain +ObjectPropertyDomain = + element ObjectPropertyDomain { ObjectPropertyDomain.type } +ObjectPropertyRange.type = + ObjectPropertyAxiom, ObjectPropertyExpression, ClassExpression +start |= ObjectPropertyRange +ObjectPropertyRange = + element ObjectPropertyRange { ObjectPropertyRange.type } +InverseObjectProperties.type = + ObjectPropertyAxiom, + ObjectPropertyExpression, + ObjectPropertyExpression +start |= InverseObjectProperties +InverseObjectProperties = + element InverseObjectProperties { InverseObjectProperties.type } +FunctionalObjectProperty.type = ObjectPropertyAxiom, ObjectPropertyExpression +start |= FunctionalObjectProperty +FunctionalObjectProperty = + element FunctionalObjectProperty { FunctionalObjectProperty.type } +InverseFunctionalObjectProperty.type = + ObjectPropertyAxiom, ObjectPropertyExpression +start |= InverseFunctionalObjectProperty +InverseFunctionalObjectProperty = + element InverseFunctionalObjectProperty { + InverseFunctionalObjectProperty.type + } +ReflexiveObjectProperty.type = ObjectPropertyAxiom, ObjectPropertyExpression +start |= ReflexiveObjectProperty +ReflexiveObjectProperty = + element ReflexiveObjectProperty { ReflexiveObjectProperty.type } +IrreflexiveObjectProperty.type = + ObjectPropertyAxiom, ObjectPropertyExpression +start |= IrreflexiveObjectProperty +IrreflexiveObjectProperty = + element IrreflexiveObjectProperty { IrreflexiveObjectProperty.type } +SymmetricObjectProperty.type = ObjectPropertyAxiom, ObjectPropertyExpression +start |= SymmetricObjectProperty +SymmetricObjectProperty = + element SymmetricObjectProperty { SymmetricObjectProperty.type } +AsymmetricObjectProperty.type = ObjectPropertyAxiom, ObjectPropertyExpression +start |= AsymmetricObjectProperty +AsymmetricObjectProperty = + element AsymmetricObjectProperty { AsymmetricObjectProperty.type } +TransitiveObjectProperty.type = ObjectPropertyAxiom, ObjectPropertyExpression +start |= TransitiveObjectProperty +TransitiveObjectProperty = + element TransitiveObjectProperty { TransitiveObjectProperty.type } +# Data property axioms +DataPropertyAxiom = Axiom | + SubDataPropertyOf + | EquivalentDataProperties + | DisjointDataProperties + | DataPropertyDomain + | DataPropertyRange + | FunctionalDataProperty +SubDataPropertyOf.type = + DataPropertyAxiom, + DataPropertyExpression, + # This is the subproperty expression + DataPropertyExpression + # This is the superproperty expression + +start |= SubDataPropertyOf +SubDataPropertyOf = element SubDataPropertyOf { SubDataPropertyOf.type } +EquivalentDataProperties.type = DataPropertyAxiom, DataPropertyExpression+ +start |= EquivalentDataProperties +EquivalentDataProperties = + element EquivalentDataProperties { EquivalentDataProperties.type } +DisjointDataProperties.type = DataPropertyAxiom, DataPropertyExpression+ +start |= DisjointDataProperties +DisjointDataProperties = + element DisjointDataProperties { DisjointDataProperties.type } +DataPropertyDomain.type = + DataPropertyAxiom, DataPropertyExpression, ClassExpression +start |= DataPropertyDomain +DataPropertyDomain = element DataPropertyDomain { DataPropertyDomain.type} +DataPropertyRange.type = DataPropertyAxiom, DataPropertyExpression, DataRange +start |= DataPropertyRange +DataPropertyRange = element DataPropertyRange { DataPropertyRange.type } +FunctionalDataProperty.type = DataPropertyAxiom, DataPropertyExpression +start |= FunctionalDataProperty +FunctionalDataProperty = + element FunctionalDataProperty { FunctionalDataProperty.type } +# Datatype definitions +DatatypeDefinition.type = Axiom, Datatype, DataRange +start |= DatatypeDefinition +DatatypeDefinition = element DatatypeDefinition { DatatypeDefinition.type } +# Key axioms +HasKey.type = + Axiom, + ClassExpression, + ObjectPropertyExpression*, + DataPropertyExpression* +start |= HasKey +HasKey = element HasKey { HasKey.type } +# Assertions +Assertion = Axiom | + SameIndividual + | DifferentIndividuals + | ClassAssertion + | ObjectPropertyAssertion + | NegativeObjectPropertyAssertion + | DataPropertyAssertion + | NegativeDataPropertyAssertion +SameIndividual.type = Assertion, Individual+ +start |= SameIndividual +SameIndividual = element SameIndividual { SameIndividual.type } +DifferentIndividuals.type = Assertion, Individual+ +start |= DifferentIndividuals +DifferentIndividuals = + element DifferentIndividuals { DifferentIndividuals.type } +ClassAssertion.type = Assertion, ClassExpression, Individual +start |= ClassAssertion +ClassAssertion = element ClassAssertion { ClassAssertion.type } +ObjectPropertyAssertion.type = + Assertion, + ObjectPropertyExpression, + Individual, + # This is the source invididual + Individual + # This is the target individual + +start |= ObjectPropertyAssertion +ObjectPropertyAssertion = + element ObjectPropertyAssertion { ObjectPropertyAssertion.type } +NegativeObjectPropertyAssertion.type = + Assertion, + ObjectPropertyExpression, + Individual, + # This is the source invididual + Individual + # This is the target individual + +start |= NegativeObjectPropertyAssertion +NegativeObjectPropertyAssertion = + element NegativeObjectPropertyAssertion { + NegativeObjectPropertyAssertion.type + } +DataPropertyAssertion.type = + Assertion, + DataPropertyExpression, + Individual, + # This is the source invididual + Literal + # This is the target individual + +start |= DataPropertyAssertion +DataPropertyAssertion = + element DataPropertyAssertion { DataPropertyAssertion.type } +NegativeDataPropertyAssertion.type = + Assertion, + DataPropertyExpression, + Individual, + # This is the source invididual + Literal + # This is the target individual + +start |= NegativeDataPropertyAssertion +NegativeDataPropertyAssertion = + element NegativeDataPropertyAssertion { + NegativeDataPropertyAssertion.type + } +# Annotations +IRI.type = attribute specialAttrs { text } +start |= IRI +IRI = element IRI { IRI.type } +AbbreviatedIRI.type = attribute specialAttrs { text } +start |= AbbreviatedIRI +AbbreviatedIRI = element AbbreviatedIRI { AbbreviatedIRI.type } +AnnotationSubject = IRI | AbbreviatedIRI | AnonymousIndividual +AnnotationValue = IRI | AbbreviatedIRI | AnonymousIndividual | Literal +Annotation.type = + annotationAnnotations, + AnnotationProperty, + AnnotationValue, + attribute specialAttrs { text } +start |= Annotation +Annotation = element Annotation { Annotation.type } +axiomAnnotations = Annotation* +ontologyAnnotations = Annotation* +annotationAnnotations = Annotation* +# Annotation axioms +AnnotationAxiom = Axiom | + AnnotationAssertion + | SubAnnotationPropertyOf + | AnnotationPropertyDomain + | AnnotationPropertyRange +AnnotationAssertion.type = + AnnotationAxiom, + AnnotationProperty, + AnnotationSubject, + AnnotationValue +start |= AnnotationAssertion +AnnotationAssertion = + element AnnotationAssertion { AnnotationAssertion.type } +SubAnnotationPropertyOf.type = + AnnotationAxiom, + AnnotationProperty, + # This is the subproperty + AnnotationProperty + # This is the superproperty + +start |= SubAnnotationPropertyOf +SubAnnotationPropertyOf = + element SubAnnotationPropertyOf { SubAnnotationPropertyOf.type } +AnnotationPropertyDomain.type = + AnnotationAxiom, AnnotationProperty, IRI, AbbreviatedIRI +start |= AnnotationPropertyDomain +AnnotationPropertyDomain = + element AnnotationPropertyDomain { AnnotationPropertyDomain.type } +AnnotationPropertyRange.type = + AnnotationAxiom, AnnotationProperty, IRI, AbbreviatedIRI +start |= AnnotationPropertyRange +AnnotationPropertyRange = + element AnnotationPropertyRange { AnnotationPropertyRange.type } |