14.  EncodingControlSections Translation

   If an EncodingControlSections instance contains at least one
   EncodingControlSection with an encodingreference that is not RXER,
   then the translation of the EncodingControlSections instance is an
   element item with the [local name] "encodingControls".  The
   translation of each EncodingControlSection with an encodingreference
   that is not RXER SHALL be appended to the [children] of the
   <encodingControls> element item.

      Aside: This is not suggesting that RXER encoding control sections
      are ignored.  Encoding control sections for RXER are not
      explicitly represented in ASN.X, but rather affect how an ASN.1
      module is translated into an ASN.X module.  The effect of an RXER
      encoding control section on the translation is addressed in other
      parts of this specification.

      Encoding control sections for other encoding rules will have
      explicit representations in ASN.X.

   If the encodingreference in an EncodingControlSection is GSER, then
   the translation of the EncodingControlSection is an element item with
   the [local name] "GSER".  The translation of the
   EncodingInstructionAssignmentList in the EncodingControlSection SHALL
   be added to the [children] of the <GSER> element item.

   The EncodingInstructionAssignmentList notation is different for each
   set of encoding instructions.  The translation into ASN.X of an
   EncodingInstructionAssignmentList for GSER is specified in a separate
   document [GSEREIT].

      Aside: The translation of an EncodingInstructionAssignmentList for
      GSER, as it is currently defined, is always empty.

   If the encodingreference in an EncodingControlSection is XER, then
   the translation of the EncodingControlSection is an element item with
   the [local name] "XER".  The translation of the
   EncodingInstructionAssignmentList in the EncodingControlSection SHALL
   be added to the [children] of the <XER> element item.  The
   translation into ASN.X of an EncodingInstructionAssignmentList for
   XER is specified in a separate document [XEREIT].

15.  Security Considerations

   The ASN.X translation of an ASN.1 specification is semantically
   equivalent to the original ASN.1 specification.  The security
   considerations that apply to an application built from the original
   ASN.1 specification apply equally to an application built from the
   ASN.X translation.

   Syntax-based canonicalization for XML documents (e.g., Canonical XML
   [CXML]) depends on the Infoset of an XML document being preserved.
   However, the Infoset representation of an ASN.X module potentially
   changes if it is decoded and re-encoded (though its ASN.1 value is
   preserved), disrupting the Canonical XML representation.  To avoid
   this problem, ASN.X modules MUST be normalized prior to the
   application of syntax-based canonicalization.  The normalization
   rules can be found in Section 6.13 of the specification for RXER
   [RXER].

16.  Acknowledgements

   The technology described in this document is the product of a
   research project begun jointly by Adacel Technologies Limited and
   Deakin University, and subsequently refined and completed by eB2Bcom.

17.  References

17.1.  Normative References

   [BCP14]    Bradner, S., "Key words for use in RFCs to Indicate
              Requirement Levels", BCP 14, RFC 2119, March 1997.

   [URI]      Berners-Lee, T., Fielding, R. and L. Masinter, "Uniform
              Resource Identifiers (URI): Generic Syntax", STD 66, RFC
              3986, January 2005.

   [GSER]     Legg, S., "Generic String Encoding Rules (GSER) for ASN.1
              Types", RFC 3641, October 2003.

   [GSEREI]   Legg, S., "Encoding Instructions for the Generic String
              Encoding Rules (GSER)", RFC 4792, January 2007.

   [RXER]     Legg, S. and D. Prager, "Robust XML Encoding Rules (RXER)
              for Abstract Syntax Notation One (ASN.1)",
               RFC 4910, July 2007.

   [RXEREI]   Legg, S., "Encoding Instructions for the Robust XML
              Encoding Rules (RXER)",
               RFC 4911, July 2007.

   [GSEREIT]  Legg, S., "Abstract Syntax Notation X (ASN.X)
              Representation of Encoding Instructions for the Generic
              String Encoding Rules (GSER)",
               RFC 4913, July 2007.

   [XEREIT]   Legg, S., "Abstract Syntax Notation X (ASN.X)
              Representation of Encoding Instructions for the XML
              Encoding Rules (XER)",
               RFC 4914, July 2007.

   [X.680]    ITU-T Recommendation X.680 (07/02) | ISO/IEC 8824-1,
              Information technology - Abstract Syntax Notation One
              (ASN.1):  Specification of basic notation.

   [X.680-1]  ITU-T Recommendation X.680 (2002) Amendment 1 (10/03) |
              ISO/IEC 8824-1:2002/Amd 1:2004, Support for EXTENDED-XER.

   [X.681]    ITU-T Recommendation X.681 (07/02) | ISO/IEC 8824-2,
              Information technology - Abstract Syntax Notation One
              (ASN.1):  Information object specification.

   [X.682]    ITU-T Recommendation X.682 (07/02) | ISO/IEC 8824-3,
              Information technology - Abstract Syntax Notation One
              (ASN.1):  Constraint specification.

   [X.683]    ITU-T Recommendation X.683 (07/02) | ISO/IEC 8824-4,
              Information technology - Abstract Syntax Notation One
              (ASN.1):  Parameterization of ASN.1 specifications.

   [X.693]    ITU-T Recommendation X.693 (12/01) | ISO/IEC 8825-4:2002,
              Information technology - ASN.1 encoding rules: XML
              encoding rules (XER).

   [X.693-1]  Amendment 1: (to ITU-T Rec. X.693 | ISO/IEC 8825-4) XER
              encoding instructions and EXTENDED-XER.

   [XML10]    Bray, T., Paoli, J., Sperberg-McQueen, C., Maler, E. and
              F. Yergeau, "Extensible Markup Language (XML) 1.0 (Fourth
              Edition)", W3C Recommendation,
              http://www.w3.org/TR/2006/REC-xml-20060816, August 2006.

   [XML11]    Bray, T., Paoli, J., Sperberg-McQueen, C., Maler, E.,
              Yergeau, F., and J. Cowan, "Extensible Markup Language
              (XML) 1.1 (Second Edition)", W3C Recommendation,
              http://www.w3.org/TR/2006/REC-xml11-20060816, August 2006.

   [XMLNS10]  Bray, T., Hollander, D., Layman, A., and R. Tobin,
              "Namespaces in XML 1.0 (Second Edition)", W3C
              Recommendation,
              http://www.w3.org/TR/2006/REC-xml-names-20060816, August
              2006.

   [XMLNS11]  Bray, T., Hollander, D., Layman, A. and R. Tobin,
              "Namespaces in XML 1.1 (Second Edition)", W3C
              Recommendation,
              http://www.w3.org/TR/2006/REC-xml-names11-20060816, August
              2006.

   [INFOSET]  Cowan, J. and R. Tobin, "XML Information Set (Second
              Edition)", W3C Recommendation,
              http://www.w3.org/TR/2004/REC-xml-infoset-20040204,
              February 2004.

   [UNICODE]  The Unicode Consortium, "The Unicode Standard, Version
              4.0", Boston, MA, Addison-Wesley Developers Press, 2003.
              ISBN 0-321-18578-1.

17.2.  Informative References

   [CXML]     Boyer, J., "Canonical XML Version 1.0", W3C
              Recommendation,
              http://www.w3.org/TR/2001/REC-xml-c14n-20010315, March
              2001.

   [XSD1]     Thompson, H., Beech, D., Maloney, M. and N. Mendelsohn,
              "XML Schema Part 1: Structures Second Edition", W3C
              Recommendation,
              http://www.w3.org/TR/2004/REC-xmlschema-1-20041028/,
              October 2004.

   [RNG]      Clark, J. and M. Makoto, "RELAX NG Tutorial", OASIS
              Committee Specification, http://www.oasis-open.org/
              committees/relax-ng/tutorial-20011203.html, December 2001.

Appendix A.  ASN.1 for ASN.X

   This appendix is normative.

   AbstractSyntaxNotation-X
       { iso(1) identified-organization(3) dod(6)
         internet(1) private(4) enterprise(1)
         xmled(21472) asnx(1) module(0) notation(1) }

   -- Copyright (C) The IETF Trust (2007).  This version of
   -- this ASN.1 module is part of RFC 4912; see the RFC itself
   -- for full legal notices.
   --
   -- Regarding this ASN.1 module or any portion of it, the author
   -- makes no guarantees and is not responsible for any damage
   -- resulting from its use.  The author grants irrevocable permission
   -- to anyone to use, modify, and distribute it in any way that does
   -- not diminish the rights of anyone else to use, modify, and
   -- distribute it, provided that redistributed derivative works do
   -- not contain misleading author or version information.
   -- Derivative works need not be licensed under similar terms.

   DEFINITIONS
   RXER INSTRUCTIONS
   AUTOMATIC TAGS
   EXTENSIBILITY IMPLIED ::= BEGIN

   IMPORTS
       Markup,
       AnyURI,
       NCName,
       Name,
       QName
           FROM AdditionalBasicDefinitions
               { iso(1) identified-organization(3) dod(6)
                 internet(1) private(4) enterprise(1)
                 xmled(21472) asnx(1) module(0) basic(0) }
       GSER-EncodingInstruction,
       GSER-EncodingInstructionAssignmentList
           FROM GSER-EncodingInstructionNotation
               { iso(1) identified-organization(3) dod(6)
                 internet(1) private(4) enterprise(1)
                 xmled(21472) asnx(1) module(0) gser-ei-notation(2) }
       XER-EncodingInstruction,
       XER-EncodingInstructionAssignmentList
           FROM XER-EncodingInstructionNotation
               { iso(1) identified-organization(3) dod(6)
                 internet(1) private(4) enterprise(1)

                 xmled(21472) asnx(1) module(0) xer-ei-notation(3) }
       ;

   ModuleDefinition ::= [HOLLOW-INSERTIONS] SEQUENCE {
       annotation            Annotation OPTIONAL,
       format                [ATTRIBUTE] [VERSION-INDICATOR]
                                 UTF8String ("1.0", ...) DEFAULT "1.0",
       name                  [ATTRIBUTE] ModuleReference,
       identifier            [ATTRIBUTE] DefinitiveIdentifier OPTIONAL,
       schemaIdentity        [ATTRIBUTE] AnyURI OPTIONAL,
       targetNamespace       [ATTRIBUTE] AnyURI OPTIONAL,
       targetPrefix          [ATTRIBUTE] NCName OPTIONAL,
       tagDefault            [ATTRIBUTE] TagDefault DEFAULT automatic,
       extensibilityImplied  [ATTRIBUTE] BOOLEAN DEFAULT FALSE,
       export                SEQUENCE { } OPTIONAL,
           -- export is not used in this version
       imports               [GROUP] ImportList OPTIONAL,
       assignments           [GROUP] AssignmentList OPTIONAL,
       encodingControls      EncodingControlSections OPTIONAL
   }

   ModuleReference ::= TypeReference

   DefinitiveIdentifier ::= OBJECT IDENTIFIER

   TagDefault ::= ENUMERATED { explicit, implicit, automatic }

   Annotation ::= Markup

   ImportList ::= SEQUENCE SIZE (1..MAX) OF import Import

   Import ::= SEQUENCE {
       name            [ATTRIBUTE] ModuleReference OPTIONAL,
       identifier      [ATTRIBUTE] DefinitiveIdentifier OPTIONAL,
       schemaIdentity  [ATTRIBUTE] AnyURI OPTIONAL,
       namespace       [ATTRIBUTE] AnyURI OPTIONAL,
       schemaLocation  [ATTRIBUTE] AnyURI OPTIONAL
   }

   AssignmentList ::= SEQUENCE SIZE (1..MAX) OF
       assignment [GROUP] Assignment

   Assignment ::= [NO-INSERTIONS] CHOICE {
       namedType       TypeAssignment,
       namedValue      ValueAssignment,
       namedValueSet   ValueSetTypeAssignment,
       namedClass      ObjectClassAssignment,
       namedObject     ObjectAssignment,

       namedObjectSet  ObjectSetAssignment,
       component       [GROUP] TopLevelNamedType
   }

   TypeAssignment ::= SEQUENCE {
       annotation  Annotation OPTIONAL,
       name        [ATTRIBUTE] TypeReference,
       type        [GROUP] Type
   }

   TypeReference ::= UTF8String (PATTERN "[A-Z]\w*(-\w+)*")
                                 -- \w is equivalent to [a-zA-Z0-9]

   ValueAssignment ::= SEQUENCE {
       annotation  Annotation OPTIONAL,
       name        [ATTRIBUTE] ValueReference,
       type        [GROUP] Type,
       value       [GROUP] Value
   }

   ValueReference ::= Identifier

   Identifier ::= UTF8String (PATTERN "[a-z]\w(-\w+)*")

   ValueSetTypeAssignment ::= SEQUENCE {
       annotation  Annotation OPTIONAL,
       name        [ATTRIBUTE] TypeReference,
       type        [GROUP] Type,
       valueSet    [GROUP] ValueSet
   }

   ObjectClassAssignment ::= SEQUENCE {
       annotation   Annotation OPTIONAL,
       name         [ATTRIBUTE] ObjectClassReference,
       objectClass  [GROUP] ObjectClass
   }

   ObjectClassReference ::= UTF8String
                                (PATTERN "[A-Z][A-Z0-9]*(-[A-Z0-9]+)*")

   ObjectAssignment ::= SEQUENCE {
       annotation   Annotation OPTIONAL,
       name         [ATTRIBUTE] ObjectReference,
       objectClass  [GROUP] DefinedObjectClass,
       object       [GROUP] Object
   }

   ObjectReference ::= ValueReference

   ObjectSetAssignment ::= SEQUENCE {
       annotation   Annotation OPTIONAL,
       name         [ATTRIBUTE] ObjectSetReference,
       objectClass  [GROUP] DefinedObjectClass,
       objectSet    [GROUP] ObjectSet
   }

   ObjectSetReference ::= TypeReference

   TopLevelNamedType ::= NamedType
       (WITH COMPONENTS { ...,
           component (WITH COMPONENTS { ...,
               definition (WITH COMPONENTS { ..., reference ABSENT })
           }),
           element   (WITH COMPONENTS { ...,
               definition (WITH COMPONENTS { ..., reference ABSENT })
           }),
           attribute (WITH COMPONENTS { ...,
               definition (WITH COMPONENTS { ..., reference ABSENT })
           }),
           group         ABSENT,
           member        ABSENT,
           item          ABSENT,
           simpleContent ABSENT })

   NamedType ::= [SINGULAR-INSERTIONS] CHOICE {
       component      Element,
       element        Element,
       attribute      Attribute,
       group          InvisibleNamedType,
       member         InvisibleNamedType,
       item           InvisibleNamedType,
       simpleContent  InvisibleNamedType
   }

   Attribute ::= GenericNamedType
       (WITH COMPONENTS { ...,
           definition (WITH COMPONENTS { ...,
               local (WITH COMPONENTS { ...,
                   typeAsVersion ABSENT }) }) })

   Element ::= GenericNamedType
       (WITH COMPONENTS { ...,
           definition (WITH COMPONENTS { ...,
               local (WITH COMPONENTS { ...,
                   versionIndicator ABSENT }) }) })

   InvisibleNamedType ::= GenericNamedType
       (WITH COMPONENTS { ...,
           definition (WITH COMPONENTS { ...,
               reference  ABSENT,
               local (WITH COMPONENTS { ...,
                   typeAsVersion ABSENT,
                   versionIndicator ABSENT }) }) })

   GenericNamedType ::= [HOLLOW-INSERTIONS] SEQUENCE {
       annotation  Annotation OPTIONAL,
       identifier  [ATTRIBUTE] IdentifierOrEmpty OPTIONAL,
       definition  [GROUP] CHOICE {
           reference   [GROUP] DefinedComponent,
           local       [GROUP] LocalComponent
       }
   }

   IdentifierOrEmpty ::= UTF8String (INCLUDES Identifier | "")

   DefinedComponent ::= [HOLLOW-INSERTIONS] SEQUENCE {
       name         [GROUP] [NO-INSERTIONS] CHOICE {
           ref          [ATTRIBUTE] QName,
           elementType  [ATTRIBUTE] Name
       },
       namespace    [ATTRIBUTE] AnyURI OPTIONAL,
       context      [ATTRIBUTE] AnyURI OPTIONAL,
       embedded     [ATTRIBUTE] BOOLEAN OPTIONAL,
       prefixes     [GROUP] EncodingPrefixes OPTIONAL
   }
   (WITH COMPONENTS { ...,
        name (WITH COMPONENTS { ref PRESENT }),
        namespace ABSENT } |
    WITH COMPONENTS { ...,
        name (WITH COMPONENTS { elementType PRESENT }),
        embedded ABSENT })

   LocalComponent ::= SEQUENCE {
       name              [ATTRIBUTE] NCName,
       typeAsVersion     [ATTRIBUTE] BOOLEAN OPTIONAL,
       versionIndicator  [ATTRIBUTE] BOOLEAN OPTIONAL,
       type              [GROUP] Type
   }

   Type ::= [NO-INSERTIONS] CHOICE {
       typeRef  [NAME AS "type"] [ATTRIBUTE] QName,
       type     ElementFormType
   }

   ElementFormType ::= [HOLLOW-INSERTIONS] SEQUENCE {
       annotation  Annotation OPTIONAL,
       explicit    [ATTRIBUTE] BOOLEAN OPTIONAL,
       definition  [GROUP] CHOICE {
           reference        [GROUP] DefinedType,
           expanded         ExpandedType,
           ancestor         [ATTRIBUTE] INTEGER (1..MAX),
           namedBitList     NamedBitList,
           namedNumberList  NamedNumberList,
           enumerated       EnumeratedType,
           tagged           TaggedType,
           prefixed         EncodingPrefixedType,
           selection        SelectionType,
           instanceOf       InstanceOfType,
           fromClass        ObjectClassFieldType,
           fromObjects      InformationFromObjects,
           sequence         SequenceType,
           set              SetType,
           choice           ChoiceType,
           union            UnionType,
           sequenceOf       SequenceOfType,
           setOf            SetOfType,
           list             ListType,
           constrained      ConstrainedType
       }
   }

   DefinedType ::= SEQUENCE {
       name       [GROUP] [NO-INSERTIONS] CHOICE {
           ref          [ATTRIBUTE] QName,
           elementType  [ATTRIBUTE] Name
       },
       context    [ATTRIBUTE] AnyURI OPTIONAL,
       embedded   [ATTRIBUTE] BOOLEAN OPTIONAL
   }
   (WITH COMPONENTS { ...,
        name (WITH COMPONENTS { ref PRESENT }) } |
    WITH COMPONENTS { ...,
        name (WITH COMPONENTS { elementType PRESENT }),
        embedded ABSENT })

   ExpandedType ::= SEQUENCE {
       name    [ATTRIBUTE] NCName OPTIONAL,
       module  ReferencedModule OPTIONAL,
       type    [GROUP] Type
   }

   ReferencedModule ::= SEQUENCE {

       name            [ATTRIBUTE] ModuleReference OPTIONAL,
       identifier      [ATTRIBUTE] DefinitiveIdentifier OPTIONAL,
       schemaIdentity  [ATTRIBUTE] AnyURI OPTIONAL
   }

   NamedBitList ::= SEQUENCE SIZE (1..MAX) OF namedBit NamedBit

   NamedBit ::= SEQUENCE {
       name        [ATTRIBUTE] NCName,
       identifier  [ATTRIBUTE] Identifier OPTIONAL,
       bit         [ATTRIBUTE] INTEGER (0..MAX)
   }

   NamedNumberList ::= SEQUENCE SIZE (1..MAX) OF
       namedNumber NamedNumber

   NamedNumber ::= SEQUENCE {
       name        [ATTRIBUTE] NCName,
       identifier  [ATTRIBUTE] Identifier OPTIONAL,
       number      [ATTRIBUTE] INTEGER
   }

   EnumeratedType ::= SEQUENCE {
       root       [GROUP] Enumeration,
       extension  SEQUENCE {
           exception  ExceptionSpec OPTIONAL,
           additions  [GROUP] Enumeration OPTIONAL
       } OPTIONAL
   }

   Enumeration ::= SEQUENCE SIZE (1..MAX) OF
       enumeration EnumerationItem

   EnumerationItem ::= SEQUENCE {
       name        [ATTRIBUTE] NCName,
       identifier  [ATTRIBUTE] Identifier OPTIONAL,
       number      [ATTRIBUTE] INTEGER OPTIONAL
   }

   Tag ::= SEQUENCE {
       tagClass  [ATTRIBUTE] TagClass OPTIONAL,
       number    [ATTRIBUTE] INTEGER (0..MAX),
       tagging   [ATTRIBUTE] Tagging OPTIONAL
   }

   TaggedType ::= SEQUENCE {
       COMPONENTS OF Tag,
       type  [GROUP] Type

   }

   TagClass ::= ENUMERATED { universal, application, private }

   Tagging ::= ENUMERATED { explicit, implicit }

   EncodingPrefixedType ::= [HOLLOW-INSERTIONS] SEQUENCE {
       prefixes  [GROUP] EncodingPrefixes,
       type      [GROUP] Type
   }

   EncodingPrefixes ::= SEQUENCE SIZE (1..MAX) OF
       prefix [GROUP] EncodingPrefix

   EncodingPrefix ::= [SINGULAR-INSERTIONS] CHOICE {
       tag   [NAME AS "TAG"] Tag,
       gser  [NAME AS "GSER"] GSER-EncodingInstruction,
       xer   [NAME AS "XER"] XER-EncodingInstruction
       -- plus encoding instructions
       -- for other encoding rules in the future
   }

   SelectionType ::= SEQUENCE {
       alternative  [GROUP] [SINGULAR-INSERTIONS] CHOICE {
           component    [ATTRIBUTE] QName,
           element      [ATTRIBUTE] QName,
           attribute    [ATTRIBUTE] QName,
           group        [ATTRIBUTE] QName,
           member       [ATTRIBUTE] QName
       },
       type         [GROUP] Type
   }

   InstanceOfType ::= DefinedObjectClass

   ObjectClassFieldType ::= SEQUENCE {
       objectClass  [GROUP] DefinedObjectClass,
       fieldName    [GROUP] FieldName
   }

   FieldName ::= [SINGULAR-INSERTIONS] CHOICE {
       fieldNameAtt  [NAME AS "fieldName"]
                         [ATTRIBUTE] PrimitiveFieldNames,
       fieldName     PrimitiveFieldNames
   }

   PrimitiveFieldNames ::= UTF8String

   InformationFromObjects ::= [HOLLOW-INSERTIONS] SEQUENCE {
       referencedObjects  [GROUP] ReferencedObjects,
       fieldName          [GROUP] FieldName
   }

   ReferencedObjects ::= [SINGULAR-INSERTIONS] CHOICE {
       object     [GROUP] Object,
       objectSet  [GROUP] ObjectSet
   }

   Insertions ::=
       ENUMERATED { none, hollow, singular, uniform, multiform }

   SequenceType ::= [HOLLOW-INSERTIONS] SEQUENCE {
       insertions         [ATTRIBUTE] Insertions OPTIONAL,
       root               [GROUP] ComponentTypeList OPTIONAL,
       extensionAndFinal  [GROUP] [HOLLOW-INSERTIONS] SEQUENCE {
           extension          [HOLLOW-INSERTIONS] SEQUENCE {
               exception          ExceptionSpec OPTIONAL,
               additions          [GROUP] ExtensionAdditions OPTIONAL
           },
           root               [GROUP] ComponentTypeList OPTIONAL
       } OPTIONAL
   }

   ComponentTypeList ::= SEQUENCE SIZE (1..MAX) OF
       componentType [GROUP] ComponentType

   ComponentType ::= [NO-INSERTIONS] CHOICE {
       component     [GROUP] SequenceNamedType,
       optional      SEQUENCE {
           component     [GROUP] SequenceNamedType,
           default       Value OPTIONAL
       },
       componentsOf  Type
   }

   SequenceNamedType ::= NamedType
       (WITH COMPONENTS { ..., member ABSENT, item ABSENT })

   ExtensionAdditions ::= SEQUENCE SIZE (1..MAX) OF
       addition [GROUP] ExtensionAddition

   ExtensionAddition ::= [NO-INSERTIONS] CHOICE {
       extensionGroup  ExtensionAdditionGroup,
       componentType   [GROUP] ComponentType
   }

   ExtensionAdditionGroup ::= [HOLLOW-INSERTIONS] SEQUENCE {
       version         [ATTRIBUTE] VersionNumber OPTIONAL,
       componentTypes  [GROUP] ComponentTypeList
   }

   VersionNumber ::= INTEGER (2..MAX)

   SetType ::= SequenceType

   ChoiceOrUnionType ::= [HOLLOW-INSERTIONS] SEQUENCE {
       insertions  [ATTRIBUTE] Insertions OPTIONAL,
       precedence  [ATTRIBUTE] PrecedenceList OPTIONAL,
       root        [GROUP] AlternativeTypeList,
       extension   [HOLLOW-INSERTIONS] SEQUENCE {
           exception   ExceptionSpec OPTIONAL,
           additions   [GROUP] ExtensionAdditionAlternatives OPTIONAL
       } OPTIONAL
   }

   PrecedenceList ::= [LIST] SEQUENCE SIZE (1..MAX) OF member QName

   AlternativeTypeList ::= SEQUENCE SIZE (1..MAX) OF
       component [GROUP] ChoiceOrUnionNamedType

   ChoiceOrUnionNamedType ::= NamedType
       (WITH COMPONENTS { ..., item ABSENT, simpleContent ABSENT })

   ExtensionAdditionAlternatives ::= SEQUENCE SIZE (1..MAX) OF
       addition [GROUP] ExtensionAdditionAlternative

   ExtensionAdditionAlternative ::= [NO-INSERTIONS] CHOICE {
       extensionGroup  ExtensionAdditionAlternativesGroup,
       component       [GROUP] ChoiceOrUnionNamedType
   }

   ExtensionAdditionAlternativesGroup ::= [HOLLOW-INSERTIONS] SEQUENCE {
       version       [ATTRIBUTE] VersionNumber OPTIONAL,
       alternatives  [GROUP] AlternativeTypeList
   }

   ChoiceType ::= ChoiceOrUnionType
       (WITH COMPONENTS { ...,
           precedence ABSENT,
           root (WITH COMPONENT (INCLUDES ChoiceNamedType)),
           extension (WITH COMPONENTS { ...,
               additions (WITH COMPONENT (WITH COMPONENTS { ...,
                   extensionGroup (WITH COMPONENTS { ...,
                       alternatives (WITH COMPONENT

                           (INCLUDES ChoiceNamedType)) }),
                   component (INCLUDES ChoiceNamedType) })) }) })

   ChoiceNamedType ::= ChoiceOrUnionNamedType
       (WITH COMPONENTS { ..., member ABSENT })

   UnionType ::= ChoiceOrUnionType
       (WITH COMPONENTS { ...,
           insertions ABSENT,
           root (WITH COMPONENT (INCLUDES UnionNamedType)),
           extension (WITH COMPONENTS { ...,
               additions (WITH COMPONENT (WITH COMPONENTS { ...,
                   extensionGroup (WITH COMPONENTS { ...,
                       alternatives (WITH COMPONENT
                           (INCLUDES UnionNamedType)) }),
                   component (INCLUDES UnionNamedType) })) }) })

   UnionNamedType ::= ChoiceOrUnionNamedType
       (WITH COMPONENTS { ...,
           component ABSENT,
           element   ABSENT,
           attribute ABSENT,
           group     ABSENT })

   SequenceOfOrListType ::= SEQUENCE {
       minSize    [ATTRIBUTE] INTEGER (0..MAX) OPTIONAL,
       maxSize    [ATTRIBUTE] INTEGER (0..MAX) OPTIONAL,
       component  [GROUP] NamedType
                      (WITH COMPONENTS { ...,
                          attribute     ABSENT,
                          member        ABSENT,
                          simpleContent ABSENT })
   }

   SequenceOfType ::= SequenceOfOrListType
       (WITH COMPONENTS { ...,
           component (WITH COMPONENTS { ..., item ABSENT }) })

   SetOfType ::= SequenceOfType

   ListType ::= SequenceOfOrListType
       (WITH COMPONENTS { ...,
           component (WITH COMPONENTS { ...,
                         component ABSENT,
                         element   ABSENT,
                         group     ABSENT }) })

   ConstrainedType ::= [HOLLOW-INSERTIONS] SEQUENCE {

       type        [GROUP] Type,
       constraint  [GROUP] Constraint
   }

   Constraint ::= SEQUENCE {
       constraintSpec  [GROUP] [NO-INSERTIONS] CHOICE {
           subtype         [GROUP] ElementSetSpecs,
           constrainedBy   UserDefinedConstraint,
           table           TableConstraint,
           contents        ContentsConstraint
       },
       exception       ExceptionSpec OPTIONAL
   }

   UserDefinedConstraint ::= [HOLLOW-INSERTIONS] SEQUENCE {
       annotation  Annotation OPTIONAL,
       parameters  [GROUP] ConstraintParameters OPTIONAL
   }

   ConstraintParameters ::= SEQUENCE SIZE (1..MAX) OF
       parameter [GROUP] UserDefinedConstraintParameter

   UserDefinedConstraintParameter ::= [SINGULAR-INSERTIONS] CHOICE {
       valueParameter      SEQUENCE {
           type                [GROUP] Type,
           value               [GROUP] Value
       },
       valueSetParameter   SEQUENCE {
           type                [GROUP] Type,
           valueSet            [GROUP] ValueSet
       },
       objectParameter     SEQUENCE {
           objectClass         [GROUP] DefinedObjectClass,
           object              [GROUP] Object
       },
       objectSetParameter  SEQUENCE {
           objectClass         [GROUP] DefinedObjectClass,
           objectSet           [GROUP] ObjectSet
       },
       typeParameter       SEQUENCE {
           type                [GROUP] Type
       },
       classParameter      SEQUENCE {
           objectClass         [GROUP] DefinedObjectClass
       }
   }

   TableConstraint ::= SEQUENCE {

       objectSet          [GROUP] ObjectSet,
       componentRelation  [GROUP] AtNotations OPTIONAL
   }

   AtNotations ::= SEQUENCE SIZE (1..MAX) OF
       restrictBy AtNotation

   AtNotation ::= Markup

   ContentsConstraint ::= SEQUENCE {
       containing  Type OPTIONAL,
       encodedBy   Value OPTIONAL
   } ((WITH COMPONENTS { ..., containing PRESENT }) |
      (WITH COMPONENTS { ..., encodedBy PRESENT }))

   ExceptionSpec ::= SEQUENCE {
       type   [GROUP] Type,
       value  [GROUP] Value
   }

   Value ::= [NO-INSERTIONS] CHOICE {
       literalValueAtt  [NAME AS "literalValue"] [ATTRIBUTE] UTF8String,
       literalValue     ElementFormLiteralValue,
       valueRef         [NAME AS "value"] [ATTRIBUTE] QName,
       value            ElementFormNotationalValue
   }

   ElementFormLiteralValue ::= Markup
   -- If asnx:literal="false" then the governing type of
   -- ElementFormLiteralValue is ElementFormNotationalValue.

   ElementFormNotationalValue ::= [HOLLOW-INSERTIONS] SEQUENCE {
       annotation  Annotation OPTIONAL,
       definition  [GROUP] [NO-INSERTIONS] CHOICE {
           reference      [GROUP] Reference,
           expanded       ExpandedValue,
           fromObjects    InformationFromObjects,
           openTypeValue  SEQUENCE {
               type           [GROUP] Type,
               value          [GROUP] Value
           },
           components     [GROUP] ComponentValueList
       }
   }

   Reference ::= SEQUENCE {
       ref      [ATTRIBUTE] QName,
       context  [ATTRIBUTE] AnyURI OPTIONAL

   }

   ExpandedValue ::= SEQUENCE {
       name    [ATTRIBUTE] NCName OPTIONAL,
       module  ReferencedModule OPTIONAL,
       value   [GROUP] Value
   }

   ComponentValueList ::= SEQUENCE SIZE (1..MAX) OF
       component [GROUP] NamedValue

   NamedValue ::= [SINGULAR-INSERTIONS] CHOICE {
       component      GenericNamedValue,
       element        GenericNamedValue,
       attribute      GenericNamedValue,
       group          GenericNamedValue,
       member         GenericNamedValue,
       item           GenericNamedValue,
       simpleContent  GenericNamedValue
   }

   GenericNamedValue ::= SEQUENCE {
       name   [ATTRIBUTE] QName,
       value  [GROUP] Value
   }

   ValueSet ::= [NO-INSERTIONS] CHOICE {
       valueSetRef  [NAME AS "valueSet"] [ATTRIBUTE] QName,
           -- valueSetRef is not used in this version
       valueSet     ElementFormValueSet
   }

   ElementFormValueSet ::= [HOLLOW-INSERTIONS] SEQUENCE {
       annotation  Annotation OPTIONAL,
       definition  [GROUP] [NO-INSERTIONS] CHOICE {
           elementSetSpecs  [GROUP] ElementSetSpecs
       }
   }

   ElementSetSpecs ::= [HOLLOW-INSERTIONS] SEQUENCE {
       root       [GROUP] ValueElementSetSpec,
       extension  [HOLLOW-INSERTIONS] SEQUENCE {
           additions  [GROUP] ValueElementSetSpec OPTIONAL
       } OPTIONAL
   }

   ValueElementSetSpec ::= ElementSetSpec
   (WITH COMPONENTS { ...,

       object        ABSENT,
       objectSet     ABSENT,
       union         (WITH COMPONENT (INCLUDES ValueElementSetSpec)),
       intersection  (WITH COMPONENT (INCLUDES ValueElementSetSpec)),
       all           (WITH COMPONENTS { ...,
           elements      (INCLUDES ValueElementSetSpec),
           except        (INCLUDES ValueElementSetSpec) }) })

   ElementSetSpec ::= [SINGULAR-INSERTIONS] CHOICE {
       literalValue    ElementFormLiteralValue,
       value           ElementFormNotationalValue,
       includes        Type,
       range           ValueRange,
       size            Constraint,
       typeConstraint  Type,
       from            Constraint,
       withComponent   Constraint,
       withComponents  MultipleTypeConstraints,
       pattern         Value,
       object          ElementFormObject,
       objectSet       ElementFormObjectSet,
       union           ElementSetSpecList,
       intersection    ElementSetSpecList,
       all             SEQUENCE {
           elements        [GROUP] ElementSetSpec OPTIONAL,
           except          ElementSetSpec
       }
   }

   ElementSetSpecList ::= SEQUENCE SIZE (2..MAX) OF
       elements [GROUP] ElementSetSpec

   ValueRange ::= SEQUENCE {
       minimum  [GROUP] [NO-INSERTIONS] CHOICE {
           minInclusive  EndValue,
           minExclusive  EndValue
       } DEFAULT minInclusive:{},
       maximum  [GROUP] [NO-INSERTIONS] CHOICE {
           maxInclusive  EndValue,
           maxExclusive  EndValue
       } DEFAULT maxInclusive:{}
   }

   EndValue ::= [HOLLOW-INSERTIONS] SEQUENCE {
       value  [GROUP] Value OPTIONAL
   }

   MultipleTypeConstraints ::= [HOLLOW-INSERTIONS] SEQUENCE {

       partial          [ATTRIBUTE] BOOLEAN DEFAULT FALSE,
       typeConstraints  [GROUP] TypeConstraints
   }

   TypeConstraints ::= SEQUENCE SIZE (1..MAX) OF
       namedConstraint [GROUP] NamedConstraint

   NamedConstraint ::= [SINGULAR-INSERTIONS] CHOICE {
       component      GenericNamedConstraint,
       element        GenericNamedConstraint,
       attribute      GenericNamedConstraint,
       group          GenericNamedConstraint,
       member         GenericNamedConstraint,
       item           GenericNamedConstraint,
       simpleContent  GenericNamedConstraint
   }

   GenericNamedConstraint ::= [HOLLOW-INSERTIONS] SEQUENCE {
       name        [ATTRIBUTE] QName,
       use         [ATTRIBUTE] PresenceConstraint OPTIONAL,
       constraint  [GROUP] Constraint OPTIONAL
   }

   PresenceConstraint ::= ENUMERATED { present, absent, optional }

   ObjectClass ::= [SINGULAR-INSERTIONS] CHOICE {
       classRef  [NAME AS "class"] [ATTRIBUTE] QName,
       class     ElementFormObjectClass
   }

   DefinedObjectClass ::= ObjectClass
       (WITH COMPONENTS { ...,
           class (WITH COMPONENTS { ...,
               definition (WITH COMPONENTS { ...,
                   objectClassDefn ABSENT }) }) })

   ElementFormObjectClass ::= [HOLLOW-INSERTIONS] SEQUENCE {
       annotation  Annotation OPTIONAL,
       definition  [GROUP] [NO-INSERTIONS] CHOICE {
           reference        [GROUP] Reference,
           expanded         ExpandedObjectClass,
           objectClassDefn  [GROUP] ObjectClassDefn
       }
   }

   ExpandedObjectClass ::= SEQUENCE {
       name         [ATTRIBUTE] NCName OPTIONAL,
       module       ReferencedModule OPTIONAL,

       objectClass  [GROUP] ObjectClass
   }

   ObjectClassDefn ::= SEQUENCE SIZE (1..MAX) OF
       fieldSpec [GROUP] FieldSpec

   FieldSpec ::= [SINGULAR-INSERTIONS] CHOICE {
       typeField       TypeField,
       valueField      ValueField,
       valueSetField   ValueSetField,
       objectField     ObjectField,
       objectSetField  ObjectSetField,
       optional        OptionalField
   }

   OptionalField ::= SEQUENCE {
       field    [GROUP] [SINGULAR-INSERTIONS] CHOICE {
           typeField       TypeField,
           valueField      ValueField,
           valueSetField   ValueSetField,
           objectField     ObjectField,
           objectSetField  ObjectSetField
       },
       default  Setting OPTIONAL
   } (WITH COMPONENTS { ...,
         field (WITH COMPONENTS { typeField PRESENT }),
         default (WITH COMPONENTS { ...,
             value ABSENT,
             valueSet ABSENT,
             object ABSENT,
             objectSet ABSENT }) } |
      WITH COMPONENTS { ...,
         field (WITH COMPONENTS { valueField PRESENT }),
         default (WITH COMPONENTS { ...,
             type ABSENT,
             valueSet ABSENT,
             object ABSENT,
             objectSet ABSENT }) } |
      WITH COMPONENTS { ...,
         field (WITH COMPONENTS { valueSetField PRESENT }),
         default (WITH COMPONENTS { ...,
             type ABSENT,
             value ABSENT,
             object ABSENT,
             objectSet ABSENT }) } |
      WITH COMPONENTS { ...,
         field (WITH COMPONENTS { objectField PRESENT }),
         default (WITH COMPONENTS { ...,

             type ABSENT,
             value ABSENT,
             valueSet ABSENT,
             objectSet ABSENT }) } |
      WITH COMPONENTS { ...,
         field (WITH COMPONENTS { objectSetField PRESENT }),
         default (WITH COMPONENTS { ...,
             type ABSENT,
             value ABSENT,
             valueSet ABSENT,
             object ABSENT }) })

   TypeField ::= SEQUENCE {
       annotation  Annotation OPTIONAL,
       name        [ATTRIBUTE] TypeFieldReference
   }

   TypeFieldReference ::= TypeReference

   ValueField ::= SEQUENCE {
       annotation  Annotation OPTIONAL,
       name        [ATTRIBUTE] ValueFieldReference,
       unique      [ATTRIBUTE] BOOLEAN OPTIONAL,
       governor    [GROUP] [SINGULAR-INSERTIONS] CHOICE {
           type           [GROUP] Type,
           typeFromField  FieldName
       }
   } ((WITH COMPONENTS { ..., unique ABSENT }) |
      (WITH COMPONENTS { ...,
          governor (WITH COMPONENTS { ..., typeFromField ABSENT }) }))

   ValueFieldReference ::= ValueReference

   ValueSetField ::= SEQUENCE {
       annotation  Annotation OPTIONAL,
       name        [ATTRIBUTE] ValueSetFieldReference,
       governor    [GROUP] [SINGULAR-INSERTIONS] CHOICE {
           type           [GROUP] Type,
           typeFromField  FieldName
       }
   }

   ValueSetFieldReference ::= TypeReference

   ObjectField ::= SEQUENCE {
       annotation   Annotation OPTIONAL,
       name         [ATTRIBUTE] ObjectFieldReference,
       objectClass  [GROUP] DefinedObjectClass

   }

   ObjectFieldReference ::= ObjectReference

   ObjectSetField ::= SEQUENCE {
       annotation   Annotation OPTIONAL,
       name         [ATTRIBUTE] ObjectSetFieldReference,
       objectClass  [GROUP] DefinedObjectClass
   }

   ObjectSetFieldReference ::= ObjectSetReference

   Object ::= [NO-INSERTIONS] CHOICE {
       objectRef  [NAME AS "object"] [ATTRIBUTE] QName,
       object     ElementFormObject
   }

   ElementFormObject ::= [HOLLOW-INSERTIONS] SEQUENCE {
       annotation  Annotation OPTIONAL,
       definition  [GROUP] [SINGULAR-INSERTIONS] CHOICE {
           reference    [GROUP] Reference,
           expanded     ExpandedObject,
           fromObjects  InformationFromObjects,
           fields       [GROUP] ObjectDefn
       }
   }

   ExpandedObject ::= SEQUENCE {
       name    [ATTRIBUTE] NCName OPTIONAL,
       module  ReferencedModule OPTIONAL,
       object  [GROUP] Object
   }

   ObjectDefn ::= SEQUENCE OF field FieldSetting

   FieldSetting ::= [HOLLOW-INSERTIONS] SEQUENCE {
       name     [ATTRIBUTE] NCName,
       setting  [GROUP] Setting
   }

   Setting ::= CHOICE {
       type       [GROUP] Type,
       value      [GROUP] Value,
       valueSet   [GROUP] ValueSet,
       object     [GROUP] Object,
       objectSet  [GROUP] ObjectSet
   }

   ObjectSet ::= [NO-INSERTIONS] CHOICE {
       objectSetRef  [NAME AS "objectSet"] [ATTRIBUTE] QName,
       objectSet     ElementFormObjectSet
   }

   ElementFormObjectSet ::= [HOLLOW-INSERTIONS] SEQUENCE {
       annotation  Annotation OPTIONAL,
       definition  [GROUP] [NO-INSERTIONS] CHOICE {
           reference      [GROUP] Reference,
           expanded       ExpandedObjectSet,
           objectSetSpec  [GROUP] ObjectSetSpec,
           fromObjects    InformationFromObjects
       }
   }

   ExpandedObjectSet ::= SEQUENCE {
       name       [ATTRIBUTE] NCName OPTIONAL,
       module     ReferencedModule OPTIONAL,
       objectSet  [GROUP] ObjectSet
   }

   ObjectSetSpec ::= [HOLLOW-INSERTIONS] SEQUENCE {
       root       [GROUP] ObjectElementSetSpec OPTIONAL,
       extension  [HOLLOW-INSERTIONS] SEQUENCE {
           additions  [GROUP] ObjectElementSetSpec OPTIONAL
       } OPTIONAL
   } ((WITH COMPONENTS { ..., root PRESENT }) |
      (WITH COMPONENTS { ..., extension PRESENT }))

   ObjectElementSetSpec ::= ElementSetSpec
   (WITH COMPONENTS { ...,
       literalValue    ABSENT,
       value           ABSENT,
       includes        ABSENT,
       range           ABSENT,
       size            ABSENT,
       typeConstraint  ABSENT,
       from            ABSENT,
       withComponent   ABSENT,
       withComponents  ABSENT,
       pattern         ABSENT,
       union           (WITH COMPONENT (INCLUDES ObjectElementSetSpec)),
       intersection    (WITH COMPONENT (INCLUDES ObjectElementSetSpec)),
       all             (WITH COMPONENTS { ...,
           elements        (INCLUDES ObjectElementSetSpec),
           except          (INCLUDES ObjectElementSetSpec) }) })

   EncodingControlSections ::= SEQUENCE SIZE (1..MAX) OF

       section [GROUP] EncodingControlSection

   EncodingControlSection ::= [SINGULAR-INSERTIONS] CHOICE {
       gser  [NAME AS "GSER"] GSER-EncodingInstructionAssignmentList,
       xer   [NAME AS "XER"] XER-EncodingInstructionAssignmentList
       -- plus encoding control sections
       -- for other encoding rules in the future
   }

   ENCODING-CONTROL RXER

       SCHEMA-IDENTITY  "urn:oid:1.3.6.1.4.1.21472.1.0.1"
       TARGET-NAMESPACE "urn:ietf:params:xml:ns:asnx" PREFIX "asnx"

       COMPONENT module ModuleDefinition

       COMPONENT literal [ATTRIBUTE] BOOLEAN

   END