-- H323-MESSAGES.asn
--
-- Taken from ITU ASN.1 database
-- http://www.itu.int/ITU-T/formal-language/itu-t/h/h225-0/2009/H323-MESSAGES.asn
--

-- Module H323-MESSAGES (H.225.0:12/2009)
H323-MESSAGES {itu-t(0) recommendation(0) h(8) h225-0(2250) version(0)
  7 h323-messages(0)} DEFINITIONS AUTOMATIC TAGS ::=
BEGIN

IMPORTS
  SIGNED{}, ENCRYPTED{}, HASHED{}, ChallengeString, TimeStamp, RandomVal,
    Password, EncodedPwdCertToken, ClearToken, CryptoToken,
    AuthenticationMechanism
    FROM H235-SECURITY-MESSAGES
  DataProtocolCapability, T38FaxProfile, QOSCapability
    FROM MULTIMEDIA-SYSTEM-CONTROL {itu-t(0) recommendation(0) h(8) h245(245)
      version(0) 15 multimedia-system-control(0)};

H323-UserInformation ::=
  SEQUENCE -- root for all H.225.0 call signalling messages
   {
  h323-uu-pdu  H323-UU-PDU,
  user-data
    SEQUENCE {protocol-discriminator  INTEGER(0..255),
              user-information        OCTET STRING(SIZE (1..131)),
              ...} OPTIONAL,
  ...
}

H323-UU-PDU ::= SEQUENCE {
  h323-message-body
    CHOICE {setup             Setup-UUIE,
            callProceeding    CallProceeding-UUIE,
            connect           Connect-UUIE,
            alerting          Alerting-UUIE,
            information       Information-UUIE,
            releaseComplete   ReleaseComplete-UUIE,
            facility          Facility-UUIE,
            ...,
            progress          Progress-UUIE,
            empty             NULL, -- used when a Facility message is sent,--
            -- but the Facility-UUIE is not to be invoked
            -- (possible when transporting supplementary
            -- services messages in versions prior to
            -- H.225.0 version 4)
            status            Status-UUIE,
            statusInquiry     StatusInquiry-UUIE,
            setupAcknowledge  SetupAcknowledge-UUIE,
            notify            Notify-UUIE},
  nonStandardData                     NonStandardParameter OPTIONAL,
  ...,
  h4501SupplementaryService           SEQUENCE OF OCTET STRING OPTIONAL,
  -- each sequence of octet string is defined as one
  -- H4501SupplementaryService APDU as defined in
  -- Table 3/H.450.1
  h245Tunnelling                      BOOLEAN,
  -- if TRUE, tunnelling of H.245 messages is enabled
  h245Control                         SEQUENCE OF OCTET STRING OPTIONAL,
  nonStandardControl                  SEQUENCE OF NonStandardParameter OPTIONAL,
  callLinkage                         CallLinkage OPTIONAL,
  tunnelledSignallingMessage
    SEQUENCE {tunnelledProtocolID  TunnelledProtocol, -- tunnelled signalling--
              -- protocol ID
              messageContent       SEQUENCE OF OCTET STRING, -- sequence of entire --
              -- message(s)
              tunnellingRequired   NULL OPTIONAL,
              nonStandardData      NonStandardParameter OPTIONAL,
              ...} OPTIONAL,
  provisionalRespToH245Tunnelling     NULL OPTIONAL,
  stimulusControl                     StimulusControl OPTIONAL,
  genericData                         SEQUENCE OF GenericData OPTIONAL
}

StimulusControl ::= SEQUENCE {
  nonStandard  NonStandardParameter OPTIONAL,
  isText       NULL OPTIONAL,
  h248Message  OCTET STRING OPTIONAL,
  ...
}

Alerting-UUIE ::= SEQUENCE {
  protocolIdentifier        ProtocolIdentifier,
  destinationInfo           EndpointType,
  h245Address               TransportAddress OPTIONAL,
  ...,
  callIdentifier            CallIdentifier,
  h245SecurityMode          H245Security OPTIONAL,
  tokens                    SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens              SEQUENCE OF CryptoH323Token OPTIONAL,
  fastStart                 SEQUENCE OF OCTET STRING OPTIONAL,
  multipleCalls             BOOLEAN,
  maintainConnection        BOOLEAN,
  alertingAddress           SEQUENCE OF AliasAddress OPTIONAL,
  presentationIndicator     PresentationIndicator OPTIONAL,
  screeningIndicator        ScreeningIndicator OPTIONAL,
  fastConnectRefused        NULL OPTIONAL,
  serviceControl            SEQUENCE OF ServiceControlSession OPTIONAL,
  capacity                  CallCapacity OPTIONAL,
  featureSet                FeatureSet OPTIONAL,
  displayName               SEQUENCE OF DisplayName OPTIONAL
}

CallProceeding-UUIE ::= SEQUENCE {
  protocolIdentifier     ProtocolIdentifier,
  destinationInfo        EndpointType,
  h245Address            TransportAddress OPTIONAL,
  ...,
  callIdentifier         CallIdentifier,
  h245SecurityMode       H245Security OPTIONAL,
  tokens                 SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens           SEQUENCE OF CryptoH323Token OPTIONAL,
  fastStart              SEQUENCE OF OCTET STRING OPTIONAL,
  multipleCalls          BOOLEAN,
  maintainConnection     BOOLEAN,
  fastConnectRefused     NULL OPTIONAL,
  featureSet             FeatureSet OPTIONAL
}

Connect-UUIE ::= SEQUENCE {
  protocolIdentifier        ProtocolIdentifier,
  h245Address               TransportAddress OPTIONAL,
  destinationInfo           EndpointType,
  conferenceID              ConferenceIdentifier,
  ...,
  callIdentifier            CallIdentifier,
  h245SecurityMode          H245Security OPTIONAL,
  tokens                    SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens              SEQUENCE OF CryptoH323Token OPTIONAL,
  fastStart                 SEQUENCE OF OCTET STRING OPTIONAL,
  multipleCalls             BOOLEAN,
  maintainConnection        BOOLEAN,
  language                  SEQUENCE OF IA5String(SIZE (1..32)) OPTIONAL, -- RFC 1766 language tag
  connectedAddress          SEQUENCE OF AliasAddress OPTIONAL,
  presentationIndicator     PresentationIndicator OPTIONAL,
  screeningIndicator        ScreeningIndicator OPTIONAL,
  fastConnectRefused        NULL OPTIONAL,
  serviceControl            SEQUENCE OF ServiceControlSession OPTIONAL,
  capacity                  CallCapacity OPTIONAL,
  featureSet                FeatureSet OPTIONAL,
  displayName               SEQUENCE OF DisplayName OPTIONAL
}

Information-UUIE ::= SEQUENCE {
  protocolIdentifier     ProtocolIdentifier,
  ...,
  callIdentifier         CallIdentifier,
  tokens                 SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens           SEQUENCE OF CryptoH323Token OPTIONAL,
  fastStart              SEQUENCE OF OCTET STRING OPTIONAL,
  fastConnectRefused     NULL OPTIONAL,
  circuitInfo            CircuitInfo OPTIONAL
}

ReleaseComplete-UUIE ::= SEQUENCE {
  protocolIdentifier        ProtocolIdentifier,
  reason                    ReleaseCompleteReason OPTIONAL,
  ...,
  callIdentifier            CallIdentifier,
  tokens                    SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens              SEQUENCE OF CryptoH323Token OPTIONAL,
  busyAddress               SEQUENCE OF AliasAddress OPTIONAL,
  presentationIndicator     PresentationIndicator OPTIONAL,
  screeningIndicator        ScreeningIndicator OPTIONAL,
  capacity                  CallCapacity OPTIONAL,
  serviceControl            SEQUENCE OF ServiceControlSession OPTIONAL,
  featureSet                FeatureSet OPTIONAL,
  destinationInfo           EndpointType OPTIONAL,
  displayName               SEQUENCE OF DisplayName OPTIONAL
}

ReleaseCompleteReason ::= CHOICE {
  noBandwidth                  NULL, -- bandwidth taken away or ARQ denied
  gatekeeperResources          NULL, -- exhausted
  unreachableDestination       NULL, -- no transport path to the destination
  destinationRejection         NULL, -- rejected at destination
  invalidRevision              NULL,
  noPermission                 NULL, -- called party's gatekeeper rejects
  unreachableGatekeeper        NULL, -- terminal cannot reach gatekeeper

  -- for ARQ
  gatewayResources             NULL,
  badFormatAddress             NULL,
  adaptiveBusy                 NULL, -- call is dropping due to LAN crowding
  inConf                       NULL, -- called party busy
  undefinedReason              NULL,
  ...,
  facilityCallDeflection       NULL, -- call was deflected using a Facility

  -- message
  securityDenied               NULL, -- incompatible security settings
  calledPartyNotRegistered     NULL, -- used by gatekeeper when endpoint has

  -- preGrantedARQ to bypass ARQ/ACF
  callerNotRegistered          NULL, -- used by gatekeeper when endpoint has

  -- preGrantedARQ to bypass ARQ/ACF
  newConnectionNeeded          NULL, -- indicates that the Setup was not

  -- accepted on this connection, but that
  -- the Setup may be accepted on
  -- a new connection
  nonStandardReason            NonStandardParameter,
  replaceWithConferenceInvite  ConferenceIdentifier, -- call dropped due to

  -- subsequent invitation
  -- to a conference
  -- (see 8.4.3.8/H.323)
  genericDataReason            NULL,
  neededFeatureNotSupported    NULL,
  tunnelledSignallingRejected  NULL,
  invalidCID                   NULL,
  securityError                SecurityErrors,
  hopCountExceeded             NULL
}

Setup-UUIE ::= SEQUENCE {
  protocolIdentifier             ProtocolIdentifier,
  h245Address                    TransportAddress OPTIONAL,
  sourceAddress                  SEQUENCE OF AliasAddress OPTIONAL,
  sourceInfo                     EndpointType,
  destinationAddress             SEQUENCE OF AliasAddress OPTIONAL,
  destCallSignalAddress          TransportAddress OPTIONAL,
  destExtraCallInfo              SEQUENCE OF AliasAddress OPTIONAL,
  destExtraCRV                   SEQUENCE OF CallReferenceValue OPTIONAL,
  activeMC                       BOOLEAN,
  conferenceID                   ConferenceIdentifier,
  conferenceGoal
    CHOICE {create                               NULL,
            join                                 NULL,
            invite                               NULL,
            ...,
            capability-negotiation               NULL,
            callIndependentSupplementaryService  NULL},
  callServices                   QseriesOptions OPTIONAL,
  callType                       CallType,
  ...,
  sourceCallSignalAddress        TransportAddress OPTIONAL,
  remoteExtensionAddress         AliasAddress OPTIONAL,
  callIdentifier                 CallIdentifier,
  h245SecurityCapability         SEQUENCE OF H245Security OPTIONAL,
  tokens                         SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens                   SEQUENCE OF CryptoH323Token OPTIONAL,
  fastStart                      SEQUENCE OF OCTET STRING OPTIONAL,
  mediaWaitForConnect            BOOLEAN,
  canOverlapSend                 BOOLEAN,
  endpointIdentifier             EndpointIdentifier OPTIONAL,
  multipleCalls                  BOOLEAN,
  maintainConnection             BOOLEAN,
  connectionParameters
    SEQUENCE-- additional gateway parameters-- {connectionType
                                                  ScnConnectionType,
                                                numberOfScnConnections
                                                  INTEGER(0..65535),
                                                connectionAggregation
                                                  ScnConnectionAggregation,
                                                ...} OPTIONAL,
  language                       SEQUENCE OF IA5String(SIZE (1..32)) OPTIONAL,
  -- RFC 1766 language tag
  presentationIndicator          PresentationIndicator OPTIONAL,
  screeningIndicator             ScreeningIndicator OPTIONAL,
  serviceControl                 SEQUENCE OF ServiceControlSession OPTIONAL,
  symmetricOperationRequired     NULL OPTIONAL,
  capacity                       CallCapacity OPTIONAL,
  circuitInfo                    CircuitInfo OPTIONAL,
  desiredProtocols               SEQUENCE OF SupportedProtocols OPTIONAL,
  neededFeatures                 SEQUENCE OF FeatureDescriptor OPTIONAL,
  desiredFeatures                SEQUENCE OF FeatureDescriptor OPTIONAL,
  supportedFeatures              SEQUENCE OF FeatureDescriptor OPTIONAL,
  parallelH245Control            SEQUENCE OF OCTET STRING OPTIONAL,
  additionalSourceAddresses      SEQUENCE OF ExtendedAliasAddress OPTIONAL,
  hopCount                       INTEGER(1..31) OPTIONAL,
  displayName                    SEQUENCE OF DisplayName OPTIONAL
}

ScnConnectionType ::= CHOICE {
  unknown     NULL, -- should be selected when connection type is unknown
  bChannel    NULL, -- each individual connection on the SCN is 64 kbit/s.

  -- Note that where SCN delivers 56 kbit/s usable data,
  -- the actual bandwidth allocated on SCN is still
  -- 64 kbit/s.
  hybrid2x64  NULL, -- each connection is a 128 kbit/s hybrid call
  hybrid384   NULL, -- each connection is an H0 (384 kbit/s) hybrid call
  hybrid1536  NULL, -- each connection is an H11 (1536 kbit/s) hybrid call
  hybrid1920  NULL, -- each connection is an H12 (1920 kbit/s) hybrid call
  multirate   NULL, -- bandwidth supplied by SCN using multirate.

  -- In this case, the information transfer rate octet
  -- in the bearer capability shall be set to multirate
  -- and the rate multiplier octet shall denote the
  -- number of B channels.
  ...
}

ScnConnectionAggregation ::= CHOICE {
  auto          NULL, -- aggregation mechanism is unknown
  none          NULL, -- call produced using a single SCN connection
  h221          NULL, -- use H.221 framing to aggregate the connections
  bonded-mode1  NULL, -- use ISO/IEC 13871 bonding mode 1.

  -- Use bonded-mode1 to signal a bonded call if the
  -- precise bonding mode to be used is unknown.
  bonded-mode2  NULL, -- use ISO/IEC 13871 bonding mode 2
  bonded-mode3  NULL, -- use ISO/IEC 13871 bonding mode 3
  ...
}

PresentationIndicator ::= CHOICE {
  presentationAllowed     NULL,
  presentationRestricted  NULL,
  addressNotAvailable     NULL,
  ...
}

ScreeningIndicator ::= ENUMERATED {
  userProvidedNotScreened(0),
  -- number was provided by a remote user
  -- and has not been screened by a gatekeeper
  userProvidedVerifiedAndPassed(1),
  -- number was provided by user
  -- equipment (or by a remote network), and has
  -- been screened by a gatekeeper
  userProvidedVerifiedAndFailed(2),
  -- number was provided by user
  -- equipment (or by a remote network), and the
  -- gatekeeper has determined that the
  -- information is incorrect
  networkProvided(3),
  -- number was provided by a gatekeeper
  ...
  }

Facility-UUIE ::= SEQUENCE {
  protocolIdentifier         ProtocolIdentifier,
  alternativeAddress         TransportAddress OPTIONAL,
  alternativeAliasAddress    SEQUENCE OF AliasAddress OPTIONAL,
  conferenceID               ConferenceIdentifier OPTIONAL,
  reason                     FacilityReason,
  ...,
  callIdentifier             CallIdentifier,
  destExtraCallInfo          SEQUENCE OF AliasAddress OPTIONAL,
  remoteExtensionAddress     AliasAddress OPTIONAL,
  tokens                     SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens               SEQUENCE OF CryptoH323Token OPTIONAL,
  conferences                SEQUENCE OF ConferenceList OPTIONAL,
  h245Address                TransportAddress OPTIONAL,
  fastStart                  SEQUENCE OF OCTET STRING OPTIONAL,
  multipleCalls              BOOLEAN,
  maintainConnection         BOOLEAN,
  fastConnectRefused         NULL OPTIONAL,
  serviceControl             SEQUENCE OF ServiceControlSession OPTIONAL,
  circuitInfo                CircuitInfo OPTIONAL,
  featureSet                 FeatureSet OPTIONAL,
  destinationInfo            EndpointType OPTIONAL,
  h245SecurityMode           H245Security OPTIONAL
}

ConferenceList ::= SEQUENCE {
  conferenceID     ConferenceIdentifier OPTIONAL,
  conferenceAlias  AliasAddress OPTIONAL,
  nonStandardData  NonStandardParameter OPTIONAL,
  ...
}

FacilityReason ::= CHOICE {
  routeCallToGatekeeper   NULL, -- call must use gatekeeper model

  -- gatekeeper is alternativeAddress
  callForwarded           NULL,
  routeCallToMC           NULL,
  undefinedReason         NULL,
  ...,
  conferenceListChoice    NULL,
  startH245               NULL, -- recipient should connect to h245Address
  noH245                  NULL, -- endpoint does not support H.245
  newTokens               NULL,
  featureSetUpdate        NULL,
  forwardedElements       NULL,
  transportedInformation  NULL
}

Progress-UUIE ::= SEQUENCE {
  protocolIdentifier     ProtocolIdentifier,
  destinationInfo        EndpointType,
  h245Address            TransportAddress OPTIONAL,
  callIdentifier         CallIdentifier,
  h245SecurityMode       H245Security OPTIONAL,
  tokens                 SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens           SEQUENCE OF CryptoH323Token OPTIONAL,
  fastStart              SEQUENCE OF OCTET STRING OPTIONAL,
  ...,
  multipleCalls          BOOLEAN,
  maintainConnection     BOOLEAN,
  fastConnectRefused     NULL OPTIONAL
}

TransportAddress ::= CHOICE {
  ipAddress
    SEQUENCE {ip    OCTET STRING(SIZE (4)),
              port  INTEGER(0..65535)},
  ipSourceRoute
    SEQUENCE {ip       OCTET STRING(SIZE (4)),
              port     INTEGER(0..65535),
              route    SEQUENCE OF OCTET STRING(SIZE (4)),
              routing  CHOICE {strict  NULL,
                               loose   NULL,
                               ...},
              ...},
  ipxAddress
    SEQUENCE {node    OCTET STRING(SIZE (6)),
              netnum  OCTET STRING(SIZE (4)),
              port    OCTET STRING(SIZE (2))},
  ip6Address
    SEQUENCE {ip    OCTET STRING(SIZE (16)),
              port  INTEGER(0..65535),
              ...},
  netBios             OCTET STRING(SIZE (16)),
  nsap                OCTET STRING(SIZE (1..20)),
  nonStandardAddress  NonStandardParameter,
  ...
}

Status-UUIE ::= SEQUENCE {
  protocolIdentifier  ProtocolIdentifier,
  callIdentifier      CallIdentifier,
  tokens              SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens        SEQUENCE OF CryptoH323Token OPTIONAL,
  ...
}

StatusInquiry-UUIE ::= SEQUENCE {
  protocolIdentifier  ProtocolIdentifier,
  callIdentifier      CallIdentifier,
  tokens              SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens        SEQUENCE OF CryptoH323Token OPTIONAL,
  ...
}

SetupAcknowledge-UUIE ::= SEQUENCE {
  protocolIdentifier  ProtocolIdentifier,
  callIdentifier      CallIdentifier,
  tokens              SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens        SEQUENCE OF CryptoH323Token OPTIONAL,
  ...
}

Notify-UUIE ::= SEQUENCE {
  protocolIdentifier        ProtocolIdentifier,
  callIdentifier            CallIdentifier,
  tokens                    SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens              SEQUENCE OF CryptoH323Token OPTIONAL,
  ...,
  connectedAddress          SEQUENCE OF AliasAddress OPTIONAL,
  presentationIndicator     PresentationIndicator OPTIONAL,
  screeningIndicator        ScreeningIndicator OPTIONAL,
  destinationInfo           EndpointType OPTIONAL,
  displayName               SEQUENCE OF DisplayName OPTIONAL
}

-- Beginning of common message elements section
EndpointType ::= SEQUENCE {
  nonStandardData                 NonStandardParameter OPTIONAL,
  vendor                          VendorIdentifier OPTIONAL,
  gatekeeper                      GatekeeperInfo OPTIONAL,
  gateway                         GatewayInfo OPTIONAL,
  mcu                             McuInfo OPTIONAL, -- mc must be set as well
  terminal                        TerminalInfo OPTIONAL,
  mc                              BOOLEAN, -- shall not be set by itself
  undefinedNode                   BOOLEAN,
  ...,
  set                             BIT STRING(SIZE (32)) OPTIONAL,
  -- shall not be used with mc, gatekeeper
  -- code points for the various SET devices
  -- are defined in the respective SET Annexes
  supportedTunnelledProtocols     SEQUENCE OF TunnelledProtocol OPTIONAL
  -- list of supported tunnelled protocols
}

GatewayInfo ::= SEQUENCE {
  protocol         SEQUENCE OF SupportedProtocols OPTIONAL,
  nonStandardData  NonStandardParameter OPTIONAL,
  ...
}

SupportedProtocols ::= CHOICE {
  nonStandardData      NonStandardParameter,
  h310                 H310Caps,
  h320                 H320Caps,
  h321                 H321Caps,
  h322                 H322Caps,
  h323                 H323Caps,
  h324                 H324Caps,
  voice                VoiceCaps,
  t120-only            T120OnlyCaps,
  ...,
  nonStandardProtocol  NonStandardProtocol,
  t38FaxAnnexbOnly     T38FaxAnnexbOnlyCaps,
  sip                  SIPCaps
}

H310Caps ::= SEQUENCE {
  nonStandardData        NonStandardParameter OPTIONAL,
  ...,
  dataRatesSupported     SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes      SEQUENCE OF SupportedPrefix
}

H320Caps ::= SEQUENCE {
  nonStandardData        NonStandardParameter OPTIONAL,
  ...,
  dataRatesSupported     SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes      SEQUENCE OF SupportedPrefix
}

H321Caps ::= SEQUENCE {
  nonStandardData        NonStandardParameter OPTIONAL,
  ...,
  dataRatesSupported     SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes      SEQUENCE OF SupportedPrefix
}

H322Caps ::= SEQUENCE {
  nonStandardData        NonStandardParameter OPTIONAL,
  ...,
  dataRatesSupported     SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes      SEQUENCE OF SupportedPrefix
}

H323Caps ::= SEQUENCE {
  nonStandardData        NonStandardParameter OPTIONAL,
  ...,
  dataRatesSupported     SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes      SEQUENCE OF SupportedPrefix
}

H324Caps ::= SEQUENCE {
  nonStandardData        NonStandardParameter OPTIONAL,
  ...,
  dataRatesSupported     SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes      SEQUENCE OF SupportedPrefix
}

VoiceCaps ::= SEQUENCE {
  nonStandardData        NonStandardParameter OPTIONAL,
  ...,
  dataRatesSupported     SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes      SEQUENCE OF SupportedPrefix
}

T120OnlyCaps ::= SEQUENCE {
  nonStandardData        NonStandardParameter OPTIONAL,
  ...,
  dataRatesSupported     SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes      SEQUENCE OF SupportedPrefix
}

NonStandardProtocol ::= SEQUENCE {
  nonStandardData     NonStandardParameter OPTIONAL,
  dataRatesSupported  SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes   SEQUENCE OF SupportedPrefix,
  ...
}

T38FaxAnnexbOnlyCaps ::= SEQUENCE {
  nonStandardData     NonStandardParameter OPTIONAL,
  dataRatesSupported  SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes   SEQUENCE OF SupportedPrefix,
  t38FaxProtocol      DataProtocolCapability,
  t38FaxProfile       T38FaxProfile,
  ...
}

SIPCaps ::= SEQUENCE {
  nonStandardData     NonStandardParameter OPTIONAL,
  dataRatesSupported  SEQUENCE OF DataRate OPTIONAL,
  supportedPrefixes   SEQUENCE OF SupportedPrefix OPTIONAL,
  ...
}

McuInfo ::= SEQUENCE {
  nonStandardData  NonStandardParameter OPTIONAL,
  ...,
  protocol         SEQUENCE OF SupportedProtocols OPTIONAL
}

TerminalInfo ::= SEQUENCE {nonStandardData  NonStandardParameter OPTIONAL,
                           ...
}

GatekeeperInfo ::= SEQUENCE {
  nonStandardData  NonStandardParameter OPTIONAL,
  ...
}

VendorIdentifier ::= SEQUENCE {
  vendor               H221NonStandard,
  productId            OCTET STRING(SIZE (1..256)) OPTIONAL, -- per vendor
  versionId            OCTET STRING(SIZE (1..256)) OPTIONAL, -- per product
  ...,
  enterpriseNumber     OBJECT IDENTIFIER OPTIONAL
}

H221NonStandard ::= SEQUENCE {
  t35CountryCode    INTEGER(0..255),
  t35Extension      INTEGER(0..255),
  manufacturerCode  INTEGER(0..65535),
  ...
}

TunnelledProtocol ::= SEQUENCE {
  id
    CHOICE {tunnelledProtocolObjectID     OBJECT IDENTIFIER,
            tunnelledProtocolAlternateID  TunnelledProtocolAlternateIdentifier,
            ...},
  subIdentifier  IA5String(SIZE (1..64)) OPTIONAL,
  ...
}

TunnelledProtocolAlternateIdentifier ::= SEQUENCE {
  protocolType     IA5String(SIZE (1..64)),
  protocolVariant  IA5String(SIZE (1..64)) OPTIONAL,
  ...
}

NonStandardParameter ::= SEQUENCE {
  nonStandardIdentifier  NonStandardIdentifier,
  data                   OCTET STRING
}

NonStandardIdentifier ::= CHOICE {
  object           OBJECT IDENTIFIER,
  h221NonStandard  H221NonStandard,
  ...
}

AliasAddress ::= CHOICE {
  dialledDigits  IA5String(SIZE (1..128))(FROM ("0123456789#*,")),
  h323-ID        BMPString(SIZE (1..256)), -- Basic ISO/IEC 10646 (Unicode)
  ...,
  url-ID         IA5String(SIZE (1..512)), -- URL style address
  transportID    TransportAddress,
  email-ID       IA5String(SIZE (1..512)), -- rfc822-compliant email address
  partyNumber    PartyNumber,
  mobileUIM      MobileUIM,
  isupNumber     IsupNumber
}

AddressPattern ::= CHOICE {
  wildcard  AliasAddress,
  range     SEQUENCE {startOfRange  PartyNumber,
                      endOfRange    PartyNumber},
  ...
}

PartyNumber ::= CHOICE {
  e164Number                   PublicPartyNumber,
  -- the numbering plan is according to
  -- ITUT Recs E.163 and E.164.
  dataPartyNumber              NumberDigits,
  -- not used, value reserved.
  telexPartyNumber             NumberDigits,
  -- not used, value reserved.
  privateNumber                PrivatePartyNumber,
  -- the numbering plan is according to
  -- ISO/IEC 11571.
  nationalStandardPartyNumber  NumberDigits,
  -- not used, value reserved.
  ...
}

PublicPartyNumber ::= SEQUENCE {
  publicTypeOfNumber  PublicTypeOfNumber,
  publicNumberDigits  NumberDigits
}

PrivatePartyNumber ::= SEQUENCE {
  privateTypeOfNumber  PrivateTypeOfNumber,
  privateNumberDigits  NumberDigits
}

NumberDigits ::= IA5String(SIZE (1..128))(FROM ("0123456789#*,"))

DisplayName ::= SEQUENCE {
  language  IA5String OPTIONAL, -- RFC4646 language tag
  name      BMPString(SIZE (1..80))
}

PublicTypeOfNumber ::= CHOICE {
  unknown                NULL,
  -- if used number digits carry prefix
  -- indicating type
  -- of number according to national
  -- recommendations.
  internationalNumber    NULL,
  nationalNumber         NULL,
  networkSpecificNumber  NULL,
  -- not used, value reserved
  subscriberNumber       NULL,
  abbreviatedNumber      NULL,
  -- valid only for called party number at
  -- the outgoing access, network
  -- substitutes
  -- appropriate number.
  ...
}

PrivateTypeOfNumber ::= CHOICE {
  unknown               NULL,
  level2RegionalNumber  NULL,
  level1RegionalNumber  NULL,
  pISNSpecificNumber    NULL,
  localNumber           NULL,
  abbreviatedNumber     NULL,
  ...
}

MobileUIM ::= CHOICE {
  ansi-41-uim  ANSI-41-UIM, -- Americas standards Wireless Networks
  gsm-uim      GSM-UIM, -- European standards Wireless Networks
  ...
}

TBCD-STRING ::= IA5String(FROM ("0123456789#*abc"))

ANSI-41-UIM ::= SEQUENCE {
  imsi                          TBCD-STRING(SIZE (3..16)) OPTIONAL,
  min                           TBCD-STRING(SIZE (3..16)) OPTIONAL,
  mdn                           TBCD-STRING(SIZE (3..16)) OPTIONAL,
  msisdn                        TBCD-STRING(SIZE (3..16)) OPTIONAL,
  esn                           TBCD-STRING(SIZE (16)) OPTIONAL,
  mscid                         TBCD-STRING(SIZE (3..16)) OPTIONAL,
  system-id
    CHOICE {sid  TBCD-STRING(SIZE (1..4)),
            mid  TBCD-STRING(SIZE (1..4)),
            ...},
  systemMyTypeCode              OCTET STRING(SIZE (1)) OPTIONAL,
  systemAccessType              OCTET STRING(SIZE (1)) OPTIONAL,
  qualificationInformationCode  OCTET STRING(SIZE (1)) OPTIONAL,
  sesn                          TBCD-STRING(SIZE (16)) OPTIONAL,
  soc                           TBCD-STRING(SIZE (3..16)) OPTIONAL,
  ...
  -- IMSI refers to International Mobile Station Identification
  -- MIN refers to Mobile Identification Number
  -- MDN refers to Mobile Directory Number
  -- MSISDN refers to Mobile Station ISDN number
  -- ESN Refers to Electronic Serial Number
  -- MSCID refers to Mobile Switching Center number + Market ID or System ID
  -- SID refers to System Identification and MID refers to Market
  -- Identification
  -- SystemMyTypeCode refers to vendor identification number
  -- SystemAccessType refers to the system access type like power down
  -- registration or call
  -- origination or Short Message response etc.
  -- Qualification Information Code refers to the validity
  -- SESN Refers to SIM Electronic Serial Number for Security purposes of
  -- User Identification
  -- SOC refers to System Operator Code
}

GSM-UIM ::= SEQUENCE {
  imsi    TBCD-STRING(SIZE (3..16)) OPTIONAL,
  tmsi    OCTET STRING(SIZE (1..4)) OPTIONAL,
  msisdn  TBCD-STRING(SIZE (3..16)) OPTIONAL,
  imei    TBCD-STRING(SIZE (15..16)) OPTIONAL,
  hplmn   TBCD-STRING(SIZE (1..4)) OPTIONAL,
  vplmn   TBCD-STRING(SIZE (1..4)) OPTIONAL,
  -- IMSI refers to International Mobile Station Identification
  -- MSISDN refers to Mobile Station ISDN number
  -- IMEI Refers to International Mobile Equipment Identification
  -- VPLMN or HPLMN refers to Visiting or Home Public Land Mobile Network
  -- number
  ...
}

IsupNumber ::= CHOICE {
  e164Number                   IsupPublicPartyNumber,
  -- the numbering plan is according to
  -- ITUT Recs E.163 and E.164.
  dataPartyNumber              IsupDigits, -- not used, value reserved.
  telexPartyNumber             IsupDigits, -- not used, value reserved.
  privateNumber                IsupPrivatePartyNumber,
  -- the numbering plan is according to
  -- ISO/IEC 11571.
  nationalStandardPartyNumber  IsupDigits, -- not used, value reserved.
  ...
}

IsupPublicPartyNumber ::= SEQUENCE {
  natureOfAddress  NatureOfAddress,
  address          IsupDigits,
  ...
}

IsupPrivatePartyNumber ::= SEQUENCE {
  privateTypeOfNumber  PrivateTypeOfNumber,
  address              IsupDigits,
  ...
}

NatureOfAddress ::= CHOICE {
  unknown                                 NULL,
  subscriberNumber                        NULL,
  nationalNumber                          NULL,
  internationalNumber                     NULL,
  networkSpecificNumber                   NULL,
  routingNumberNationalFormat             NULL,
  routingNumberNetworkSpecificFormat      NULL,
  routingNumberWithCalledDirectoryNumber  NULL,
  ...
}

IsupDigits ::= IA5String(SIZE (1..128))(FROM ("0123456789ABCDE"))

ExtendedAliasAddress ::= SEQUENCE {
  address                AliasAddress,
  presentationIndicator  PresentationIndicator OPTIONAL,
  screeningIndicator     ScreeningIndicator OPTIONAL,
  ...
}

Endpoint ::= SEQUENCE {
  nonStandardData                 NonStandardParameter OPTIONAL,
  aliasAddress                    SEQUENCE OF AliasAddress OPTIONAL,
  callSignalAddress               SEQUENCE OF TransportAddress OPTIONAL,
  rasAddress                      SEQUENCE OF TransportAddress OPTIONAL,
  endpointType                    EndpointType OPTIONAL,
  tokens                          SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens                    SEQUENCE OF CryptoH323Token OPTIONAL,
  priority                        INTEGER(0..127) OPTIONAL,
  remoteExtensionAddress          SEQUENCE OF AliasAddress OPTIONAL,
  destExtraCallInfo               SEQUENCE OF AliasAddress OPTIONAL,
  ...,
  alternateTransportAddresses     AlternateTransportAddresses OPTIONAL,
  circuitInfo                     CircuitInfo OPTIONAL,
  featureSet                      FeatureSet OPTIONAL
}

AlternateTransportAddresses ::= SEQUENCE {
  annexE   SEQUENCE OF TransportAddress OPTIONAL,
  ...,
  sctp     SEQUENCE OF TransportAddress OPTIONAL
}

UseSpecifiedTransport ::= CHOICE {tcp     NULL,
                                  annexE  NULL,
                                  ...,
                                  sctp    NULL
}

AlternateGK ::= SEQUENCE {
  rasAddress            TransportAddress,
  gatekeeperIdentifier  GatekeeperIdentifier OPTIONAL,
  needToRegister        BOOLEAN,
  priority              INTEGER(0..127),
  ...
}

AltGKInfo ::= SEQUENCE {
  alternateGatekeeper  SEQUENCE OF AlternateGK,
  altGKisPermanent     BOOLEAN,
  ...
}

SecurityServiceMode ::= CHOICE {
  nonStandard  NonStandardParameter,
  none         NULL,
  default      NULL,
  ... -- can be extended with other specific modes
}

SecurityCapabilities ::= SEQUENCE {
  nonStandard    NonStandardParameter OPTIONAL,
  encryption     SecurityServiceMode,
  authenticaton  SecurityServiceMode,
  integrity      SecurityServiceMode,
  ...
}

SecurityErrors ::= CHOICE {
  securityWrongSyncTime                 NULL, -- either time server

  -- problem or network delay
  securityReplay                        NULL, -- replay attack encountered
  securityWrongGeneralID                NULL, -- wrong general ID
  securityWrongSendersID                NULL, -- wrong senders ID
  securityIntegrityFailed               NULL, -- integrity check failed
  securityWrongOID                      NULL, -- wrong token OIDs or crypto alg

  -- OIDs
  securityDHmismatch                    NULL, -- mismatch of DH parameters
  securityCertificateExpired            NULL, -- certificate has expired
  securityCertificateDateInvalid        NULL, -- certificate is not yet valid
  securityCertificateRevoked            NULL, -- certificate was found revoked
  securityCertificateNotReadable        NULL, -- decoding error
  securityCertificateSignatureInvalid   NULL, -- wrong signature in the

  -- certificate
  securityCertificateMissing            NULL, -- no certificate available
  securityCertificateIncomplete         NULL, -- missing expected certificate

  -- extensions
  securityUnsupportedCertificateAlgOID  NULL, -- crypto algs not understood
  securityUnknownCA                     NULL, -- CA/root certificate could not

  -- be found
  ...
}

SecurityErrors2 ::= CHOICE {
  securityWrongSyncTime    NULL, -- either time server problem or network

  -- delay
  securityReplay           NULL, -- replay attack encountered
  securityWrongGeneralID   NULL, -- wrong general ID
  securityWrongSendersID   NULL, -- wrong senders ID
  securityIntegrityFailed  NULL, -- integrity check failed
  securityWrongOID         NULL, -- wrong token OIDs or crypto alg OIDs
  ...
}

H245Security ::= CHOICE {
  nonStandard  NonStandardParameter,
  noSecurity   NULL,
  tls          SecurityCapabilities,
  ipsec        SecurityCapabilities,
  ...
}

QseriesOptions ::= SEQUENCE {
  q932Full  BOOLEAN, -- if true, indicates full support for Q.932
  q951Full  BOOLEAN, -- if true, indicates full support for Q.951
  q952Full  BOOLEAN, -- if true, indicates full support for Q.952
  q953Full  BOOLEAN, -- if true, indicates full support for Q.953
  q955Full  BOOLEAN, -- if true, indicates full support for Q.955
  q956Full  BOOLEAN, -- if true, indicates full support for Q.956
  q957Full  BOOLEAN, -- if true, indicates full support for Q.957
  q954Info  Q954Details,
  ...
}

Q954Details ::= SEQUENCE {
  conferenceCalling  BOOLEAN,
  threePartyService  BOOLEAN,
  ...
}

GloballyUniqueID ::= OCTET STRING(SIZE (16))

ConferenceIdentifier ::= GloballyUniqueID

RequestSeqNum ::= INTEGER(1..65535)

GatekeeperIdentifier ::= BMPString(SIZE (1..128))

BandWidth ::= INTEGER(0..4294967295) -- in 100s of bits


CallReferenceValue ::= INTEGER(0..65535)

EndpointIdentifier ::= BMPString(SIZE (1..128))

ProtocolIdentifier ::= OBJECT IDENTIFIER

TimeToLive ::= INTEGER(1..4294967295) -- in seconds


H248PackagesDescriptor ::= OCTET STRING -- This octet string contains ASN.1

-- PER encoded H.248
-- PackagesDescriptor
H248SignalsDescriptor ::= OCTET STRING -- This octet string contains

-- ASN.1 PER encoded H.248
-- SignalsDescriptor.
FeatureDescriptor ::=
  GenericData

CallIdentifier ::= SEQUENCE {guid  GloballyUniqueID,
                             ...
}

EncryptIntAlg ::=
  CHOICE { -- core encryption algorithms for RAS message integrity
  nonStandard   NonStandardParameter,
  isoAlgorithm  OBJECT IDENTIFIER, -- defined in ISO/IEC 9979
  ...
}

NonIsoIntegrityMechanism ::=
  CHOICE { -- HMAC mechanism used, no truncation, tagging may be necessary!
  hMAC-MD5           NULL,
  hMAC-iso10118-2-s  EncryptIntAlg, -- according to ISO/IEC 10118-2 using

  -- EncryptIntAlg as core block
  -- encryption algorithm (short MAC)
  hMAC-iso10118-2-l  EncryptIntAlg, -- according to ISO/IEC 10118-2 using

  -- EncryptIntAlg as core block
  -- encryption algorithm (long MAC)
  hMAC-iso10118-3    OBJECT IDENTIFIER, -- according to ISO/IEC 10118-3 using

  -- OID as hash function (OID is
  -- SHA-1,
  -- RIPE-MD160,
  -- RIPE-MD128)
  ...
}

IntegrityMechanism ::= CHOICE { -- for RAS message integrity
  nonStandard  NonStandardParameter,
  digSig       NULL, -- indicates to apply a digital signature
  iso9797      OBJECT IDENTIFIER, -- according to ISO/IEC 9797 using OID as

  -- core encryption algorithm (X-CBC MAC)
  nonIsoIM     NonIsoIntegrityMechanism,
  ...
}

ICV ::= SEQUENCE {
  algorithmOID  OBJECT IDENTIFIER, -- the algorithm used to compute the

  -- signature
  icv           BIT STRING-- the computed cryptographic --
  -- integrity check value or signature
}

FastStartToken ::=
  ClearToken
    (WITH COMPONENTS {
       ...,
       timeStamp  PRESENT,
       dhkey      PRESENT,
       generalID  PRESENT

     -- set to "alias" --})

EncodedFastStartToken ::= TYPE-IDENTIFIER.&Type(FastStartToken)

CryptoH323Token ::= CHOICE {
  cryptoEPPwdHash
    SEQUENCE {alias      AliasAddress, -- alias of entity generating hash--
              timeStamp  TimeStamp, -- timestamp used in hash--
              token
                HASHED{EncodedPwdCertToken-- generalID set to --
                      -- "alias" -- }},
  cryptoGKPwdHash
    SEQUENCE {gatekeeperId  GatekeeperIdentifier, -- GatekeeperID of GK generating --
              -- hash
              timeStamp     TimeStamp, -- timestamp used in hash--
              token
                HASHED{EncodedPwdCertToken-- generalID set to --
                      -- Gatekeeperid -- }},
  cryptoEPPwdEncr
    ENCRYPTED{EncodedPwdCertToken-- generalID set to --
             -- Gatekeeperid -- },
  cryptoGKPwdEncr
    ENCRYPTED{EncodedPwdCertToken-- generalID set to --
             -- Gatekeeperid -- },
  cryptoEPCert
    SIGNED{EncodedPwdCertToken-- generalID set to --
          -- Gatekeeperid -- },
  cryptoGKCert       SIGNED{EncodedPwdCertToken-- generalID set to alias -- },
  cryptoFastStart    SIGNED{EncodedFastStartToken},
  nestedcryptoToken  CryptoToken,
  ...
}

DataRate ::= SEQUENCE {
  nonStandardData    NonStandardParameter OPTIONAL,
  channelRate        BandWidth,
  channelMultiplier  INTEGER(1..256) OPTIONAL,
  ...
}

CallLinkage ::= SEQUENCE {
  globalCallId  GloballyUniqueID OPTIONAL,
  threadId      GloballyUniqueID OPTIONAL,
  ...
}

SupportedPrefix ::= SEQUENCE {
  nonStandardData  NonStandardParameter OPTIONAL,
  prefix           AliasAddress,
  ...
}

CapacityReportingCapability ::= SEQUENCE {canReportCallCapacity  BOOLEAN,
                                          ...
}

CapacityReportingSpecification ::= SEQUENCE {
  when  SEQUENCE {callStart  NULL OPTIONAL,
                  callEnd    NULL OPTIONAL,
                  ...},
  ...
}

CallCapacity ::= SEQUENCE {
  maximumCallCapacity  CallCapacityInfo OPTIONAL,
  currentCallCapacity  CallCapacityInfo OPTIONAL,
  ...
}

CallCapacityInfo ::= SEQUENCE {
  voiceGwCallsAvailable             SEQUENCE OF CallsAvailable OPTIONAL,
  h310GwCallsAvailable              SEQUENCE OF CallsAvailable OPTIONAL,
  h320GwCallsAvailable              SEQUENCE OF CallsAvailable OPTIONAL,
  h321GwCallsAvailable              SEQUENCE OF CallsAvailable OPTIONAL,
  h322GwCallsAvailable              SEQUENCE OF CallsAvailable OPTIONAL,
  h323GwCallsAvailable              SEQUENCE OF CallsAvailable OPTIONAL,
  h324GwCallsAvailable              SEQUENCE OF CallsAvailable OPTIONAL,
  t120OnlyGwCallsAvailable          SEQUENCE OF CallsAvailable OPTIONAL,
  t38FaxAnnexbOnlyGwCallsAvailable  SEQUENCE OF CallsAvailable OPTIONAL,
  terminalCallsAvailable            SEQUENCE OF CallsAvailable OPTIONAL,
  mcuCallsAvailable                 SEQUENCE OF CallsAvailable OPTIONAL,
  ...,
  sipGwCallsAvailable               SEQUENCE OF CallsAvailable OPTIONAL
}

CallsAvailable ::= SEQUENCE {
  calls       INTEGER(0..4294967295),
  group       IA5String(SIZE (1..128)) OPTIONAL,
  ...,
  carrier     CarrierInfo OPTIONAL
}

CircuitInfo ::= SEQUENCE {
  sourceCircuitID       CircuitIdentifier OPTIONAL,
  destinationCircuitID  CircuitIdentifier OPTIONAL,
  genericData           SEQUENCE OF GenericData OPTIONAL,
  ...
}

CircuitIdentifier ::= SEQUENCE {
  cic         CicInfo OPTIONAL,
  group       GroupID OPTIONAL,
  ...,
  carrier     CarrierInfo OPTIONAL
}

CicInfo ::= SEQUENCE {
  cic        SEQUENCE OF OCTET STRING(SIZE (2..4)),
  pointCode  OCTET STRING(SIZE (2..5)),
  ...
}

GroupID ::= SEQUENCE {
  member  SEQUENCE OF INTEGER(0..65535) OPTIONAL,
  group   IA5String(SIZE (1..128)),
  ...
}

CarrierInfo ::= SEQUENCE {
  carrierIdentificationCode  OCTET STRING(SIZE (3..4)) OPTIONAL,
  carrierName                IA5String(SIZE (1..128)) OPTIONAL,
  ...
}

ServiceControlDescriptor ::= CHOICE {
  url                       IA5String(SIZE (0..512)), -- indicates a URL-

  -- referenced
  -- protocol/resource
  signal                    H248SignalsDescriptor,
  nonStandard               NonStandardParameter,
  callCreditServiceControl  CallCreditServiceControl,
  ...
}

ServiceControlSession ::= SEQUENCE {
  sessionId  INTEGER(0..255),
  contents   ServiceControlDescriptor OPTIONAL,
  reason     CHOICE {open     NULL,
                     refresh  NULL,
                     close    NULL,
                     ...},
  ...
}

RasUsageInfoTypes ::= SEQUENCE {
  nonStandardUsageTypes  SEQUENCE OF NonStandardParameter,
  startTime              NULL OPTIONAL,
  endTime                NULL OPTIONAL,
  terminationCause       NULL OPTIONAL,
  ...
}

RasUsageSpecification ::= SEQUENCE {
  when
    SEQUENCE {start  NULL OPTIONAL,
              end    NULL OPTIONAL,
              inIrr  NULL OPTIONAL,
              ...},
  callStartingPoint
    SEQUENCE {alerting  NULL OPTIONAL,
              connect   NULL OPTIONAL,
              ...} OPTIONAL,
  required           RasUsageInfoTypes,
  ...
}

RasUsageInformation ::= SEQUENCE {
  nonStandardUsageFields  SEQUENCE OF NonStandardParameter,
  alertingTime            TimeStamp OPTIONAL,
  connectTime             TimeStamp OPTIONAL,
  endTime                 TimeStamp OPTIONAL,
  ...
}

CallTerminationCause ::= CHOICE {
  releaseCompleteReason   ReleaseCompleteReason,
  releaseCompleteCauseIE  OCTET STRING(SIZE (2..32)),
  ...
}

BandwidthDetails ::= SEQUENCE {
  sender         BOOLEAN, -- TRUE=sender, FALSE=receiver
  multicast      BOOLEAN, -- TRUE if stream is multicast
  bandwidth      BandWidth, -- Bandwidth used for stream
  rtcpAddresses  TransportChannelInfo, -- RTCP addresses for media stream
  ...
}

CallCreditCapability ::= SEQUENCE {
  canDisplayAmountString   BOOLEAN OPTIONAL,
  canEnforceDurationLimit  BOOLEAN OPTIONAL,
  ...
}

CallCreditServiceControl ::= SEQUENCE {
  amountString              BMPString(SIZE (1..512)) OPTIONAL, -- (Unicode)
  billingMode               CHOICE {credit  NULL,
                                    debit   NULL,
                                    ...} OPTIONAL,
  callDurationLimit         INTEGER(1..4294967295) OPTIONAL, -- in seconds
  enforceCallDurationLimit  BOOLEAN OPTIONAL,
  callStartingPoint         CHOICE {alerting  NULL,
                                    connect   NULL,
                                    ...} OPTIONAL,
  ...
}

GenericData ::= SEQUENCE {
  id          GenericIdentifier,
  parameters  SEQUENCE (SIZE (1..512)) OF EnumeratedParameter OPTIONAL,
  ...
}

GenericIdentifier ::= CHOICE {
  standard     INTEGER(0..16383, ...),
  oid          OBJECT IDENTIFIER,
  nonStandard  GloballyUniqueID,
  ...
}

EnumeratedParameter ::= SEQUENCE {
  id       GenericIdentifier,
  content  Content OPTIONAL,
  ...
}

Content ::= CHOICE {
  raw        OCTET STRING,
  text       IA5String,
  unicode    BMPString,
  bool       BOOLEAN,
  number8    INTEGER(0..255),
  number16   INTEGER(0..65535),
  number32   INTEGER(0..4294967295),
  id         GenericIdentifier,
  alias      AliasAddress,
  transport  TransportAddress,
  compound   SEQUENCE (SIZE (1..512)) OF EnumeratedParameter,
  nested     SEQUENCE (SIZE (1..16)) OF GenericData,
  ...
}

FeatureSet ::= SEQUENCE {
  replacementFeatureSet  BOOLEAN,
  neededFeatures         SEQUENCE OF FeatureDescriptor OPTIONAL,
  desiredFeatures        SEQUENCE OF FeatureDescriptor OPTIONAL,
  supportedFeatures      SEQUENCE OF FeatureDescriptor OPTIONAL,
  ...
}

TransportChannelInfo ::= SEQUENCE {
  sendAddress  TransportAddress OPTIONAL,
  recvAddress  TransportAddress OPTIONAL,
  ...
}

RTPSession ::= SEQUENCE {
  rtpAddress            TransportChannelInfo,
  rtcpAddress           TransportChannelInfo,
  cname                 PrintableString,
  ssrc                  INTEGER(1..4294967295),
  sessionId             INTEGER(1..255),
  associatedSessionIds  SEQUENCE OF INTEGER(1..255),
  ...,
  multicast             NULL OPTIONAL,
  bandwidth             BandWidth OPTIONAL
}

RehomingModel ::= CHOICE {gatekeeperBased  NULL,
                          endpointBased    NULL
}

RasMessage ::= CHOICE {
  gatekeeperRequest           GatekeeperRequest,
  gatekeeperConfirm           GatekeeperConfirm,
  gatekeeperReject            GatekeeperReject,
  registrationRequest         RegistrationRequest,
  registrationConfirm         RegistrationConfirm,
  registrationReject          RegistrationReject,
  unregistrationRequest       UnregistrationRequest,
  unregistrationConfirm       UnregistrationConfirm,
  unregistrationReject        UnregistrationReject,
  admissionRequest            AdmissionRequest,
  admissionConfirm            AdmissionConfirm,
  admissionReject             AdmissionReject,
  bandwidthRequest            BandwidthRequest,
  bandwidthConfirm            BandwidthConfirm,
  bandwidthReject             BandwidthReject,
  disengageRequest            DisengageRequest,
  disengageConfirm            DisengageConfirm,
  disengageReject             DisengageReject,
  locationRequest             LocationRequest,
  locationConfirm             LocationConfirm,
  locationReject              LocationReject,
  infoRequest                 InfoRequest,
  infoRequestResponse         InfoRequestResponse,
  nonStandardMessage          NonStandardMessage,
  unknownMessageResponse      UnknownMessageResponse,
  ...,
  requestInProgress           RequestInProgress,
  resourcesAvailableIndicate  ResourcesAvailableIndicate,
  resourcesAvailableConfirm   ResourcesAvailableConfirm,
  infoRequestAck              InfoRequestAck,
  infoRequestNak              InfoRequestNak,
  serviceControlIndication    ServiceControlIndication,
  serviceControlResponse      ServiceControlResponse,
  admissionConfirmSequence    SEQUENCE OF AdmissionConfirm
}

GatekeeperRequest ::= SEQUENCE --(GRQ)
                       {
  requestSeqNum                RequestSeqNum,
  protocolIdentifier           ProtocolIdentifier,
  nonStandardData              NonStandardParameter OPTIONAL,
  rasAddress                   TransportAddress,
  endpointType                 EndpointType,
  gatekeeperIdentifier         GatekeeperIdentifier OPTIONAL,
  callServices                 QseriesOptions OPTIONAL,
  endpointAlias                SEQUENCE OF AliasAddress OPTIONAL,
  ...,
  alternateEndpoints           SEQUENCE OF Endpoint OPTIONAL,
  tokens                       SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens                 SEQUENCE OF CryptoH323Token OPTIONAL,
  authenticationCapability     SEQUENCE OF AuthenticationMechanism OPTIONAL,
  algorithmOIDs                SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
  integrity                    SEQUENCE OF IntegrityMechanism OPTIONAL,
  integrityCheckValue          ICV OPTIONAL,
  supportsAltGK                NULL OPTIONAL,
  featureSet                   FeatureSet OPTIONAL,
  genericData                  SEQUENCE OF GenericData OPTIONAL,
  supportsAssignedGK           BOOLEAN,
  assignedGatekeeper           AlternateGK OPTIONAL
}

GatekeeperConfirm ::= SEQUENCE --(GCF)
                       {
  requestSeqNum           RequestSeqNum,
  protocolIdentifier      ProtocolIdentifier,
  nonStandardData         NonStandardParameter OPTIONAL,
  gatekeeperIdentifier    GatekeeperIdentifier OPTIONAL,
  rasAddress              TransportAddress,
  ...,
  alternateGatekeeper     SEQUENCE OF AlternateGK OPTIONAL,
  authenticationMode      AuthenticationMechanism OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  algorithmOID            OBJECT IDENTIFIER OPTIONAL,
  integrity               SEQUENCE OF IntegrityMechanism OPTIONAL,
  integrityCheckValue     ICV OPTIONAL,
  featureSet              FeatureSet OPTIONAL,
  genericData             SEQUENCE OF GenericData OPTIONAL,
  assignedGatekeeper      AlternateGK OPTIONAL,
  rehomingModel           RehomingModel OPTIONAL
}

GatekeeperReject ::= SEQUENCE --(GRJ)
                      {
  requestSeqNum           RequestSeqNum,
  protocolIdentifier      ProtocolIdentifier,
  nonStandardData         NonStandardParameter OPTIONAL,
  gatekeeperIdentifier    GatekeeperIdentifier OPTIONAL,
  rejectReason            GatekeeperRejectReason,
  ...,
  altGKInfo               AltGKInfo OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL,
  featureSet              FeatureSet OPTIONAL,
  genericData             SEQUENCE OF GenericData OPTIONAL
}

GatekeeperRejectReason ::= CHOICE {
  resourceUnavailable        NULL,
  terminalExcluded           NULL, -- permission failure, not a resource

  -- failure
  invalidRevision            NULL,
  undefinedReason            NULL,
  ...,
  securityDenial             NULL,
  genericDataReason          NULL,
  neededFeatureNotSupported  NULL,
  securityError              SecurityErrors
}

RegistrationRequest ::= SEQUENCE --(RRQ)
                         {
  requestSeqNum                   RequestSeqNum,
  protocolIdentifier              ProtocolIdentifier,
  nonStandardData                 NonStandardParameter OPTIONAL,
  discoveryComplete               BOOLEAN,
  callSignalAddress               SEQUENCE OF TransportAddress,
  rasAddress                      SEQUENCE OF TransportAddress,
  terminalType                    EndpointType,
  terminalAlias                   SEQUENCE OF AliasAddress OPTIONAL,
  gatekeeperIdentifier            GatekeeperIdentifier OPTIONAL,
  endpointVendor                  VendorIdentifier,
  ...,
  alternateEndpoints              SEQUENCE OF Endpoint OPTIONAL,
  timeToLive                      TimeToLive OPTIONAL,
  tokens                          SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens                    SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue             ICV OPTIONAL,
  keepAlive                       BOOLEAN,
  endpointIdentifier              EndpointIdentifier OPTIONAL,
  willSupplyUUIEs                 BOOLEAN,
  maintainConnection              BOOLEAN,
  alternateTransportAddresses     AlternateTransportAddresses OPTIONAL,
  additiveRegistration            NULL OPTIONAL,
  terminalAliasPattern            SEQUENCE OF AddressPattern OPTIONAL,
  supportsAltGK                   NULL OPTIONAL,
  usageReportingCapability        RasUsageInfoTypes OPTIONAL,
  multipleCalls                   BOOLEAN OPTIONAL,
  supportedH248Packages           SEQUENCE OF H248PackagesDescriptor OPTIONAL,
  callCreditCapability            CallCreditCapability OPTIONAL,
  capacityReportingCapability     CapacityReportingCapability OPTIONAL,
  capacity                        CallCapacity OPTIONAL,
  featureSet                      FeatureSet OPTIONAL,
  genericData                     SEQUENCE OF GenericData OPTIONAL,
  restart                         NULL OPTIONAL,
  supportsACFSequences            NULL OPTIONAL,
  supportsAssignedGK              BOOLEAN,
  assignedGatekeeper              AlternateGK OPTIONAL,
  transportQOS                    TransportQOS OPTIONAL,
  language                        SEQUENCE OF IA5String(SIZE (1..32)) OPTIONAL
}

RegistrationConfirm ::= SEQUENCE --(RCF)
                         {
  requestSeqNum                    RequestSeqNum,
  protocolIdentifier               ProtocolIdentifier,
  nonStandardData                  NonStandardParameter OPTIONAL,
  callSignalAddress                SEQUENCE OF TransportAddress,
  terminalAlias                    SEQUENCE OF AliasAddress OPTIONAL,
  gatekeeperIdentifier             GatekeeperIdentifier OPTIONAL,
  endpointIdentifier               EndpointIdentifier,
  ...,
  alternateGatekeeper              SEQUENCE OF AlternateGK OPTIONAL,
  timeToLive                       TimeToLive OPTIONAL,
  tokens                           SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens                     SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue              ICV OPTIONAL,
  willRespondToIRR                 BOOLEAN,
  preGrantedARQ
    SEQUENCE {makeCall                          BOOLEAN,
              useGKCallSignalAddressToMakeCall  BOOLEAN,
              answerCall                        BOOLEAN,
              useGKCallSignalAddressToAnswer    BOOLEAN,
              ...,
              irrFrequencyInCall                INTEGER(1..65535) OPTIONAL, -- in seconds; --
              -- not present
              -- if GK does
              -- not want IRRs
              totalBandwidthRestriction         BandWidth OPTIONAL, -- total limit --
              -- for all
              -- concurrent
              -- calls
              alternateTransportAddresses
                AlternateTransportAddresses OPTIONAL,
              useSpecifiedTransport             UseSpecifiedTransport OPTIONAL
  } OPTIONAL,
  maintainConnection               BOOLEAN,
  serviceControl                   SEQUENCE OF ServiceControlSession OPTIONAL,
  supportsAdditiveRegistration     NULL OPTIONAL,
  terminalAliasPattern             SEQUENCE OF AddressPattern OPTIONAL,
  supportedPrefixes                SEQUENCE OF SupportedPrefix OPTIONAL,
  usageSpec                        SEQUENCE OF RasUsageSpecification OPTIONAL,
  featureServerAlias               AliasAddress OPTIONAL,
  capacityReportingSpec            CapacityReportingSpecification OPTIONAL,
  featureSet                       FeatureSet OPTIONAL,
  genericData                      SEQUENCE OF GenericData OPTIONAL,
  assignedGatekeeper               AlternateGK OPTIONAL,
  rehomingModel                    RehomingModel OPTIONAL,
  transportQOS                     TransportQOS OPTIONAL
}

RegistrationReject ::= SEQUENCE --(RRJ)
                        {
  requestSeqNum           RequestSeqNum,
  protocolIdentifier      ProtocolIdentifier,
  nonStandardData         NonStandardParameter OPTIONAL,
  rejectReason            RegistrationRejectReason,
  gatekeeperIdentifier    GatekeeperIdentifier OPTIONAL,
  ...,
  altGKInfo               AltGKInfo OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL,
  featureSet              FeatureSet OPTIONAL,
  genericData             SEQUENCE OF GenericData OPTIONAL,
  assignedGatekeeper      AlternateGK OPTIONAL
}

RegistrationRejectReason ::= CHOICE {
  discoveryRequired                 NULL,
  invalidRevision                   NULL,
  invalidCallSignalAddress          NULL,
  invalidRASAddress                 NULL, -- supplied address is invalid
  duplicateAlias                    SEQUENCE OF AliasAddress,
  -- alias registered to another
  -- endpoint
  invalidTerminalType               NULL,
  undefinedReason                   NULL,
  transportNotSupported             NULL, -- one or more of the transports
  ...,
  transportQOSNotSupported          NULL, -- endpoint QoS not supported
  resourceUnavailable               NULL, -- gatekeeper resources exhausted
  invalidAlias                      NULL, -- alias not consistent with

  -- gatekeeper rules
  securityDenial                    NULL,
  fullRegistrationRequired          NULL, -- registration permission has

  -- expired
  additiveRegistrationNotSupported  NULL,
  invalidTerminalAliases
    SEQUENCE {terminalAlias         SEQUENCE OF AliasAddress OPTIONAL,
              terminalAliasPattern  SEQUENCE OF AddressPattern OPTIONAL,
              supportedPrefixes     SEQUENCE OF SupportedPrefix OPTIONAL,
              ...},
  genericDataReason                 NULL,
  neededFeatureNotSupported         NULL,
  securityError                     SecurityErrors,
  registerWithAssignedGK            NULL
}

UnregistrationRequest ::= SEQUENCE --(URQ)
                           {
  requestSeqNum            RequestSeqNum,
  callSignalAddress        SEQUENCE OF TransportAddress,
  endpointAlias            SEQUENCE OF AliasAddress OPTIONAL,
  nonStandardData          NonStandardParameter OPTIONAL,
  endpointIdentifier       EndpointIdentifier OPTIONAL,
  ...,
  alternateEndpoints       SEQUENCE OF Endpoint OPTIONAL,
  gatekeeperIdentifier     GatekeeperIdentifier OPTIONAL,
  tokens                   SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens             SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue      ICV OPTIONAL,
  reason                   UnregRequestReason OPTIONAL,
  endpointAliasPattern     SEQUENCE OF AddressPattern OPTIONAL,
  supportedPrefixes        SEQUENCE OF SupportedPrefix OPTIONAL,
  alternateGatekeeper      SEQUENCE OF AlternateGK OPTIONAL,
  genericData              SEQUENCE OF GenericData OPTIONAL,
  assignedGatekeeper       AlternateGK OPTIONAL
}

UnregRequestReason ::= CHOICE {
  reregistrationRequired  NULL,
  ttlExpired              NULL,
  securityDenial          NULL,
  undefinedReason         NULL,
  ...,
  maintenance             NULL,
  securityError           SecurityErrors2,
  registerWithAssignedGK  NULL
}

UnregistrationConfirm ::= SEQUENCE --(UCF)
                           {
  requestSeqNum           RequestSeqNum,
  nonStandardData         NonStandardParameter OPTIONAL,
  ...,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL,
  genericData             SEQUENCE OF GenericData OPTIONAL,
  assignedGatekeeper      AlternateGK OPTIONAL
}

UnregistrationReject ::= SEQUENCE --(URJ)
                          {
  requestSeqNum           RequestSeqNum,
  rejectReason            UnregRejectReason,
  nonStandardData         NonStandardParameter OPTIONAL,
  ...,
  altGKInfo               AltGKInfo OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL,
  genericData             SEQUENCE OF GenericData OPTIONAL
}

UnregRejectReason ::= CHOICE {
  notCurrentlyRegistered  NULL,
  callInProgress          NULL,
  undefinedReason         NULL,
  ...,
  permissionDenied        NULL, -- requesting user not allowed to

  -- unregister specified user
  securityDenial          NULL,
  securityError           SecurityErrors2
}

AdmissionRequest ::= SEQUENCE --(ARQ)
                      {
  requestSeqNum                RequestSeqNum,
  callType                     CallType,
  callModel                    CallModel OPTIONAL,
  endpointIdentifier           EndpointIdentifier,
  destinationInfo              SEQUENCE OF AliasAddress OPTIONAL,
  destCallSignalAddress        TransportAddress OPTIONAL,
  destExtraCallInfo            SEQUENCE OF AliasAddress OPTIONAL,
  srcInfo                      SEQUENCE OF AliasAddress,
  srcCallSignalAddress         TransportAddress OPTIONAL,
  bandWidth                    BandWidth,
  callReferenceValue           CallReferenceValue,
  nonStandardData              NonStandardParameter OPTIONAL,
  callServices                 QseriesOptions OPTIONAL,
  conferenceID                 ConferenceIdentifier,
  activeMC                     BOOLEAN,
  answerCall                   BOOLEAN, -- answering a call
  ...,
  canMapAlias                  BOOLEAN, -- can handle alias address
  callIdentifier               CallIdentifier,
  srcAlternatives              SEQUENCE OF Endpoint OPTIONAL,
  destAlternatives             SEQUENCE OF Endpoint OPTIONAL,
  gatekeeperIdentifier         GatekeeperIdentifier OPTIONAL,
  tokens                       SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens                 SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue          ICV OPTIONAL,
  transportQOS                 TransportQOS OPTIONAL,
  willSupplyUUIEs              BOOLEAN,
  callLinkage                  CallLinkage OPTIONAL,
  gatewayDataRate              DataRate OPTIONAL,
  capacity                     CallCapacity OPTIONAL,
  circuitInfo                  CircuitInfo OPTIONAL,
  desiredProtocols             SEQUENCE OF SupportedProtocols OPTIONAL,
  desiredTunnelledProtocol     TunnelledProtocol OPTIONAL,
  featureSet                   FeatureSet OPTIONAL,
  genericData                  SEQUENCE OF GenericData OPTIONAL,
  canMapSrcAlias               BOOLEAN
}

CallType ::= CHOICE {
  pointToPoint  NULL, -- Point-to-point
  oneToN        NULL, -- no interaction (FFS)
  nToOne        NULL, -- no interaction (FFS)
  nToN          NULL, -- interactive (multipoint)
  ...
}

CallModel ::= CHOICE {direct            NULL,
                      gatekeeperRouted  NULL,
                      ...
}

TransportQOS ::= CHOICE {
  endpointControlled    NULL,
  gatekeeperControlled  NULL,
  noControl             NULL,
  ...,
  qOSCapabilities       SEQUENCE SIZE (1..256) OF QOSCapability
}

AdmissionConfirm ::= SEQUENCE --(ACF)
                      {
  requestSeqNum                   RequestSeqNum,
  bandWidth                       BandWidth,
  callModel                       CallModel,
  destCallSignalAddress           TransportAddress,
  irrFrequency                    INTEGER(1..65535) OPTIONAL,
  nonStandardData                 NonStandardParameter OPTIONAL,
  ...,
  destinationInfo                 SEQUENCE OF AliasAddress OPTIONAL,
  destExtraCallInfo               SEQUENCE OF AliasAddress OPTIONAL,
  destinationType                 EndpointType OPTIONAL,
  remoteExtensionAddress          SEQUENCE OF AliasAddress OPTIONAL,
  alternateEndpoints              SEQUENCE OF Endpoint OPTIONAL,
  tokens                          SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens                    SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue             ICV OPTIONAL,
  transportQOS                    TransportQOS OPTIONAL,
  willRespondToIRR                BOOLEAN,
  uuiesRequested                  UUIEsRequested,
  language                        SEQUENCE OF IA5String(SIZE (1..32)) OPTIONAL,
  alternateTransportAddresses     AlternateTransportAddresses OPTIONAL,
  useSpecifiedTransport           UseSpecifiedTransport OPTIONAL,
  circuitInfo                     CircuitInfo OPTIONAL,
  usageSpec                       SEQUENCE OF RasUsageSpecification OPTIONAL,
  supportedProtocols              SEQUENCE OF SupportedProtocols OPTIONAL,
  serviceControl                  SEQUENCE OF ServiceControlSession OPTIONAL,
  multipleCalls                   BOOLEAN OPTIONAL,
  featureSet                      FeatureSet OPTIONAL,
  genericData                     SEQUENCE OF GenericData OPTIONAL,
  modifiedSrcInfo                 SEQUENCE OF AliasAddress OPTIONAL,
  assignedGatekeeper              AlternateGK OPTIONAL
}

UUIEsRequested ::= SEQUENCE {
  setup                BOOLEAN,
  callProceeding       BOOLEAN,
  connect              BOOLEAN,
  alerting             BOOLEAN,
  information          BOOLEAN,
  releaseComplete      BOOLEAN,
  facility             BOOLEAN,
  progress             BOOLEAN,
  empty                BOOLEAN,
  ...,
  status               BOOLEAN,
  statusInquiry        BOOLEAN,
  setupAcknowledge     BOOLEAN,
  notify               BOOLEAN
}

AdmissionReject ::= SEQUENCE --(ARJ)
                     {
  requestSeqNum           RequestSeqNum,
  rejectReason            AdmissionRejectReason,
  nonStandardData         NonStandardParameter OPTIONAL,
  ...,
  altGKInfo               AltGKInfo OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  callSignalAddress       SEQUENCE OF TransportAddress OPTIONAL,
  integrityCheckValue     ICV OPTIONAL,
  serviceControl          SEQUENCE OF ServiceControlSession OPTIONAL,
  featureSet              FeatureSet OPTIONAL,
  genericData             SEQUENCE OF GenericData OPTIONAL,
  assignedGatekeeper      AlternateGK OPTIONAL
}

AdmissionRejectReason ::= CHOICE {
  calledPartyNotRegistered   NULL, -- cannot translate address
  invalidPermission          NULL, -- permission has expired
  requestDenied              NULL,
  undefinedReason            NULL,
  callerNotRegistered        NULL,
  routeCallToGatekeeper      NULL,
  invalidEndpointIdentifier  NULL,
  resourceUnavailable        NULL,
  ...,
  securityDenial             NULL,
  qosControlNotSupported     NULL,
  incompleteAddress          NULL,
  aliasesInconsistent        NULL, -- multiple aliases in request

  -- identify distinct people
  routeCallToSCN             SEQUENCE OF PartyNumber,
  exceedsCallCapacity        NULL, -- destination does not have the

  -- capacity for this call
  collectDestination         NULL,
  collectPIN                 NULL,
  genericDataReason          NULL,
  neededFeatureNotSupported  NULL,
  securityError              SecurityErrors2,
  securityDHmismatch         NULL, -- mismatch of DH parameters
  noRouteToDestination       NULL, -- destination unreachable
  unallocatedNumber          NULL, -- destination number unassigned
  registerWithAssignedGK     NULL
}

BandwidthRequest ::= SEQUENCE --(BRQ)
                      {
  requestSeqNum            RequestSeqNum,
  endpointIdentifier       EndpointIdentifier,
  conferenceID             ConferenceIdentifier,
  callReferenceValue       CallReferenceValue,
  callType                 CallType OPTIONAL,
  bandWidth                BandWidth,
  nonStandardData          NonStandardParameter OPTIONAL,
  ...,
  callIdentifier           CallIdentifier,
  gatekeeperIdentifier     GatekeeperIdentifier OPTIONAL,
  tokens                   SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens             SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue      ICV OPTIONAL,
  answeredCall             BOOLEAN,
  callLinkage              CallLinkage OPTIONAL,
  capacity                 CallCapacity OPTIONAL,
  usageInformation         RasUsageInformation OPTIONAL,
  bandwidthDetails         SEQUENCE OF BandwidthDetails OPTIONAL,
  genericData              SEQUENCE OF GenericData OPTIONAL,
  transportQOS             TransportQOS OPTIONAL
}

BandwidthConfirm ::= SEQUENCE --(BCF)
                      {
  requestSeqNum           RequestSeqNum,
  bandWidth               BandWidth,
  nonStandardData         NonStandardParameter OPTIONAL,
  ...,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL,
  capacity                CallCapacity OPTIONAL,
  genericData             SEQUENCE OF GenericData OPTIONAL,
  transportQOS            TransportQOS OPTIONAL
}

BandwidthReject ::= SEQUENCE --(BRJ)
                     {
  requestSeqNum           RequestSeqNum,
  rejectReason            BandRejectReason,
  allowedBandWidth        BandWidth,
  nonStandardData         NonStandardParameter OPTIONAL,
  ...,
  altGKInfo               AltGKInfo OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL,
  genericData             SEQUENCE OF GenericData OPTIONAL
}

BandRejectReason ::= CHOICE {
  notBound               NULL, -- discovery permission has aged
  invalidConferenceID    NULL, -- possible revision
  invalidPermission      NULL, -- true permission violation
  insufficientResources  NULL,
  invalidRevision        NULL,
  undefinedReason        NULL,
  ...,
  securityDenial         NULL,
  securityError          SecurityErrors2
}

LocationRequest ::= SEQUENCE --(LRQ)
                     {
  requestSeqNum                RequestSeqNum,
  endpointIdentifier           EndpointIdentifier OPTIONAL,
  destinationInfo              SEQUENCE OF AliasAddress,
  nonStandardData              NonStandardParameter OPTIONAL,
  replyAddress                 TransportAddress,
  ...,
  sourceInfo                   SEQUENCE OF AliasAddress OPTIONAL,
  canMapAlias                  BOOLEAN, -- can handle alias address
  gatekeeperIdentifier         GatekeeperIdentifier OPTIONAL,
  tokens                       SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens                 SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue          ICV OPTIONAL,
  desiredProtocols             SEQUENCE OF SupportedProtocols OPTIONAL,
  desiredTunnelledProtocol     TunnelledProtocol OPTIONAL,
  featureSet                   FeatureSet OPTIONAL,
  genericData                  SEQUENCE OF GenericData OPTIONAL,
  hopCount                     INTEGER(1..255) OPTIONAL,
  circuitInfo                  CircuitInfo OPTIONAL,
  callIdentifier               CallIdentifier OPTIONAL,
  bandWidth                    BandWidth OPTIONAL,
  sourceEndpointInfo           SEQUENCE OF AliasAddress OPTIONAL,
  canMapSrcAlias               BOOLEAN,
  language                     SEQUENCE OF IA5String(SIZE (1..32)) OPTIONAL
}

LocationConfirm ::= SEQUENCE --(LCF)
                     {
  requestSeqNum                   RequestSeqNum,
  callSignalAddress               TransportAddress,
  rasAddress                      TransportAddress,
  nonStandardData                 NonStandardParameter OPTIONAL,
  ...,
  destinationInfo                 SEQUENCE OF AliasAddress OPTIONAL,
  destExtraCallInfo               SEQUENCE OF AliasAddress OPTIONAL,
  destinationType                 EndpointType OPTIONAL,
  remoteExtensionAddress          SEQUENCE OF AliasAddress OPTIONAL,
  alternateEndpoints              SEQUENCE OF Endpoint OPTIONAL,
  tokens                          SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens                    SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue             ICV OPTIONAL,
  alternateTransportAddresses     AlternateTransportAddresses OPTIONAL,
  supportedProtocols              SEQUENCE OF SupportedProtocols OPTIONAL,
  multipleCalls                   BOOLEAN OPTIONAL,
  featureSet                      FeatureSet OPTIONAL,
  genericData                     SEQUENCE OF GenericData OPTIONAL,
  circuitInfo                     CircuitInfo OPTIONAL,
  serviceControl                  SEQUENCE OF ServiceControlSession OPTIONAL,
  modifiedSrcInfo                 SEQUENCE OF AliasAddress OPTIONAL,
  bandWidth                       BandWidth OPTIONAL
}

LocationReject ::= SEQUENCE --(LRJ)
                    {
  requestSeqNum           RequestSeqNum,
  rejectReason            LocationRejectReason,
  nonStandardData         NonStandardParameter OPTIONAL,
  ...,
  altGKInfo               AltGKInfo OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL,
  featureSet              FeatureSet OPTIONAL,
  genericData             SEQUENCE OF GenericData OPTIONAL,
  serviceControl          SEQUENCE OF ServiceControlSession OPTIONAL
}

LocationRejectReason ::= CHOICE {
  notRegistered              NULL,
  invalidPermission          NULL, -- exclusion by administrator or feature
  requestDenied              NULL,
  undefinedReason            NULL,
  ...,
  securityDenial             NULL,
  aliasesInconsistent        NULL, -- multiple aliases in request

  -- identify distinct people
  routeCalltoSCN             SEQUENCE OF PartyNumber,
  resourceUnavailable        NULL,
  genericDataReason          NULL,
  neededFeatureNotSupported  NULL,
  hopCountExceeded           NULL,
  incompleteAddress          NULL,
  securityError              SecurityErrors2,
  securityDHmismatch         NULL, -- mismatch of DH parameters
  noRouteToDestination       NULL, -- destination unreachable
  unallocatedNumber          NULL -- destination number unassigned
}

DisengageRequest ::= SEQUENCE --(DRQ)
                      {
  requestSeqNum            RequestSeqNum,
  endpointIdentifier       EndpointIdentifier,
  conferenceID             ConferenceIdentifier,
  callReferenceValue       CallReferenceValue,
  disengageReason          DisengageReason,
  nonStandardData          NonStandardParameter OPTIONAL,
  ...,
  callIdentifier           CallIdentifier,
  gatekeeperIdentifier     GatekeeperIdentifier OPTIONAL,
  tokens                   SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens             SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue      ICV OPTIONAL,
  answeredCall             BOOLEAN,
  callLinkage              CallLinkage OPTIONAL,
  capacity                 CallCapacity OPTIONAL,
  circuitInfo              CircuitInfo OPTIONAL,
  usageInformation         RasUsageInformation OPTIONAL,
  terminationCause         CallTerminationCause OPTIONAL,
  serviceControl           SEQUENCE OF ServiceControlSession OPTIONAL,
  genericData              SEQUENCE OF GenericData OPTIONAL
}

DisengageReason ::= CHOICE {
  forcedDrop       NULL, -- gatekeeper is forcing the drop
  normalDrop       NULL, -- associated with normal drop
  undefinedReason  NULL,
  ...
}

DisengageConfirm ::= SEQUENCE --(DCF)
                      {
  requestSeqNum           RequestSeqNum,
  nonStandardData         NonStandardParameter OPTIONAL,
  ...,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL,
  capacity                CallCapacity OPTIONAL,
  circuitInfo             CircuitInfo OPTIONAL,
  usageInformation        RasUsageInformation OPTIONAL,
  genericData             SEQUENCE OF GenericData OPTIONAL,
  assignedGatekeeper      AlternateGK OPTIONAL
}

DisengageReject ::= SEQUENCE --(DRJ)
                     {
  requestSeqNum           RequestSeqNum,
  rejectReason            DisengageRejectReason,
  nonStandardData         NonStandardParameter OPTIONAL,
  ...,
  altGKInfo               AltGKInfo OPTIONAL,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL,
  genericData             SEQUENCE OF GenericData OPTIONAL
}

DisengageRejectReason ::= CHOICE {
  notRegistered       NULL, -- not registered with gatekeeper
  requestToDropOther  NULL, -- cannot request drop for others
  ...,
  securityDenial      NULL,
  securityError       SecurityErrors2
}

InfoRequest ::= SEQUENCE --(IRQ)
                 {
  requestSeqNum                  RequestSeqNum,
  callReferenceValue             CallReferenceValue,
  nonStandardData                NonStandardParameter OPTIONAL,
  replyAddress                   TransportAddress OPTIONAL,
  ...,
  callIdentifier                 CallIdentifier,
  tokens                         SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens                   SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue            ICV OPTIONAL,
  uuiesRequested                 UUIEsRequested OPTIONAL,
  callLinkage                    CallLinkage OPTIONAL,
  usageInfoRequested             RasUsageInfoTypes OPTIONAL,
  segmentedResponseSupported     NULL OPTIONAL,
  nextSegmentRequested           INTEGER(0..65535) OPTIONAL,
  capacityInfoRequested          NULL OPTIONAL,
  genericData                    SEQUENCE OF GenericData OPTIONAL,
  assignedGatekeeper             AlternateGK OPTIONAL
}

InfoRequestResponse ::= SEQUENCE --(IRR)
                         {
  nonStandardData         NonStandardParameter OPTIONAL,
  requestSeqNum           RequestSeqNum,
  endpointType            EndpointType,
  endpointIdentifier      EndpointIdentifier,
  rasAddress              TransportAddress,
  callSignalAddress       SEQUENCE OF TransportAddress,
  endpointAlias           SEQUENCE OF AliasAddress OPTIONAL,
  perCallInfo
    SEQUENCE OF
      SEQUENCE {nonStandardData       NonStandardParameter OPTIONAL,
                callReferenceValue    CallReferenceValue,
                conferenceID          ConferenceIdentifier,
                originator            BOOLEAN OPTIONAL,
                audio                 SEQUENCE OF RTPSession OPTIONAL,
                video                 SEQUENCE OF RTPSession OPTIONAL,
                data                  SEQUENCE OF TransportChannelInfo OPTIONAL,
                h245                  TransportChannelInfo,
                callSignalling        TransportChannelInfo,
                callType              CallType,
                bandWidth             BandWidth,
                callModel             CallModel,
                ...,
                callIdentifier        CallIdentifier,
                tokens                SEQUENCE OF ClearToken OPTIONAL,
                cryptoTokens          SEQUENCE OF CryptoH323Token OPTIONAL,
                substituteConfIDs     SEQUENCE OF ConferenceIdentifier,
                pdu
                  SEQUENCE OF
                    SEQUENCE {h323pdu  H323-UU-PDU,
                              sent     BOOLEAN -- TRUE is sent, FALSE is received
                    } OPTIONAL,
                callLinkage           CallLinkage OPTIONAL,
                usageInformation      RasUsageInformation OPTIONAL,
                circuitInfo           CircuitInfo OPTIONAL} OPTIONAL,
  ...,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL,
  needResponse            BOOLEAN,
  capacity                CallCapacity OPTIONAL,
  irrStatus               InfoRequestResponseStatus OPTIONAL,
  unsolicited             BOOLEAN,
  genericData             SEQUENCE OF GenericData OPTIONAL
}

InfoRequestResponseStatus ::= CHOICE {
  complete     NULL,
  incomplete   NULL,
  segment      INTEGER(0..65535),
  invalidCall  NULL,
  ...
}

InfoRequestAck ::= SEQUENCE --(IACK)
                    {
  requestSeqNum        RequestSeqNum,
  nonStandardData      NonStandardParameter OPTIONAL,
  tokens               SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens         SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue  ICV OPTIONAL,
  ...
}

InfoRequestNak ::= SEQUENCE --(INAK)
                    {
  requestSeqNum        RequestSeqNum,
  nonStandardData      NonStandardParameter OPTIONAL,
  nakReason            InfoRequestNakReason,
  altGKInfo            AltGKInfo OPTIONAL,
  tokens               SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens         SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue  ICV OPTIONAL,
  ...
}

InfoRequestNakReason ::= CHOICE {
  notRegistered    NULL, -- not registered with gatekeeper
  securityDenial   NULL,
  undefinedReason  NULL,
  ...,
  securityError    SecurityErrors2
}

NonStandardMessage ::= SEQUENCE {
  requestSeqNum           RequestSeqNum,
  nonStandardData         NonStandardParameter,
  ...,
  tokens                  SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens            SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue     ICV OPTIONAL,
  featureSet              FeatureSet OPTIONAL,
  genericData             SEQUENCE OF GenericData OPTIONAL
}

UnknownMessageResponse ::= SEQUENCE -- (XRS)
                            {
  requestSeqNum            RequestSeqNum,
  ...,
  tokens                   SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens             SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue      ICV OPTIONAL,
  messageNotUnderstood     OCTET STRING
}

RequestInProgress ::= SEQUENCE -- (RIP)
                       {
  requestSeqNum        RequestSeqNum,
  nonStandardData      NonStandardParameter OPTIONAL,
  tokens               SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens         SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue  ICV OPTIONAL,
  delay                INTEGER(1..65535),
  ...
}

ResourcesAvailableIndicate ::= SEQUENCE --(RAI)
                                {
  requestSeqNum         RequestSeqNum,
  protocolIdentifier    ProtocolIdentifier,
  nonStandardData       NonStandardParameter OPTIONAL,
  endpointIdentifier    EndpointIdentifier,
  protocols             SEQUENCE OF SupportedProtocols,
  almostOutOfResources  BOOLEAN,
  tokens                SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens          SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue   ICV OPTIONAL,
  ...,
  capacity              CallCapacity OPTIONAL,
  genericData           SEQUENCE OF GenericData OPTIONAL
}

ResourcesAvailableConfirm ::= SEQUENCE --(RAC)
                               {
  requestSeqNum        RequestSeqNum,
  protocolIdentifier   ProtocolIdentifier,
  nonStandardData      NonStandardParameter OPTIONAL,
  tokens               SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens         SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue  ICV OPTIONAL,
  ...,
  genericData          SEQUENCE OF GenericData OPTIONAL
}

ServiceControlIndication ::= SEQUENCE --(SCI)
                              {
  requestSeqNum        RequestSeqNum,
  nonStandardData      NonStandardParameter OPTIONAL,
  serviceControl       SEQUENCE OF ServiceControlSession,
  endpointIdentifier   EndpointIdentifier OPTIONAL,
  callSpecific
    SEQUENCE {callIdentifier  CallIdentifier,
              conferenceID    ConferenceIdentifier,
              answeredCall    BOOLEAN,
              ...} OPTIONAL,
  tokens               SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens         SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue  ICV OPTIONAL,
  featureSet           FeatureSet OPTIONAL,
  genericData          SEQUENCE OF GenericData OPTIONAL,
  ...
}

ServiceControlResponse ::= SEQUENCE --(SCR)
                            {
  requestSeqNum        RequestSeqNum,
  result
    CHOICE {started                    NULL,
            failed                     NULL,
            stopped                    NULL,
            notAvailable               NULL,
            neededFeatureNotSupported  NULL,
            ...} OPTIONAL,
  nonStandardData      NonStandardParameter OPTIONAL,
  tokens               SEQUENCE OF ClearToken OPTIONAL,
  cryptoTokens         SEQUENCE OF CryptoH323Token OPTIONAL,
  integrityCheckValue  ICV OPTIONAL,
  featureSet           FeatureSet OPTIONAL,
  genericData          SEQUENCE OF GenericData OPTIONAL,
  ...
}

END -- of ASN.1

-- Generated by Asnp, the ASN.1 pretty-printer of France Telecom R&D