-- This ASN definition is taken from
-- http://132.151.1.19/internet-drafts/draft-ietf-megaco-h248v2-04.txt
--
-- and has been modified to pass through the ASN2ETH compiler
-- (we dont support automatic tags yet so the tags had to be added by
--  hand)

MEDIA-GATEWAY-CONTROL {itu-t(0) recommendation(0) h(8) h248(248) 
modules(0) media-gateway-control(0) version2(2)} 
DEFINITIONS AUTOMATIC TAGS ::= 
BEGIN 
       
      MegacoMessage ::= SEQUENCE 
      { 
         authHeader     [0] IMPLICIT AuthenticationHeader OPTIONAL, 
         mess           [1] IMPLICIT Message 
      } 
       
      AuthenticationHeader ::= SEQUENCE 
      { 
         secParmIndex   [0] IMPLICIT SecurityParmIndex, 
         seqNum         [1] IMPLICIT SequenceNum, 
         ad             [2] IMPLICIT AuthData 
      } 
       
      SecurityParmIndex ::= OCTET STRING(SIZE(4)) 
       
      SequenceNum       ::= OCTET STRING(SIZE(4)) 
       
      AuthData          ::= OCTET STRING (SIZE (12..32)) 
       
      Message ::= SEQUENCE 
      { 
         version           [0] IMPLICIT INTEGER(0..99), 
         -- The version of the protocol defined here is equal to 2. 
         mId               [1] MId,  -- Name/address of message originator 
         messageBody       [2] CHOICE 
         { 
            messageError      [0] IMPLICIT ErrorDescriptor, 
            transactions      [1] IMPLICIT SEQUENCE OF Transaction 
         }, 
         ... 
      } 
       
      MId ::= CHOICE 
      { 
         ip4Address           [0] IMPLICIT IP4Address, 
         ip6Address           [1] IMPLICIT IP6Address, 
         domainName           [2] IMPLICIT DomainName, 
         deviceName           [3] IMPLICIT PathName, 
         mtpAddress           [4] IMPLICIT MtpAddress, 
          -- Addressing structure of mtpAddress: 
          --     25 - 15              0 
          --     |  PC           | NI | 
          --     24 - 14 bits    2 bits 
      -- Note: 14 bits are defined for international use. 
      -- Two national options exist where the point code is 16 or 24   
       -- bits. 
       -- To octet align the mtpAddress, the MSBs shall be encoded as 0s. 
         ... 
      } 
       
      MtpAddress ::= OCTET STRING(SIZE(2..4))

      DomainName ::= SEQUENCE 
      { 
         name           [0] IMPLICIT IA5String, 
         -- The name starts with an alphanumeric digit followed by a 
         -- sequence of alphanumeric digits, hyphens and dots.  No two 
         -- dots shall occur consecutively. 
         portNumber     [1] IMPLICIT INTEGER(0..65535) OPTIONAL 
      } 
       
      IP4Address ::= SEQUENCE 
      { 
         address        [0] IMPLICIT OCTET STRING (SIZE(4)), 
         portNumber     [1] IMPLICIT INTEGER(0..65535) OPTIONAL 
      } 
       
      IP6Address ::= SEQUENCE 
      { 
         address        [0] IMPLICIT OCTET STRING (SIZE(16)), 
         portNumber     [1] IMPLICIT INTEGER(0..65535) OPTIONAL 
      } 
       
      PathName ::= IA5String(SIZE (1..64)) 
      -- See A.3 

      Transaction ::= CHOICE 
      { 
         transactionRequest      [0] IMPLICIT TransactionRequest, 
         transactionPending      [1] IMPLICIT TransactionPending, 
         transactionReply        [2] IMPLICIT TransactionReply, 
         transactionResponseAck  [3] IMPLICIT TransactionResponseAck, 
            -- use of response acks is dependent on underlying transport 
         ... 
      } 
       
      TransactionId ::= INTEGER(0..4294967295)  -- 32-bit unsigned integer 
       
      TransactionRequest ::= SEQUENCE 
      { 
         transactionId        [0] IMPLICIT TransactionId, 
         actions              [1] IMPLICIT SEQUENCE OF ActionRequest, 
         ... 
      } 
       
      TransactionPending ::= SEQUENCE 
      { 
         transactionId        [0] IMPLICIT TransactionId, 
         ... 
      } 
       
      TransactionReply ::= SEQUENCE 
      { 
         transactionId        [0] IMPLICIT TransactionId, 
         immAckRequired       [1] IMPLICIT NULL OPTIONAL, 
         transactionResult    [2] CHOICE 
         { 
              transactionError   [0] IMPLICIT ErrorDescriptor, 
              actionReplies      [1] IMPLICIT SEQUENCE OF ActionReply 
         }, 
         ... 
      } 
       
      TransactionResponseAck ::= SEQUENCE OF TransactionAck 
      TransactionAck ::= SEQUENCE 
      { 
         firstAck       [0] IMPLICIT TransactionId, 
         lastAck        [1] IMPLICIT TransactionId OPTIONAL 
      } 
       
      ErrorDescriptor ::= SEQUENCE 
      { 
         errorCode      [0] IMPLICIT ErrorCode, 
         errorText      [1] IMPLICIT ErrorText OPTIONAL 
      } 
       
      ErrorCode ::= INTEGER(0..65535) 
      -- See clause 14 for IANA considerations with respect to error codes 
    
      ErrorText ::= IA5String 
       
      ContextID ::= INTEGER(0..4294967295) 
       
      -- Context NULL Value: 0 
      -- Context CHOOSE Value: 4294967294 (0xFFFFFFFE)  
      -- Context ALL Value: 4294967295 (0xFFFFFFFF) 
       
       
      ActionRequest ::= SEQUENCE 
      { 
         contextId            [0] IMPLICIT ContextID, 
         contextRequest       [1] IMPLICIT ContextRequest OPTIONAL, 
         contextAttrAuditReq  [2] IMPLICIT ContextAttrAuditRequest OPTIONAL, 
         commandRequests      [3] IMPLICIT SEQUENCE OF CommandRequest 
      } 
       
      ActionReply ::= SEQUENCE 
      { 
         contextId         [0] IMPLICIT ContextID, 
         errorDescriptor   [1] IMPLICIT ErrorDescriptor OPTIONAL, 
         contextReply      [2] IMPLICIT ContextRequest OPTIONAL, 
         commandReply      [3] IMPLICIT SEQUENCE OF CommandReply 
      } 
       
      ContextRequest ::= SEQUENCE 
      { 
         priority       [0] IMPLICIT INTEGER(0..15) OPTIONAL, 
         emergency      [1] IMPLICIT BOOLEAN OPTIONAL, 
         topologyReq    [2] IMPLICIT SEQUENCE OF TopologyRequest OPTIONAL, 
         ... 
      } 
       
      ContextAttrAuditRequest ::= SEQUENCE 
      { 
         topology    [0] IMPLICIT NULL OPTIONAL, 
         emergency   [1] IMPLICIT NULL OPTIONAL, 
         priority    [2] IMPLICIT NULL OPTIONAL, 
         ... 
      } 
       
      CommandRequest ::= SEQUENCE 
      { 
         command           [0] Command, 
         optional          [1] IMPLICIT NULL OPTIONAL, 
         wildcardReturn    [2] IMPLICIT NULL OPTIONAL, 
         ... 
      } 

      Command ::= CHOICE 
      { 
         addReq               [0] IMPLICIT AmmRequest, 
         moveReq              [1] IMPLICIT AmmRequest, 
         modReq               [2] IMPLICIT AmmRequest, 
         -- Add, Move, Modify requests have the same parameters 
         subtractReq          [3] IMPLICIT SubtractRequest, 
         auditCapRequest      [4] IMPLICIT AuditRequest, 
         auditValueRequest    [5] IMPLICIT AuditRequest, 
         notifyReq            [6] IMPLICIT NotifyRequest, 
         serviceChangeReq     [7] IMPLICIT ServiceChangeRequest, 
         ... 
      } 

      CommandReply ::= CHOICE 
      { 
         addReply                [0] IMPLICIT AmmsReply, 
         moveReply               [1] IMPLICIT AmmsReply, 
         modReply                [2] IMPLICIT AmmsReply, 
         subtractReply           [3] IMPLICIT AmmsReply, 
         -- Add, Move, Modify, Subtract replies have the same parameters 
         auditCapReply           [4] AuditReply, 
         auditValueReply         [5] AuditReply, 
         notifyReply             [6] IMPLICIT NotifyReply, 
         serviceChangeReply      [7] IMPLICIT ServiceChangeReply, 
         ... 
      } 
       
      TopologyRequest ::= SEQUENCE 
      { 
         terminationFrom         [0] IMPLICIT TerminationID, 
         terminationTo           [1] IMPLICIT TerminationID, 
         topologyDirection       [2] IMPLICIT ENUMERATED 
         { 
            bothway(0), 
            isolate(1), 
            oneway(2) 
         }, 
         ..., 
         streamID             [3] IMPLICIT StreamID OPTIONAL 
      } 
       
      AmmRequest ::= SEQUENCE 
      { 
         terminationID        [0] IMPLICIT TerminationIDList, 
         descriptors          [1] IMPLICIT SEQUENCE OF AmmDescriptor, 
         -- At most one descriptor of each type (see AmmDescriptor) 
         -- allowed in the sequence. 
         ... 
      } 

      AmmDescriptor ::= CHOICE 
      { 
         mediaDescriptor         [0] IMPLICIT MediaDescriptor, 
         modemDescriptor         [1] IMPLICIT ModemDescriptor, 
         muxDescriptor           [2] IMPLICIT MuxDescriptor, 
         eventsDescriptor        [3] IMPLICIT EventsDescriptor, 
         eventBufferDescriptor   [4] IMPLICIT EventBufferDescriptor, 
         signalsDescriptor       [5] IMPLICIT SignalsDescriptor, 
         digitMapDescriptor      [6] IMPLICIT DigitMapDescriptor, 
         auditDescriptor         [7] IMPLICIT AuditDescriptor, 
         ... 
      } 
       
       
      AmmsReply ::= SEQUENCE 
      { 
         terminationID        [0] IMPLICIT TerminationIDList, 
         terminationAudit     [1] IMPLICIT TerminationAudit OPTIONAL, 
         ... 
      } 
       
      SubtractRequest ::= SEQUENCE 
      { 
         terminationID        [0] IMPLICIT TerminationIDList, 
         auditDescriptor      [1] IMPLICIT AuditDescriptor OPTIONAL, 
         ... 
      } 
       
      AuditRequest ::= SEQUENCE 
      { 
         terminationID        [0] IMPLICIT TerminationID, 
         auditDescriptor      [1] IMPLICIT AuditDescriptor, 
         ... 
      } 

      AuditReply ::= CHOICE 
      { 
         contextAuditResult   [0] IMPLICIT TerminationIDList, 
         error                [1] IMPLICIT ErrorDescriptor, 
         auditResult          [2] IMPLICIT AuditResult, 
         ... 
      } 
       
      AuditResult ::= SEQUENCE 
      { 
       
         terminationID           [0] IMPLICIT TerminationID, 
         terminationAuditResult  [1] IMPLICIT TerminationAudit 
      } 
       
       
       
      TerminationAudit ::= SEQUENCE OF AuditReturnParameter 

      AuditReturnParameter ::= CHOICE 
      { 
         errorDescriptor            [0] IMPLICIT ErrorDescriptor, 
         mediaDescriptor            [1] IMPLICIT MediaDescriptor, 
         modemDescriptor            [2] IMPLICIT ModemDescriptor, 
         muxDescriptor              [3] IMPLICIT MuxDescriptor, 
         eventsDescriptor           [4] IMPLICIT EventsDescriptor, 
         eventBufferDescriptor      [5] IMPLICIT EventBufferDescriptor, 
         signalsDescriptor          [6] IMPLICIT SignalsDescriptor, 
         digitMapDescriptor         [7] IMPLICIT DigitMapDescriptor, 
         observedEventsDescriptor   [8] IMPLICIT ObservedEventsDescriptor, 
         statisticsDescriptor       [9] IMPLICIT StatisticsDescriptor, 
         packagesDescriptor         [10] IMPLICIT PackagesDescriptor, 
         emptyDescriptors           [11] IMPLICIT AuditDescriptor, 
         ... 
      } 
       
      AuditDescriptor ::= SEQUENCE 
      { 
         auditToken  [0] IMPLICIT BIT STRING 
               { 
                  muxToken(0), modemToken(1), mediaToken(2), 
                  eventsToken(3), signalsToken(4), 
                  digitMapToken(5), statsToken(6), 
                  observedEventsToken(7), 
                  packagesToken(8), eventBufferToken(9) 
               } OPTIONAL, 
         ..., 
         auditPropertyToken [1] IMPLICIT SEQUENCE OF IndAuditParameter OPTIONAL 
      } 

      IndAuditParameter ::= CHOICE 
      { 
         indaudmediaDescriptor         [0] IMPLICIT IndAudMediaDescriptor, 
         indaudeventsDescriptor        [1] IMPLICIT IndAudEventsDescriptor, 
         indaudeventBufferDescriptor   [2] IMPLICIT IndAudEventBufferDescriptor, 
         indaudsignalsDescriptor       [3] IndAudSignalsDescriptor, 
         indauddigitMapDescriptor      [4] IMPLICIT IndAudDigitMapDescriptor, 
         indaudstatisticsDescriptor    [5] IMPLICIT IndAudStatisticsDescriptor, 
         indaudpackagesDescriptor      [6] IMPLICIT IndAudPackagesDescriptor, 
         ... 
      } 
       
      IndAudMediaDescriptor ::= SEQUENCE 
      { 
          
         termStateDescr    [0] IMPLICIT IndAudTerminationStateDescriptor OPTIONAL, 
         streams           [1] CHOICE 
               { 
                  oneStream      [0] IMPLICIT IndAudStreamParms, 
                  multiStream    [1] IMPLICIT SEQUENCE OF IndAudStreamDescriptor 
               } OPTIONAL, 
         ... 
      } 
       
      IndAudStreamDescriptor ::= SEQUENCE 
      { 
         streamID                [0] IMPLICIT StreamID, 
         streamParms             [1] IMPLICIT IndAudStreamParms 
      } 
       
      IndAudStreamParms ::= SEQUENCE 
      { 
         localControlDescriptor  [0] IMPLICIT IndAudLocalControlDescriptor OPTIONAL, 
         localDescriptor         [1] IMPLICIT IndAudLocalRemoteDescriptor OPTIONAL, 
         remoteDescriptor        [2] IMPLICIT IndAudLocalRemoteDescriptor OPTIONAL, 
         ... 
      } 
       
      IndAudLocalControlDescriptor ::= SEQUENCE 
      { 
         streamMode              [0] IMPLICIT NULL OPTIONAL, 
         reserveValue            [1] IMPLICIT NULL OPTIONAL, 
         reserveGroup            [2] IMPLICIT NULL OPTIONAL, 
         propertyParms           [3] IMPLICIT IndAudPropertyParms OPTIONAL, 
         ... 
      } 
       
      IndAudPropertyParm ::= SEQUENCE 
      { 
         name     [0] IMPLICIT PkgdName, 
         ... 
      } 

      IndAudPropertyParms ::= SEQUENCE OF IndAudPropertyParm 
       
      IndAudLocalRemoteDescriptor ::= SEQUENCE 
      { 
         propGroupID    [0] IMPLICIT INTEGER(0..65535) OPTIONAL, 
         propGrps       [1] IMPLICIT IndAudPropertyGroup, 
         ... 
      } 
       
      IndAudPropertyGroup ::= SEQUENCE OF IndAudPropertyParm 
       
      IndAudTerminationStateDescriptor ::= SEQUENCE  
      { 
         propertyParms        [0] IMPLICIT IndAudPropertyParms, 
         eventBufferControl   [1] IMPLICIT NULL OPTIONAL, 
         serviceState         [2] IMPLICIT NULL OPTIONAL, 
         ... 
      } 
       
      IndAudEventsDescriptor ::= SEQUENCE 
      { 
         requestID      [0] IMPLICIT RequestID OPTIONAL, 
         pkgdName       [1] IMPLICIT PkgdName, 
         streamID       [2] IMPLICIT StreamID OPTIONAL, 
         ... 
      } 
       
      IndAudEventBufferDescriptor ::= SEQUENCE 
      { 
         eventName   [0] IMPLICIT PkgdName, 
         streamID    [1] IMPLICIT StreamID OPTIONAL, 
         ... 
      } 

      IndAudSignalsDescriptor ::=CHOICE 
      { 
         signal         [0] IMPLICIT IndAudSignal, 
         seqSigList     [1] IMPLICIT IndAudSeqSigList, 
         ... 
      } 
       
      IndAudSeqSigList ::= SEQUENCE 
      { 
         id             [0] IMPLICIT INTEGER(0..65535), 
         signalList     [1] IMPLICIT IndAudSignal OPTIONAL 
      } 
       
      IndAudSignal ::= SEQUENCE 
      { 
         signalName     [0] IMPLICIT PkgdName, 
         streamID       [1] IMPLICIT StreamID OPTIONAL, 
         ... 
      } 
       
      IndAudDigitMapDescriptor ::= SEQUENCE 
      { 
         digitMapName   [0] IMPLICIT DigitMapName OPTIONAL 
      } 
    
      IndAudStatisticsDescriptor ::= SEQUENCE  
      { 
         statName       [0] IMPLICIT PkgdName 
      } 
       
      IndAudPackagesDescriptor ::= SEQUENCE 
      { 
         packageName       [0] IMPLICIT Name, 
         packageVersion    [1] IMPLICIT INTEGER(0..99), 
         ... 
      } 
       
      NotifyRequest ::= SEQUENCE 
      { 
         terminationID              [0] IMPLICIT TerminationIDList, 
         observedEventsDescriptor   [1] IMPLICIT ObservedEventsDescriptor, 
         errorDescriptor            [2] IMPLICIT ErrorDescriptor OPTIONAL, 
         ... 
      } 
       
      NotifyReply ::= SEQUENCE 
      { 
         terminationID           [0] IMPLICIT TerminationIDList, 
         errorDescriptor         [1] IMPLICIT ErrorDescriptor OPTIONAL, 
         ... 
      } 
       
      ObservedEventsDescriptor ::= SEQUENCE 
      { 
         requestId               [0] IMPLICIT RequestID, 
         observedEventLst        [1] IMPLICIT SEQUENCE OF ObservedEvent 
      } 
       
      ObservedEvent ::= SEQUENCE 
      { 
         eventName               [0] IMPLICIT EventName, 
         streamID                [1] IMPLICIT StreamID OPTIONAL, 
         eventParList            [2] IMPLICIT EventParameters, 
         timeNotation            [3] IMPLICIT TimeNotation OPTIONAL, 
         ... 
      } 
       
      EventName ::= OCTET STRING 

      ExtraInfo ::= CHOICE 
      { 
         relation [0] IMPLICIT Relation, 
         range    [1] IMPLICIT BOOLEAN, 
         sublist  [2] IMPLICIT BOOLEAN 
      }
             
      EventParameter ::= SEQUENCE 
      { 
         eventParameterName      [0] IMPLICIT Name, 
         value                   [1] IMPLICIT Value, 
    
         -- For use of extraInfo see the comment related to PropertyParm 
         extraInfo               [2] ExtraInfo OPTIONAL,
         ... 
       
      }

      EventParameters ::= SEQUENCE OF EventParameter

      ServiceChangeRequest ::= SEQUENCE 
      { 
         terminationID           [0] IMPLICIT TerminationIDList, 
         serviceChangeParms      [1] IMPLICIT ServiceChangeParm, 
         ... 
      } 
       
      ServiceChangeReply ::= SEQUENCE 
      { 
         terminationID           [0] IMPLICIT TerminationIDList, 
         serviceChangeResult     [1] ServiceChangeResult, 
         ... 
      } 
       
      -- For ServiceChangeResult, no parameters are mandatory.  Hence the 
      -- distinction between ServiceChangeParm and ServiceChangeResParm. 

      ServiceChangeResult ::= CHOICE 
      { 
         errorDescriptor            [0] IMPLICIT ErrorDescriptor, 
         serviceChangeResParms      [1] IMPLICIT ServiceChangeResParm 
      } 
       
      WildcardField ::= OCTET STRING(SIZE(1)) 
       
      TerminationID ::= SEQUENCE 
      { 
         wildcard       [0] IMPLICIT SEQUENCE OF WildcardField,  
         id             [1] IMPLICIT OCTET STRING(SIZE(1..8)), 
         ... 
      } 
      -- See A.1 for explanation of wildcarding mechanism. 
      -- Termination ID 0xFFFFFFFFFFFFFFFF indicates the ROOT Termination. 
       
      TerminationIDList ::= SEQUENCE OF TerminationID 
       

      MediaDescriptor ::= SEQUENCE 
      { 
         termStateDescr    [0] IMPLICIT TerminationStateDescriptor OPTIONAL, 
         streams           [1] CHOICE 
                  { 
                     oneStream      [0] IMPLICIT StreamParms, 
                     multiStream    [1] IMPLICIT SEQUENCE OF StreamDescriptor 
                  } OPTIONAL, 
         ... 
      } 
       
      StreamDescriptor ::= SEQUENCE 
      { 
         streamID                [0] IMPLICIT StreamID, 
         streamParms             [1] IMPLICIT StreamParms 
      } 
       
      StreamParms ::= SEQUENCE 
      { 
         localControlDescriptor     [0] IMPLICIT LocalControlDescriptor OPTIONAL, 
         localDescriptor            [1] IMPLICIT LocalRemoteDescriptor OPTIONAL, 
         remoteDescriptor           [2] IMPLICIT LocalRemoteDescriptor OPTIONAL, 
         ... 
      } 
       
      LocalControlDescriptor ::= SEQUENCE 
      { 
         streamMode        [0] IMPLICIT StreamMode OPTIONAL, 
         reserveValue      [1] IMPLICIT BOOLEAN OPTIONAL, 
         reserveGroup      [2] IMPLICIT BOOLEAN OPTIONAL, 
         propertyParms     [3] IMPLICIT PropertyParms, 
         ... 
      } 
       
      StreamMode ::= ENUMERATED  
      { 
         sendOnly(0), 
         recvOnly(1), 
         sendRecv(2), 
         inactive(3), 
         loopBack(4), 
            ... 
      } 
       
      -- In PropertyParm, value is a SEQUENCE OF octet string.  When sent 
      -- by an MGC the interpretation is as follows: 
      -- empty sequence means CHOOSE 
      -- one element sequence specifies value 
      -- If the sublist field is not selected, a longer sequence means 
      -- "choose one of the values" (i.e. value1 OR value2 OR ...) 
      -- If the sublist field is selected, 
      -- a sequence with more than one element encodes the value of a 
      -- list-valued property (i.e. value1 AND value2 AND ...). 
      -- The relation field may only be selected if the value sequence 
      -- has length 1.  It indicates that the MG has to choose a value 
      -- for the property. E.g. x > 3 (using the greaterThan 
      -- value for relation) instructs the MG to choose any value larger 
      -- than 3 for property x. 
      -- The range field may only be selected if the value sequence 
      -- has length 2.  It indicates that the MG has to choose a value 
      -- in the range between the first octet in the value sequence and 
      -- the trailing octet in the value sequence, including the 
      -- boundary values. 
      -- When sent by the MG, only responses to an AuditCapability request 
      -- may contain multiple values, a range, or a relation field. 
       
      PropertyParm ::= SEQUENCE 
      { 
         propertyName [0] IMPLICIT PkgdName, 
         value        [1] IMPLICIT SEQUENCE OF PropertyID, 
         extraInfo    [2] ExtraInfo OPTIONAL,
         ... 
      } 

      PropertyParms ::= SEQUENCE OF PropertyParm 
       
      Name ::= OCTET STRING(SIZE(2)) 
       
      PkgdName ::= OCTET STRING(SIZE(4)) 
      -- represents Package Name (2 octets) plus Property, Event, 
      -- Signal Names or Statistics ID. (2 octets) 
      -- To wildcard a package use 0xFFFF for first two octets, choose 
      -- is not allowed. To reference native property tag specified in 
      -- Annex C, use 0x0000 as first two octets. 
      -- To wildcard a Property, Event, Signal, or Statistics ID, use 
      -- 0xFFFF for last two octets, choose is not allowed. 
      -- Wildcarding of Package Name is permitted only if Property, 
      -- Event, Signal, or Statistics ID are 
      -- also wildcarded. 
      PropertyID ::= OCTET STRING 
       
      Relation ::= ENUMERATED 
      { 
         greaterThan(0), 
         smallerThan(1), 
         unequalTo(2), 
         ... 
      } 
       
      LocalRemoteDescriptor ::= SEQUENCE 
      { 
         propGrps [0] IMPLICIT SEQUENCE OF PropertyGroup, 
         ... 
      } 
       
      PropertyGroup ::= SEQUENCE OF PropertyParm 
       
      TerminationStateDescriptor ::= SEQUENCE  
      { 
         propertyParms        [0] IMPLICIT PropertyParms, 
         eventBufferControl   [1] IMPLICIT EventBufferControl OPTIONAL, 
         serviceState         [2] IMPLICIT ServiceState OPTIONAL, 
         ... 
      } 
       
      EventBufferControl ::= ENUMERATED 
      { 
         off(0), 
         lockStep(1), 
         ... 
      } 
       
      ServiceState ::= ENUMERATED 
      { 
         test(0), 
         outOfSvc(1), 
         inSvc(2), 
            ... 
      } 
       
      MuxDescriptor   ::= SEQUENCE 
      { 
         muxType           [0] IMPLICIT MuxType, 
         termList          [1] IMPLICIT SEQUENCE OF TerminationID, 
         nonStandardData   [2] IMPLICIT NonStandardData OPTIONAL, 
         ... 
      } 
       
      MuxType ::= ENUMERATED 
      { 
         h221(0), 
         h223(1), 
         h226(2), 
         v76(3), 
         ..., 
         nx64k(4) 
      } 
       
      StreamID ::= INTEGER(0..65535)   -- 16-bit unsigned integer 
       
      EventsDescriptor ::= SEQUENCE 
      { 
         requestID      [0] IMPLICIT RequestID OPTIONAL, 
                     -- RequestID must be present if eventList 
                     -- is non empty 
         eventList      [1] IMPLICIT RequestedEvents, 
         ... 
      } 
       
      RequestedEvent ::= SEQUENCE 
      { 
         pkgdName       [0] IMPLICIT EventName, 
         streamID       [1] IMPLICIT StreamID OPTIONAL, 
         eventAction    [2] IMPLICIT RequestedActions OPTIONAL, 
         evParList      [3] IMPLICIT EventParameters, 
         ... 
      } 

      RequestedEvents ::= SEQUENCE OF RequestedEvent

      RequestedActions ::= SEQUENCE 
      { 
         keepActive           [0] IMPLICIT BOOLEAN OPTIONAL, 
         eventDM              [1] EventDM OPTIONAL, 
         secondEvent          [2] IMPLICIT SecondEventsDescriptor OPTIONAL, 
         signalsDescriptor    [3] IMPLICIT SignalsDescriptor OPTIONAL, 
         ... 
      } 

      EventDM ::= CHOICE 
      { 
         digitMapName   [0] IMPLICIT DigitMapName, 
         digitMapValue  [1] IMPLICIT DigitMapValue 
      } 
       
      SecondEventsDescriptor ::= SEQUENCE 
      { 
         requestID         [0] IMPLICIT RequestID OPTIONAL, 
         eventList         [1] IMPLICIT SEQUENCE OF SecondRequestedEvent, 
         ... 
      } 
       
      SecondRequestedEvent ::= SEQUENCE 
      { 
         pkgdName          [0] IMPLICIT EventName, 
         streamID          [1] IMPLICIT StreamID OPTIONAL, 
         eventAction       [2] IMPLICIT SecondRequestedActions OPTIONAL, 
         evParList         [3] IMPLICIT EventParameters, 
         ... 
      } 
       
      SecondRequestedActions ::= SEQUENCE 
      { 
         keepActive           [0] IMPLICIT BOOLEAN OPTIONAL, 
         eventDM              [1] EventDM OPTIONAL, 
         signalsDescriptor    [2] IMPLICIT SignalsDescriptor OPTIONAL, 
         ... 
      } 
       
      EventBufferDescriptor ::= SEQUENCE OF EventSpec 
       
      EventSpec ::= SEQUENCE 
      { 
         eventName      [0] IMPLICIT EventName, 
         streamID       [1] IMPLICIT StreamID OPTIONAL, 
         eventParList   [2] IMPLICIT EventParameters, 
         ... 
      } 
       
       
      SignalsDescriptor ::= SEQUENCE OF SignalRequest 
       
      SignalRequest ::= CHOICE 
      { 
         signal         [0] IMPLICIT Signal, 
         seqSigList     [1] IMPLICIT SeqSigList, 
         ... 
      } 
       
      SeqSigList ::= SEQUENCE 
      { 
         id          [0] IMPLICIT INTEGER(0..65535), 
         signalList  [1] IMPLICIT SEQUENCE OF Signal 
      } 
       
      Signal ::= SEQUENCE 
      { 
         signalName        [0] IMPLICIT SignalName, 
         streamID          [1] IMPLICIT StreamID OPTIONAL, 
         sigType           [2] IMPLICIT SignalType OPTIONAL, 
         duration          [3] IMPLICIT INTEGER (0..65535) OPTIONAL, 
         notifyCompletion  [4] IMPLICIT NotifyCompletion OPTIONAL, 
         keepActive        [5] IMPLICIT BOOLEAN OPTIONAL, 
         sigParList        [6] IMPLICIT SEQUENCE OF SigParameter, 
         ... 
      } 
       
      SignalType ::= ENUMERATED 
      { 
         brief(0), 
         onOff(1), 
         timeOut(2), 
         ... 
      } 
       
      SignalName ::= OCTET STRING 
       
      NotifyCompletion ::= BIT STRING 
      { 
         onTimeOut(0), onInterruptByEvent(1), 
         onInterruptByNewSignalDescr(2), otherReason(3) 
      } 
       
      SigParameter ::= SEQUENCE 
      { 
         sigParameterName     [0] IMPLICIT Name, 
         value                [1] IMPLICIT Value, 
      -- For use of extraInfo see the comment related to PropertyParm 
         extraInfo            [2] ExtraInfo OPTIONAL,
         ... 
      } 
       
      -- For an AuditCapReply with all events, the RequestID SHALL be ALL. 
      -- ALL is represented by 0xffffffff. 
       
      RequestID ::= INTEGER(0..4294967295)   -- 32-bit unsigned integer 
       
      ModemDescriptor ::= SEQUENCE 
      { 
         mtl               [0] IMPLICIT SEQUENCE OF ModemType,  
         mpl               [1] IMPLICIT PropertyParms, 
         nonStandardData   [2] IMPLICIT NonStandardData OPTIONAL 
      } 
       
      ModemType ::= ENUMERATED 
      { 
         v18(0), 
         v22(1), 
         v22bis(2), 
         v32(3), 
         v32bis(4), 
         v34(5), 
         v90(6), 
         v91(7), 
         synchISDN(8), 
         ... 
      } 
       
      DigitMapDescriptor ::= SEQUENCE 
      { 
         digitMapName   [0] IMPLICIT DigitMapName OPTIONAL, 
         digitMapValue  [1] IMPLICIT DigitMapValue OPTIONAL 
      } 
       
      DigitMapName ::= Name 
       
      DigitMapValue ::= SEQUENCE 
      { 
         startTimer        [0] IMPLICIT INTEGER(0..99) OPTIONAL, 
         shortTimer        [1] IMPLICIT INTEGER(0..99) OPTIONAL, 
         longTimer         [2] IMPLICIT INTEGER(0..99) OPTIONAL, 
         digitMapBody      [3] IMPLICIT IA5String, 
      -- Units are seconds for start, short and long timers, and 
      -- hundreds of milliseconds for duration timer. Thus start, 
      -- short, and long range from 1 to 99 seconds and duration 
      -- from 100 ms to 9.9 s 
         -- See A.3 for explanation of digit map syntax 
         ..., 
         durationTimer     [4] IMPLICIT INTEGER (0..99) OPTIONAL 
      } 
       
      ServiceChangeParm ::= SEQUENCE 
      { 
         serviceChangeMethod     [0] IMPLICIT ServiceChangeMethod, 
         serviceChangeAddress    [1] ServiceChangeAddress OPTIONAL, 
         serviceChangeVersion    [2] IMPLICIT INTEGER(0..99) OPTIONAL, 
         serviceChangeProfile    [3] IMPLICIT ServiceChangeProfile OPTIONAL, 
         serviceChangeReason     [4] IMPLICIT Value, 
      -- A serviceChangeReason consists of a numeric reason code 
      -- and an optional text description. 
      -- The serviceChangeReason SHALL be a string consisting of  
      -- a decimal reason code, optionally followed by a single  
      -- space character and a textual description string. 
      -- This string is first BER-encoded as an IA5String. 
      -- The result of this BER-encoding is then encoded as 
      -- an ASN.1 OCTET STRING type, "double wrapping" the  
      -- value 
      -- as was done for package elements. 
         serviceChangeDelay      [5] IMPLICIT INTEGER(0..4294967295) OPTIONAL, 
                                           -- 32-bit unsigned integer 
         serviceChangeMgcId      [6] MId OPTIONAL, 
         timeStamp               [7] IMPLICIT TimeNotation OPTIONAL, 
         nonStandardData         [8] IMPLICIT NonStandardData OPTIONAL, 
         ..., 
         serviceChangeInfo       [9] IMPLICIT AuditDescriptor OPTIONAL 
      } 

      ServiceChangeAddress ::= CHOICE 
      { 
         portNumber        [0] IMPLICIT INTEGER(0..65535),    -- TCP/UDP port number 
         ip4Address        [1] IMPLICIT IP4Address, 
         ip6Address        [2] IMPLICIT IP6Address, 
         domainName        [3] IMPLICIT DomainName, 
         deviceName        [4] IMPLICIT PathName, 
         mtpAddress        [5] IMPLICIT MtpAddress, 
         ... 
      } 
       
      ServiceChangeResParm ::= SEQUENCE 
      { 
         serviceChangeMgcId      [0] MId OPTIONAL, 
         serviceChangeAddress    [1] ServiceChangeAddress OPTIONAL, 
         serviceChangeVersion    [2] IMPLICIT INTEGER(0..99) OPTIONAL, 
         serviceChangeProfile    [3] IMPLICIT ServiceChangeProfile OPTIONAL, 
         timestamp               [4] IMPLICIT TimeNotation OPTIONAL, 
         ... 
      } 
       
      ServiceChangeMethod ::= ENUMERATED 
      { 
         failover(0), 
         forced(1), 
         graceful(2), 
         restart(3), 
         disconnected(4), 
         handOff(5), 
         ... 
      } 
       
      ServiceChangeProfile ::= SEQUENCE 
      { 
         profileName    [0] IMPLICIT IA5String(SIZE (1..67)) 
       
         -- 64 characters for name, 1 for "/", 2 for version to match ABNF 
      } 
       
      PackagesDescriptor ::= SEQUENCE OF PackagesItem 
       
      PackagesItem ::= SEQUENCE 
      { 
         packageName       [0] IMPLICIT Name, 
         packageVersion    [1] IMPLICIT INTEGER(0..99), 
         ... 
      } 
       
      StatisticsDescriptor ::= SEQUENCE OF StatisticsParameter 
       
      StatisticsParameter ::= SEQUENCE 
      { 
         statName       [0] IMPLICIT PkgdName, 
         statValue      [1] IMPLICIT Value OPTIONAL 
      } 
       
      NonStandardData ::= SEQUENCE 
      { 
         nonStandardIdentifier   [0] NonStandardIdentifier, 
         data                    [1] IMPLICIT OCTET STRING 
      } 
       
      NonStandardIdentifier ::= CHOICE 
      { 
         object            [0] IMPLICIT OBJECT IDENTIFIER, 
         h221NonStandard   [1] IMPLICIT H221NonStandard, 
         experimental      [2] IMPLICIT IA5String(SIZE(8)),  
             -- first two characters SHOULD be "X-" or "X+" 
         ... 
      } 
       
      H221NonStandard ::= SEQUENCE 
      {  t35CountryCode1      [0] IMPLICIT INTEGER(0..255), 
         t35CountryCode2      [1] IMPLICIT INTEGER(0..255),      -- country, as per T.35 
         t35Extension         [2] IMPLICIT INTEGER(0..255),      -- assigned nationally 
         manufacturerCode     [3] IMPLICIT INTEGER(0..65535), -- assigned nationally 
         ... 
      } 
       
      TimeNotation ::= SEQUENCE 
      { 
         date     [0] IMPLICIT IA5String(SIZE(8)),  -- yyyymmdd format 
         time     [1] IMPLICIT IA5String(SIZE(8))   -- hhmmssss format 
         -- per ISO 8601:1988 
      } 
       
      Value ::= SEQUENCE OF OCTET STRING 
       
      END