MEDIA-GATEWAY-CONTROL {itu-t(0) recommendation(0) h(8) h248(248) modules(0)
  media-gateway-control(0) version3(3)} DEFINITIONS AUTOMATIC TAGS ::=
BEGIN

MegacoMessage ::= SEQUENCE {
  authHeader  AuthenticationHeader OPTIONAL,
  mess        Message
}

AuthenticationHeader ::= SEQUENCE {
  secParmIndex  SecurityParmIndex,
  seqNum        SequenceNum,
  ad            AuthData
}

SecurityParmIndex ::= OCTET STRING(SIZE (4))

SequenceNum ::= OCTET STRING(SIZE (4))

AuthData ::= OCTET STRING(SIZE (12..32))

Message ::= SEQUENCE {
  version      INTEGER(0..99),
  -- The version of the protocol defined here is equal to 3.
  mId          Mid, -- Name/address of message originator
  messageBody
    CHOICE {messageError  ErrorDescriptor,
            transactions  SEQUENCE OF Transaction},
  ...
}

Mid ::= CHOICE {
  ip4Address  IP4Address,
  ip6Address  IP6Address,
  domainName  DomainName,
  deviceName  PathName,
  mtpAddress  OCTET STRING(SIZE (2..4)),
  -- 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.
  ...
}

DomainName ::= SEQUENCE {
  name        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  INTEGER(0..65535) OPTIONAL
}

IP4Address ::= SEQUENCE {
  address     OCTET STRING(SIZE (4)),
  portNumber  INTEGER(0..65535) OPTIONAL
}

IP6Address ::= SEQUENCE {
  address     OCTET STRING(SIZE (16)),
  portNumber  INTEGER(0..65535) OPTIONAL
}

PathName ::= IA5String(SIZE (1..64))

-- See A.3
Transaction ::= CHOICE {
  transactionRequest      TransactionRequest,
  transactionPending      TransactionPending,
  transactionReply        TransactionReply,
  transactionResponseAck  TransactionResponseAck,
  -- use of response acks is dependent on underlying transport
  ...,
  segmentReply            SegmentReply
}

TransactionId ::= INTEGER(0..4294967295) -- 32-bit unsigned integer
                         

TransactionRequest ::= SEQUENCE {
  transactionId  TransactionId,
  actions        SEQUENCE OF ActionRequest,
  ...
}

TransactionPending ::= SEQUENCE {transactionId  TransactionId,
                                 ...
}

TransactionReply ::= SEQUENCE {
  transactionId            TransactionId,
  immAckRequired           NULL OPTIONAL,
  transactionResult
    CHOICE {transactionError  ErrorDescriptor,
            actionReplies     SEQUENCE OF ActionReply},
  ...,
  segmentNumber            SegmentNumber OPTIONAL,
  segmentationComplete     NULL OPTIONAL
}

SegmentReply ::= SEQUENCE {
  transactionId         TransactionId,
  segmentNumber         SegmentNumber,
  segmentationComplete  NULL OPTIONAL,
  ...
}

SegmentNumber ::= INTEGER(0..65535)

TransactionResponseAck ::= SEQUENCE OF TransactionAck

TransactionAck ::= SEQUENCE {
  firstAck  TransactionId,
  lastAck   TransactionId OPTIONAL
}

ErrorDescriptor ::= SEQUENCE {
  errorCode  ErrorCode,
  errorText  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            ContextID,
  contextRequest       ContextRequest OPTIONAL,
  contextAttrAuditReq  ContextAttrAuditRequest OPTIONAL,
  commandRequests      SEQUENCE OF CommandRequest
}

ActionReply ::= SEQUENCE {
  contextId        ContextID,
  errorDescriptor  ErrorDescriptor OPTIONAL,
  contextReply     ContextRequest OPTIONAL,
  commandReply     SEQUENCE OF CommandReply
}

ContextRequest ::= SEQUENCE {
  priority        INTEGER(0..15) OPTIONAL,
  emergency       BOOLEAN OPTIONAL,
  topologyReq     SEQUENCE OF TopologyRequest OPTIONAL,
  ...,
  iepscallind     BOOLEAN OPTIONAL,
  contextProp     SEQUENCE OF PropertyParm OPTIONAL,
  contextList     SEQUENCE OF ContextID OPTIONAL
}

-- When returning a contextList, the contextId in the ActionReply construct will
-- return the contextId from the associated ActionRequest.
ContextAttrAuditRequest ::= SEQUENCE {
  topology              NULL OPTIONAL,
  emergency             NULL OPTIONAL,
  priority              NULL OPTIONAL,
  ...,
  iepscallind           NULL OPTIONAL,
  contextPropAud        SEQUENCE OF IndAudPropertyParm OPTIONAL,
  selectpriority        INTEGER(0..15) OPTIONAL,
  -- to select given priority
  selectemergency       BOOLEAN OPTIONAL,
  -- to select if emergency set/not set (T/F)
  selectiepscallind     BOOLEAN OPTIONAL,
  -- to select if IEPS set/not set (T/F)
  selectLogic           SelectLogic OPTIONAL -- default is AND
}

SelectLogic ::= CHOICE {
  andAUDITSelect  NULL, -- all filter conditions satisfied
  orAUDITSelect   NULL, -- at least one filter condition satisfied
  ...
}

CommandRequest ::= SEQUENCE {
  command         Command,
  optional        NULL OPTIONAL,
  wildcardReturn  NULL OPTIONAL,
  ...
}

Command ::= CHOICE {
  addReq             AmmRequest,
  moveReq            AmmRequest,
  modReq             AmmRequest,
  -- Add, Move, Modify requests have the same parameters
  subtractReq        SubtractRequest,
  auditCapRequest    AuditRequest,
  auditValueRequest  AuditRequest,
  notifyReq          NotifyRequest,
  serviceChangeReq   ServiceChangeRequest,
  ...
}

CommandReply ::= CHOICE {
  addReply            AmmsReply,
  moveReply           AmmsReply,
  modReply            AmmsReply,
  subtractReply       AmmsReply,
  -- Add, Move, Modify, Subtract replies have the same parameters
  auditCapReply       AuditReply,
  auditValueReply     AuditReply,
  notifyReply         NotifyReply,
  serviceChangeReply  ServiceChangeReply,
  ...
}

TopologyRequest ::= SEQUENCE {
  terminationFrom                TerminationID,
  terminationTo                  TerminationID,
  topologyDirection              ENUMERATED {bothway(0), isolate(1), oneway(2)},
  ...,
  streamID                       StreamID OPTIONAL,
  topologyDirectionExtension
    ENUMERATED {onewayexternal(0), onewayboth(1), ...
                } OPTIONAL
}

-- if present, topologyDirectionExtension takes precedence over
-- topologyDirection
AmmRequest ::= SEQUENCE {
  terminationID  TerminationIDList,
  descriptors    SEQUENCE OF AmmDescriptor,
  -- At most one descriptor of each type (see AmmDescriptor)
  -- allowed in the sequence.
  ...
}

AmmDescriptor ::= CHOICE {
  mediaDescriptor        MediaDescriptor,
  modemDescriptor        ModemDescriptor,
  muxDescriptor          MuxDescriptor,
  eventsDescriptor       EventsDescriptor,
  eventBufferDescriptor  EventBufferDescriptor,
  signalsDescriptor      SignalsDescriptor,
  digitMapDescriptor     DigitMapDescriptor,
  auditDescriptor        AuditDescriptor,
  ...,
  statisticsDescriptor   StatisticsDescriptor
}

AmmsReply ::= SEQUENCE {
  terminationID     TerminationIDList,
  terminationAudit  TerminationAudit OPTIONAL,
  ...
}

SubtractRequest ::= SEQUENCE {
  terminationID    TerminationIDList,
  auditDescriptor  AuditDescriptor OPTIONAL,
  ...
}

AuditRequest ::= SEQUENCE {
  terminationID         TerminationID,
  auditDescriptor       AuditDescriptor,
  ...,
  terminationIDList     TerminationIDList OPTIONAL
}

-- terminationID shall contain the first termination in the
-- list when using the terminationIDList construct in AuditRequest
AuditReply ::= CHOICE {
  contextAuditResult   TerminationIDList,
  error                ErrorDescriptor,
  auditResult          AuditResult,
  ...,
  auditResultTermList  TermListAuditResult
}

AuditResult ::= SEQUENCE {
  terminationID           TerminationID,
  terminationAuditResult  TerminationAudit
}

TermListAuditResult ::= SEQUENCE {
  terminationIDList       TerminationIDList,
  terminationAuditResult  TerminationAudit,
  ...
}

TerminationAudit ::= SEQUENCE OF AuditReturnParameter

AuditReturnParameter ::= CHOICE {
  errorDescriptor           ErrorDescriptor,
  mediaDescriptor           MediaDescriptor,
  modemDescriptor           ModemDescriptor,
  muxDescriptor             MuxDescriptor,
  eventsDescriptor          EventsDescriptor,
  eventBufferDescriptor     EventBufferDescriptor,
  signalsDescriptor         SignalsDescriptor,
  digitMapDescriptor        DigitMapDescriptor,
  observedEventsDescriptor  ObservedEventsDescriptor,
  statisticsDescriptor      StatisticsDescriptor,
  packagesDescriptor        PackagesDescriptor,
  emptyDescriptors          AuditDescriptor,
  ...
}

AuditDescriptor ::= SEQUENCE {
  auditToken
    BIT STRING {muxToken(0), modemToken(1), mediaToken(2), eventsToken(3),
                signalsToken(4), digitMapToken(5), statsToken(6),
                observedEventsToken(7), packagesToken(8), eventBufferToken(9)}
      OPTIONAL,
  ...,
  auditPropertyToken     SEQUENCE OF IndAuditParameter OPTIONAL
}

IndAuditParameter ::= CHOICE {
  indaudmediaDescriptor        IndAudMediaDescriptor,
  indaudeventsDescriptor       IndAudEventsDescriptor,
  indaudeventBufferDescriptor  IndAudEventBufferDescriptor,
  indaudsignalsDescriptor      IndAudSignalsDescriptor,
  indauddigitMapDescriptor     IndAudDigitMapDescriptor,
  indaudstatisticsDescriptor   IndAudStatisticsDescriptor,
  indaudpackagesDescriptor     IndAudPackagesDescriptor,
  ...
}

IndAudMediaDescriptor ::= SEQUENCE {
  termStateDescr  IndAudTerminationStateDescriptor OPTIONAL,
  streams
    CHOICE {oneStream    IndAudStreamParms,
            multiStream  SEQUENCE OF IndAudStreamDescriptor} OPTIONAL,
  ...
}

IndAudStreamDescriptor ::= SEQUENCE {
  streamID     StreamID,
  streamParms  IndAudStreamParms
}

IndAudStreamParms ::= SEQUENCE {
  localControlDescriptor   IndAudLocalControlDescriptor OPTIONAL,
  localDescriptor          IndAudLocalRemoteDescriptor OPTIONAL,
  remoteDescriptor         IndAudLocalRemoteDescriptor OPTIONAL,
  ...,
  statisticsDescriptor     IndAudStatisticsDescriptor OPTIONAL
}

IndAudLocalControlDescriptor ::= SEQUENCE {
  streamMode        NULL OPTIONAL,
  reserveValue      NULL OPTIONAL,
  reserveGroup      NULL OPTIONAL,
  propertyParms     SEQUENCE OF IndAudPropertyParm OPTIONAL,
  ...,
  streamModeSel     StreamMode OPTIONAL
}

-- must not have both streamMode and streamModeSel
-- if both are present only streamModeSel shall be honoured
IndAudPropertyParm ::= SEQUENCE {
  name              PkgdName,
  ...,
  propertyParms     PropertyParm OPTIONAL
}

--  to select based on property values
--  AND/OR selection logic is specified at context level
IndAudLocalRemoteDescriptor ::= SEQUENCE {
  propGroupID  INTEGER(0..65535) OPTIONAL,
  propGrps     IndAudPropertyGroup,
  ...
}

IndAudPropertyGroup ::= SEQUENCE OF IndAudPropertyParm

IndAudTerminationStateDescriptor ::= SEQUENCE {
  propertyParms       SEQUENCE OF IndAudPropertyParm,
  eventBufferControl  NULL OPTIONAL,
  serviceState        NULL OPTIONAL,
  ...,
  serviceStateSel     ServiceState OPTIONAL
}

-- must not have both serviceState and serviceStateSel
-- if both are present only serviceStateSel shall be honoured
IndAudEventsDescriptor ::= SEQUENCE {
  requestID  RequestID OPTIONAL,
  pkgdName   PkgdName,
  streamID   StreamID OPTIONAL,
  ...
}

IndAudEventBufferDescriptor ::= SEQUENCE {
  eventName  PkgdName,
  streamID   StreamID OPTIONAL,
  ...
}

IndAudSignalsDescriptor ::= CHOICE {
  signal      IndAudSignal,
  seqSigList  IndAudSeqSigList,
  ...
}

IndAudSeqSigList ::= SEQUENCE {
  id          INTEGER(0..65535),
  signalList  IndAudSignal OPTIONAL
}

IndAudSignal ::= SEQUENCE {
  signalName          PkgdName,
  streamID            StreamID OPTIONAL,
  ...,
  signalRequestID     RequestID OPTIONAL
}

IndAudDigitMapDescriptor ::= SEQUENCE {digitMapName  DigitMapName OPTIONAL
}

IndAudStatisticsDescriptor ::= SEQUENCE {statName  PkgdName
}

IndAudPackagesDescriptor ::= SEQUENCE {
  packageName     Name,
  packageVersion  INTEGER(0..99),
  ...
}

NotifyRequest ::= SEQUENCE {
  terminationID             TerminationIDList,
  observedEventsDescriptor  ObservedEventsDescriptor,
  errorDescriptor           ErrorDescriptor OPTIONAL,
  ...
}

NotifyReply ::= SEQUENCE {
  terminationID    TerminationIDList,
  errorDescriptor  ErrorDescriptor OPTIONAL,
  ...
}

ObservedEventsDescriptor ::= SEQUENCE {
  requestId         RequestID,
  observedEventLst  SEQUENCE OF ObservedEvent
}

ObservedEvent ::= SEQUENCE {
  eventName     EventName,
  streamID      StreamID OPTIONAL,
  eventParList  SEQUENCE OF EventParameter,
  timeNotation  TimeNotation OPTIONAL,
  ...
}

EventName ::= PkgdName

EventParameter ::= SEQUENCE {
  eventParameterName  Name,
  value               Value,
  -- For use of extraInfos see the comment related to PropertyParm
  extraInfo
    CHOICE {relation  Relation,
            range     BOOLEAN,
            sublist   BOOLEAN} OPTIONAL,
  ...
}

ServiceChangeRequest ::= SEQUENCE {
  terminationID       TerminationIDList,
  serviceChangeParms  ServiceChangeParm,
  ...
}

ServiceChangeReply ::= SEQUENCE {
  terminationID        TerminationIDList,
  serviceChangeResult  ServiceChangeResult,
  ...
}

-- For ServiceChangeResult, no parameters are mandatory. Hence the
-- distinction between ServiceChangeParm and ServiceChangeResParm.
ServiceChangeResult ::= CHOICE {
  errorDescriptor        ErrorDescriptor,
  serviceChangeResParms  ServiceChangeResParm
}

WildcardField ::= OCTET STRING(SIZE (1))

TerminationID ::= SEQUENCE {
  wildcard  SEQUENCE OF WildcardField,
  id        OCTET STRING(SIZE (1..8)),
  ...
}

-- See A.1 for explanation of wildcarding mechanism.
-- TerminationID 0xFFFFFFFFFFFFFFFF indicates the Root Termination.
TerminationIDList ::= SEQUENCE OF TerminationID

MediaDescriptor ::= SEQUENCE {
  termStateDescr  TerminationStateDescriptor OPTIONAL,
  streams
    CHOICE {oneStream    StreamParms,
            multiStream  SEQUENCE OF StreamDescriptor} OPTIONAL,
  ...
}

StreamDescriptor ::= SEQUENCE {streamID     StreamID,
                               streamParms  StreamParms
}

StreamParms ::= SEQUENCE {
  localControlDescriptor   LocalControlDescriptor OPTIONAL,
  localDescriptor          LocalRemoteDescriptor OPTIONAL,
  remoteDescriptor         LocalRemoteDescriptor OPTIONAL,
  ...,
  statisticsDescriptor     StatisticsDescriptor OPTIONAL
}

LocalControlDescriptor ::= SEQUENCE {
  streamMode     StreamMode OPTIONAL,
  reserveValue   BOOLEAN OPTIONAL,
  reserveGroup   BOOLEAN OPTIONAL,
  propertyParms  SEQUENCE OF PropertyParm,
  ...
}

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 etc., from a
-- collection of values.
-- If the sublist field is selected,
-- a sequence with more than one element encodes the value of a
-- list-valued property (i.e., a collection of values, value1 and value2
-- and ...)
-- Note that when encoding a sub-list of length one, the sublist field
-- may be left unselected.
-- 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 {
  name       PkgdName,
  value      SEQUENCE OF OCTET STRING,
  extraInfo  CHOICE {relation  Relation,
                     range     BOOLEAN,
                     sublist   BOOLEAN} OPTIONAL,
  ...
}

Name ::= OCTET STRING(SIZE (2))

PkgdName ::= OCTET STRING(SIZE (4))

-- represents Package Name (2 octets) plus property, event,
-- signal names or StatisticsID. (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 PropertyID, EventID, SignalID, or StatisticsID, use
-- 0xFFFF for last two octets, CHOOSE is not allowed.
-- Wildcarding of Package Name is permitted only if PropertyID,
-- EventID, SignalID, or StatisticsID are also wildcarded.
Relation ::= ENUMERATED {greaterThan(0), smallerThan(1), unequalTo(2), ...
                         }

LocalRemoteDescriptor ::= SEQUENCE {propGrps  SEQUENCE OF PropertyGroup,
                                    ...
}

PropertyGroup ::= SEQUENCE OF PropertyParm

TerminationStateDescriptor ::= SEQUENCE {
  propertyParms       SEQUENCE OF PropertyParm,
  eventBufferControl  EventBufferControl OPTIONAL,
  serviceState        ServiceState OPTIONAL,
  ...
}

EventBufferControl ::= ENUMERATED {off(0), lockStep(1), ...
                                   }

ServiceState ::= ENUMERATED {test(0), outOfSvc(1), inSvc(2), ...
                             }

MuxDescriptor ::= SEQUENCE {
  muxType          MuxType,
  termList         SEQUENCE OF TerminationID,
  nonStandardData  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  RequestID OPTIONAL,
  -- RequestID must be present if eventList
  -- is non empty
  eventList  SEQUENCE OF RequestedEvent,
  ...
}

RequestedEvent ::= SEQUENCE {
  pkgdName     PkgdName,
  streamID     StreamID OPTIONAL,
  eventAction  RequestedActions OPTIONAL,
  evParList    SEQUENCE OF EventParameter,
  ...
}

RegulatedEmbeddedDescriptor ::= SEQUENCE {
  secondEvent        SecondEventsDescriptor OPTIONAL,
  signalsDescriptor  SignalsDescriptor OPTIONAL,
  ...
}

NotifyBehaviour ::= CHOICE {
  notifyImmediate  NULL,
  notifyRegulated  RegulatedEmbeddedDescriptor,
  neverNotify      NULL,
  ...
}

RequestedActions ::= SEQUENCE {
  keepActive                BOOLEAN OPTIONAL,
  eventDM                   EventDM OPTIONAL,
  secondEvent               SecondEventsDescriptor OPTIONAL,
  signalsDescriptor         SignalsDescriptor OPTIONAL,
  ...,
  notifyBehaviour           NotifyBehaviour OPTIONAL,
  resetEventsDescriptor     NULL OPTIONAL
}

EventDM ::= CHOICE {digitMapName   DigitMapName,
                    digitMapValue  DigitMapValue
}

SecondEventsDescriptor ::= SEQUENCE {
  requestID  RequestID OPTIONAL,
  eventList  SEQUENCE OF SecondRequestedEvent,
  ...
}

SecondRequestedEvent ::= SEQUENCE {
  pkgdName     PkgdName,
  streamID     StreamID OPTIONAL,
  eventAction  SecondRequestedActions OPTIONAL,
  evParList    SEQUENCE OF EventParameter,
  ...
}

SecondRequestedActions ::= SEQUENCE {
  keepActive                BOOLEAN OPTIONAL,
  eventDM                   EventDM OPTIONAL,
  signalsDescriptor         SignalsDescriptor OPTIONAL,
  ...,
  notifyBehaviour           NotifyBehaviour OPTIONAL,
  resetEventsDescriptor     NULL OPTIONAL
}

EventBufferDescriptor ::= SEQUENCE OF EventSpec

EventSpec ::= SEQUENCE {
  eventName     EventName,
  streamID      StreamID OPTIONAL,
  eventParList  SEQUENCE OF EventParameter,
  ...
}

SignalsDescriptor ::= SEQUENCE OF SignalRequest

SignalRequest ::= CHOICE {signal      Signal,
                          seqSigList  SeqSigList,
                          ...
}

SeqSigList ::= SEQUENCE {
  id          INTEGER(0..65535),
  signalList  SEQUENCE OF Signal
}

Signal ::= SEQUENCE {
  signalName        SignalName,
  streamID          StreamID OPTIONAL,
  sigType           SignalType OPTIONAL,
  duration          INTEGER(0..65535) OPTIONAL,
  notifyCompletion  NotifyCompletion OPTIONAL,
  keepActive        BOOLEAN OPTIONAL,
  sigParList        SEQUENCE OF SigParameter,
  ...,
  direction         SignalDirection OPTIONAL,
  requestID         RequestID OPTIONAL,
  intersigDelay     INTEGER(0..65535) OPTIONAL
}

SignalType ::= ENUMERATED {brief(0), onOff(1), timeOut(2), ...
                           }

SignalDirection ::= ENUMERATED {internal(0), external(1), both(2), ...
                                }

SignalName ::= PkgdName

NotifyCompletion ::= BIT STRING {
  onTimeOut(0), onInterruptByEvent(1), onInterruptByNewSignalDescr(2),
  otherReason(3), onIteration(4)}

SigParameter ::= SEQUENCE {
  sigParameterName  Name,
  value             Value,
  -- For use of extraInfo see the comment related to PropertyParm
  extraInfo
    CHOICE {relation  Relation,
            range     BOOLEAN,
            sublist   BOOLEAN} 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              SEQUENCE OF ModemType,
  mpl              SEQUENCE OF PropertyParm,
  nonStandardData  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   DigitMapName OPTIONAL,
  digitMapValue  DigitMapValue OPTIONAL
}

DigitMapName ::= Name

DigitMapValue ::= SEQUENCE {
  startTimer        INTEGER(0..99) OPTIONAL,
  shortTimer        INTEGER(0..99) OPTIONAL,
  longTimer         INTEGER(0..99) OPTIONAL,
  digitMapBody      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
  -- An exception is the start timer which may equal 0.
  -- See A.3 for explanation of DigitMap syntax
  ...,
  durationTimer     INTEGER(0..99) OPTIONAL
}

ServiceChangeParm ::= SEQUENCE {
  serviceChangeMethod             ServiceChangeMethod,
  serviceChangeAddress            ServiceChangeAddress OPTIONAL,
  serviceChangeVersion            INTEGER(0..99) OPTIONAL,
  serviceChangeProfile            ServiceChangeProfile OPTIONAL,
  serviceChangeReason             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              INTEGER(0..4294967295) OPTIONAL,
  -- 32-bit unsigned integer
  serviceChangeMgcId              Mid OPTIONAL,
  timeStamp                       TimeNotation OPTIONAL,
  nonStandardData                 NonStandardData OPTIONAL,
  ...,
  serviceChangeInfo               AuditDescriptor OPTIONAL,
  serviceChangeIncompleteFlag     NULL OPTIONAL
}

ServiceChangeAddress ::= CHOICE {
  portNumber  INTEGER(0..65535), -- TCP/UDP port number
  ip4Address  IP4Address,
  ip6Address  IP6Address,
  domainName  DomainName,
  deviceName  PathName,
  mtpAddress  OCTET STRING(SIZE (2..4)),
  ...
}

ServiceChangeResParm ::= SEQUENCE {
  serviceChangeMgcId    Mid OPTIONAL,
  serviceChangeAddress  ServiceChangeAddress OPTIONAL,
  serviceChangeVersion  INTEGER(0..99) OPTIONAL,
  serviceChangeProfile  ServiceChangeProfile OPTIONAL,
  timestamp             TimeNotation OPTIONAL,
  ...
}

ServiceChangeMethod ::= ENUMERATED {
  failover(0), forced(1), graceful(2), restart(3), disconnected(4), handOff(5),
  ...
  }

ServiceChangeProfile ::= SEQUENCE {
  profileName  IA5String(SIZE (1..67))
  -- 64 characters for name, 1 for "/", 2 for version to match ABNF
}

PackagesDescriptor ::= SEQUENCE OF PackagesItem

PackagesItem ::= SEQUENCE {
  packageName     Name,
  packageVersion  INTEGER(0..99),
  ...
}

StatisticsDescriptor ::= SEQUENCE OF StatisticsParameter

StatisticsParameter ::= SEQUENCE {
  statName   PkgdName,
  statValue  Value OPTIONAL
}

-- If statistic consists of a sub-lists there will be more than
-- one octetstring in statValue.
NonStandardData ::= SEQUENCE {
  nonStandardIdentifier  NonStandardIdentifier,
  data                   OCTET STRING
}

NonStandardIdentifier ::= CHOICE {
  object           OBJECT IDENTIFIER,
  h221NonStandard  H221NonStandard,
  experimental     IA5String(SIZE (8)),
  -- first two characters should be "X-" or "X+"
  ...
}

H221NonStandard ::= SEQUENCE {
  t35CountryCode1   INTEGER(0..255),
  t35CountryCode2   INTEGER(0..255), -- country, as per T.35
  t35Extension      INTEGER(0..255), -- assigned nationally
  manufacturerCode  INTEGER(0..65535), -- assigned nationally
  ...
}

TimeNotation ::= SEQUENCE {
  date  IA5String(SIZE (8)), -- yyyymmdd format
  time  IA5String(SIZE (8))-- hhmmssss format--
  -- per ISO 8601:2004
}

Value ::= SEQUENCE OF OCTET STRING

END