All Downloads are FREE. Search and download functionalities are using the official Maven repository.

schema.XMLSchema.xsd Maven / Gradle / Ivy

The newest version!







    
        
            Part 1 version: Id: structures.xsd,v 1.2 2004/01/15 11:34:25 ht Exp Part 2 version: Id: datatypes.xsd,v 1.3
            2004/01/23 18:11:13 ht Exp
        
    

    
        
            The schema corresponding to this document is normative, with respect to the syntactic constraints it
            expresses in the XML Schema language. The documentation (within <documentation> elements) below, is not
            normative, but rather highlights important aspects of the W3C Recommendation of which this is a part
        
    

    
        
            The simpleType element and all of its members are defined towards the end of this schema document
        
    

    
        
            
                Get access to the xml: attribute groups for xml:lang as declared on 'schema' and 'documentation' below
            
        
    

    
        
            
                This type is extended by almost all schema types to allow attributes from other namespaces to be added
                to user schemas.
            
        
        
            
                
            
        
    

    
        
            
                This type is extended by all types which allow annotation other than <schema> itself
            
        
        
            
                
                    
                
                
            
        
    

    
        
            
                This group is for the elements which occur freely at the top level of schemas. All of their types are
                based on the "annotated" type by extension.
            
        
        
            
            
            
            
        
    

    
        
            
                This group is for the elements which can self-redefine (see <redefine> below).
            
        
        
            
            
            
            
        
    

    
        
            A utility type, not for public use
        
        
            
            
        
    

    
        
            A utility type, not for public use
        
        
            
            
        
    

    
        
            A utility type, not for public use
            #all or (possibly empty) subset of {extension, restriction}
        
        
            
                
                    
                
            
            
                
            
        
    

    
        
            A utility type, not for public use
        
        
            
            
            
            
        
    

    
        
            A utility type, not for public use
            
                #all or (possibly empty) subset of {extension, restriction, list, union}
            
        
        
            
                
                    
                
            
            
                
            
        
    

    
        
            
        
        
            
                
                    
                        
                            
                            
                            
                            
                        
                        
                            
                            
                        
                    
                    
                    
                    
                    
                    
                    
                    
                    
                
            
        

        
            
            
        

        
            
            
        

        
            
            
        

        
            
            
        

        
            
            
        

        
            
            
        

        
            
            
        

    

    
        
            for maxOccurs
        
        
            
                
                    
                
            
        
    

    
        
            for all particles
        
        
        
    

    
        
            for element, group and attributeGroup, which both define and reference
        
        
        
    

    
        
            'complexType' uses this
        
        
            
            
            
            
        
    



    
        
            
            
            
            
            
        
    

    
        
            
            
            
            
            
            
        
    

    
        
            
                
                    
                
                
                
                
                    
                        
                            
                            
                            
                        
                    
                
                
                
                
            
        
    

    
        
            
                
                    
                    
                
                
                
                
                
                
            
        
    

    
        
            
                
                
            
            
        
    

    
        
            
        
    

    
        
            
            
            
                
                    
                        This branch is short for <complexContent> <restriction base="xs:anyType"> ...
                        </restriction> </complexContent>
                    
                
                
                
            
        
    

    
        
            
                
                
                    
                        Will be restricted to required or forbidden
                    
                
                
                    
                        
                            Not allowed if simpleContent child is chosen. May be overriden by setting on complexContent
                            child.
                        
                    
                
                
                
                
            
        
    

    
        
            
                
                    
                    
                
                
                
            
        
    

    
        
            
                
                    
                    
                
                
                
                
                
                
            
        
    

    
        
            
                
                    
                        
                        
                    
                    
                
                
            
        
    

    
        
            
                
                    
                    
                        
                            
                                This choice is added simply to make this a valid restriction per the REC
                            
                        
                        
                    
                    
                
                
            
        
    

    
        
            
                
                    
                    
                
                
            
        
    

    
        
            
        
        
            
                
                    
                        
                        
                    
                    
                        
                            Overrides any setting on complexType parent.
                        
                    
                
            
        
    

    
        
            
                
                    
                    
                        
                            
                                This choice is added simply to make this a valid restriction per the REC
                            
                        
                        
                    
                    
                
                
            
        
    

    
        
            
                
                    
                        No typeDefParticle group reference
                    
                    
                    
                
                
            
        
    

    
        
            
        
        
            
                
                    
                        
                        
                    
                
            
        
    

    
        
            
        
    


    
        
            A utility type, not for public use
            
                #all or (possibly empty) subset of {substitution, extension, restriction}
            
        
        
            
                
                    
                
            
            
                
                    
                        
                            
                            
                            
                        
                    
                
            
        
    

    
        
            
                The element element can be used either at the top level to define an element-type binding globally, or
                within a content model to either reference a globally-defined element or type or declare an element-type
                binding locally. The ref form is not allowed at the top level.
            
        

        
            
                
                    
                        
                        
                    
                    
                
                
                
                
                
                
                
                
                
                
                
                
            
        
    

    
        
            
                
                    
                    
                        
                        
                    
                    
                
                
                
                
                
                
                
            
        
    

    
        
            
                
                    
                    
                        
                        
                    
                    
                
                
                
                
                
            
        
    

    
        
            
        
    

    
        
            
                group type for explicit groups, named top-level groups and group references
            
        
        
            
                
                
                
            
        
    

    
        
            
                
                    
                    
                        
                        
                        
                    
                
                
            
        
    

    
        
            
                
                    
                    
                        
                            
                                
                                    
                                        
                                        
                                        
                                        
                                    
                                
                            
                        
                        
                        
                    
                
                
                
                
                
                
            
        
    

    
        
            
                
                    
                
                
                
                
            
        
    

    
        
            group type for the three kinds of group
        
        
            
                
                    
                    
                
                
                
                
            
        
    

    
        
            
                
                    
                    
                
                
                
                
            
        
    

    
        
            
            
                
                    
                        This choice with min/max is here to avoid a pblm with the Elt:All/Choice/Seq Particle derivation
                        constraint
                    
                
                
            
        
    


    
        
            restricted max/min
        
        
            
                
                    
                    
                        
                        
                    
                    
                
                
                    
                        
                            
                            
                        
                    
                
                
                    
                        
                            
                            
                        
                    
                
                
            
        
    

    
        
            Only elements allowed inside
        
        
            
                
                
                    
                        
                            
                            
                        
                    
                
                
                    
                        
                            
                        
                    
                
                
            
        
    

    
        
            
        
    

    
        
            
        
    

    
        
            
        
    

    
        
            
        
    

    
        
            
                
                
                    
                        
                            
                            
                            
                        
                    
                
            
        
    

    
        
            
        
        
            
                
                    
                
            
        
    

    
        
            simple type for the value of the 'namespace' attr of 'any' and 'anyAttribute'
        
    
    
        
            Value is ##any - - any non-conflicting WFXML/attribute at all

            ##other - - any non-conflicting WFXML/attribute from namespace other than targetNS

            ##local - - any unqualified non-conflicting WFXML/attribute

            one or - - any non-conflicting WFXML/attribute from more URI the listed namespaces references (space
            separated)

            ##targetNamespace or ##local may appear in the above list, to refer to the targetNamespace of the enclosing
            schema or an absent targetNamespace respectively
        
    

    
        
            A utility type, not for public use
        
        
            
                
                    
                    
                
            
            
                
                    
                        
                            
                                
                                    
                                    
                                
                            
                        
                    
                
            
        
    

    
        
            
        
    

    
        
            
                
                
            
        
    

    
        
            
                
                    
                    
                
                
                
                
            
        
    

    
        
            
                
                    
                
                
                
                
            
        
    

    
        
            
        
    

    
        
            
        
        
            
                
                    
                
            
        
    

    
        
            
        
        
            
                
                    
                        
                        
                    
                    
                    
                
            
        
    

    
        
            
        
        
            
                
                    
                    
                
            
        
    

    
        
            
        
        
            
                
                    
                        
                            
                                A subset of XPath expressions for use in selectors
                                A utility type, not for public use
                            
                            
                                
                                    
                                        The following pattern is intended to allow XPath expressions per the following
                                        EBNF: Selector ::= Path ( '|' Path )* Path ::= ('.//')? Step ( '/' Step )* Step
                                        ::= '.' | NameTest NameTest ::= QName | '*' | NCName ':' '*' child:: is also
                                        allowed
                                    
                                
                                
                                
                            
                        
                    
                
            
        
    

    
        
            
        
        
            
                
                    
                        
                            
                                A subset of XPath expressions for use in fields
                                A utility type, not for public use
                            
                            
                                
                                    
                                        The following pattern is intended to allow XPath expressions per the same EBNF
                                        as for selector, with the following change: Path ::= ('.//')? ( Step '/' )* (
                                        Step | '@' NameTest )
                                    
                                
                                
                                
                            
                        
                    
                
            
        
    

    
        
            
                
                    
                    
                
                
            
        
    

    
        
            
                The three kinds of identity constraints, all with type of or derived from 'keybase'.
            
        
        
            
            
            
        
    

    
        
            
        
    
    
        
            
        
    
    
        
            
        
        
            
                
                    
                
            
        
    

    
        
            
        
        
            
                
                    
                    
                    
                
            
        
    

    
        
            A utility type, not for public use
            A public identifier, per ISO 8879
        
        
    

    
        
            
        
        
            
                
            
            
            
        
    

    
        
            
        
        
            
                
            
            
            
            
        
    

    
        
            
        
        
            
                
                    
                        
                        
                    
                    
                
            
        
    

    
        notations for use within XML Schema schemas
    

    
    

    
        
            
                Not the real urType, but as close an approximation as we can get in the XML representation
            
        
        
            
        
        
    

    
        
            First the built-in primitive datatypes. These definitions are for information only, the real built-in
            definitions are magic.
        

        
            For each built-in datatype in this schema (both primitive and derived) can be uniquely addressed via a URI
            constructed as follows: 1) the base URI is the URI of the XML Schema namespace 2) the fragment identifier is
            the name of the datatype

            For example, to address the int datatype, the URI is:

            http://www.w3.org/2001/XMLSchema#int

            Additionally, each facet definition element can be uniquely addressed via a URI constructed as follows: 1)
            the base URI is the URI of the XML Schema namespace 2) the fragment identifier is the name of the facet

            For example, to address the maxInclusive facet, the URI is:

            http://www.w3.org/2001/XMLSchema#maxInclusive

            Additionally, each facet usage in a built-in datatype definition can be uniquely addressed via a URI
            constructed as follows: 1) the base URI is the URI of the XML Schema namespace 2) the fragment identifier is
            the name of the datatype, followed by a period (".") followed by the name of the facet

            For example, to address the usage of the maxInclusive facet in the definition of int, the URI is:

            http://www.w3.org/2001/XMLSchema#int.maxInclusive

        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
            
            
            
                NOTATION cannot be used directly in a schema; rather a type must be derived from it by specifying at
                least one enumeration facet whose value is the name of a NOTATION declared in the schema.
            
        
        
            
        
    

    
        Now the derived primitive types
    

    
        
            
        
        
            
        
    

    
        
            
        
        
            
        
    

    
        
            
        
        
            
                
                    
                        pattern specifies the content of section 2.12 of XML 1.0e2 and RFC 3066 (Revised version of RFC
                        1766).
                    
                
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
                
            
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
                
            
            
        
    

    
        
            
        
        
            
                
                    
                        pattern matches production 7 from the XML spec
                    
                
            
        
    

    
        
            
                
                
                
                
                
                
                
                
                
                
            
            
        
        
            
                
            
            
        
    

    
        
            
        
        
            
                
                    
                        pattern matches production 5 from the XML spec
                    
                
            
        
    

    
        
            
        
        
            
                
                    
                        pattern matches production 4 from the Namespaces in XML spec
                    
                
            
        
    

    
        
            
        
        
    

    
        
            
        
        
    

    
        
            
        
        
    

    
        
            
        
        
            
            
        
    

    
        
            
        
        
            
        
    

    
        
            
        
        
            
        
    

    
        
            
                
                
            
            
        
        
            
            
        
    

    
        
            
        
        
            
            
        
    

    
        
            
        
        
            
            
        
    

    
        
            
        
        
            
            
        
    

    
        
            
        
        
            
        
    

    
        
            
                
                
            
            
        
        
            
        
    

    
        
            
        
        
            
        
    

    
        
            
        
        
            
        
    

    
        
            
        
        
            
        
    

    
        
            
        
        
            
        
    

    
        
            A utility type, not for public use
        
        
            
            
            
            
            
        
    

    
        
            
            
            
        
    

    
        
            #all or (possibly empty) subset of {restriction, union, list}
            A utility type, not for public use
        
        
            
                
                    
                
            
            
                
                    
                        
                            
                            
                            
                        
                    
                
            
        
    

    
        
            
                
                
                
                    
                        Can be restricted to required or forbidden
                    
                
            
        
    

    
        
            
                
                    
                    
                
                
                    
                        Required at the top level
                    
                
                
            
        
    

    
        
            
                
                    
                    
                
                
                    
                        Forbidden when nested
                    
                
                
                
            
        
    

    
        
            
        
    

    
        
            
                We should use a substitution group for facets, but that's ruled out because it would allow users to add
                their own, which we're not ready for yet.
            
        
        
            
            
            
            
            
            
            
            
            
            
            
            
        
    

    
        
            
            
        
    

    
        
            
                
                    base attribute and simpleType child are mutually exclusive, but one or other is required
                
            
            
                
                    
                    
                
            
        
    

    
        
            
                
                    itemType attribute and simpleType child are mutually exclusive, but one or other is required
                
            
            
                
                    
                        
                    
                    
                
            
        
    

    
        
            
                
                    memberTypes attribute must be non-empty or there must be at least one simpleType child
                
            
            
                
                    
                        
                    
                    
                        
                            
                        
                    
                
            
        
    

    
        
            
                
                
            
        
    

    
        
            
                
                    
                
                
                
            
        
    

    
        
            
        
    
    
        
            
        
    

    
        
            
        
    
    
        
            
        
    

    
        
            
                
                    
                
                
                
            
        
    

    
        
            
        
        
            
                
                    
                        
                    
                    
                    
                
            
        
    
    
        
            
        
    

    
        
            
        
    
    
        
            
        
    
    
        
            
        
    

    
        
            
        
    

    
        
            
        
        
            
                
                    
                        
                    
                    
                        
                            
                                
                                
                                
                            
                        
                    
                    
                
            
        
    

    
        
            
        
        
            
                
                    
                        
                    
                    
                    
                
            
        
    






© 2015 - 2024 Weber Informatics LLC | Privacy Policy