--
-- Abstract Syntax Notion (ASN.1) file for H.225.0 Version 6
--
-- File provided by Packetizer, Inc. - http://www.packetizer.com
-- Last Updated: 23 Apr 2006
--
-- History of changes:
--    23 Apr 2006
--        Initial H.225.0v6 ASN.1 file
--

H323-MESSAGES 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;

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). Also used as specified
                                                        -- in H.323 to send messages that are not
                                                        -- call related.

                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

        h245Tunneling                   BOOLEAN, -- if TRUE, tunneling 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,
        provisionalRespToH245Tunneling  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
}

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, -- RFC1766 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
}

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
}

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 H.323 8.4.3.8)
        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, -- RFC1766 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
}

ScnConnectionType ::= CHOICE
{
        unknown         NULL,   -- should be seleceted when connection type is unknown
        bChannel        NULL,   -- each individual connection on the SCN is 64kbps.
                                        -- Note that where SCN delivers 56kbps usable data, the
                                        -- actual bandwidth allocated on SCN is still 64kbps.
        hybrid2x64      NULL,   -- each connection is a 128kbps hybrid call
        hybrid384       NULL,   -- each connection is an H0 (384kbps) hybrid call
        hybrid1536      NULL,   -- each connection is an H11 (1536kbps) hybrid call
        hybrid1920      NULL,   -- each connection is an H12 (1920kbps) 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,
        ...
}

-- 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
{
        dialedDigits            IA5String (SIZE (1..128)) (FROM ("0123456789#*,")),
        h323-ID                 BMPString (SIZE (1..256)),      -- Basic ISO/IEC 10646-1 (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
                                                -- Recommendations 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#*,"))

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 repsonse 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 Identificaiton
        -- 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
                                    -- Recommendations 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       
                                        -- shall be set to  
                                        -- {itu-t (0) recommendation (0) h (8) 2250 version (0) 4}
TimeToLive              ::=     INTEGER (1..4294967295) -- in seconds
H248PackagesDescriptor  ::=     OCTET STRING  -- This octet string contans
                                              -- ASN.1 PER encoded H.248
                                              -- PackageDescriptor
H248SignalsDescriptor   ::=     OCTET STRING  -- This octet string contans
                                              -- ASN.1 PER encoded H.248
                                              -- SignalDescriptor
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,
        securityErrors                  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    -- detination 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,
                callSignaling                   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

