gccpdu.h

//
// gccpdu.h
//
// Code automatically generated by asnparse.
//

#if ! H323_DISABLE_GCC

#ifndef __GCC_H
#define __GCC_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <ptclib/asner.h>

//
// ChannelID
//

class GCC_ChannelID : public PASN_Integer
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ChannelID, PASN_Integer);
#endif
  public:
    GCC_ChannelID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_ChannelID & operator=(int v);
    GCC_ChannelID & operator=(unsigned v);
    PObject * Clone() const;
};


//
// StaticChannelID
//

class GCC_StaticChannelID : public PASN_Integer
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_StaticChannelID, PASN_Integer);
#endif
  public:
    GCC_StaticChannelID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_StaticChannelID & operator=(int v);
    GCC_StaticChannelID & operator=(unsigned v);
    PObject * Clone() const;
};


//
// DynamicChannelID
//

class GCC_DynamicChannelID : public PASN_Integer
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_DynamicChannelID, PASN_Integer);
#endif
  public:
    GCC_DynamicChannelID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_DynamicChannelID & operator=(int v);
    GCC_DynamicChannelID & operator=(unsigned v);
    PObject * Clone() const;
};


//
// UserID
//

class GCC_UserID : public GCC_DynamicChannelID
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_UserID, GCC_DynamicChannelID);
#endif
  public:
    GCC_UserID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_UserID & operator=(int v);
    GCC_UserID & operator=(unsigned v);
    PObject * Clone() const;
};


//
// TokenID
//

class GCC_TokenID : public PASN_Integer
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_TokenID, PASN_Integer);
#endif
  public:
    GCC_TokenID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_TokenID & operator=(int v);
    GCC_TokenID & operator=(unsigned v);
    PObject * Clone() const;
};


//
// StaticTokenID
//

class GCC_StaticTokenID : public PASN_Integer
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_StaticTokenID, PASN_Integer);
#endif
  public:
    GCC_StaticTokenID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_StaticTokenID & operator=(int v);
    GCC_StaticTokenID & operator=(unsigned v);
    PObject * Clone() const;
};


//
// DynamicTokenID
//

class GCC_DynamicTokenID : public PASN_Integer
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_DynamicTokenID, PASN_Integer);
#endif
  public:
    GCC_DynamicTokenID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_DynamicTokenID & operator=(int v);
    GCC_DynamicTokenID & operator=(unsigned v);
    PObject * Clone() const;
};


//
// Time
//

class GCC_Time : public PASN_Integer
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_Time, PASN_Integer);
#endif
  public:
    GCC_Time(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_Time & operator=(int v);
    GCC_Time & operator=(unsigned v);
    PObject * Clone() const;
};


//
// Handle
//

class GCC_Handle : public PASN_Integer
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_Handle, PASN_Integer);
#endif
  public:
    GCC_Handle(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_Handle & operator=(int v);
    GCC_Handle & operator=(unsigned v);
    PObject * Clone() const;
};


//
// H221NonStandardIdentifier
//

class GCC_H221NonStandardIdentifier : public PASN_OctetString
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_H221NonStandardIdentifier, PASN_OctetString);
#endif
  public:
    GCC_H221NonStandardIdentifier(unsigned tag = UniversalOctetString, TagClass tagClass = UniversalTagClass);

    GCC_H221NonStandardIdentifier(const char * v);
    GCC_H221NonStandardIdentifier(const PString & v);
    GCC_H221NonStandardIdentifier(const PBYTEArray & v);

    GCC_H221NonStandardIdentifier & operator=(const char * v);
    GCC_H221NonStandardIdentifier & operator=(const PString & v);
    GCC_H221NonStandardIdentifier & operator=(const PBYTEArray & v);
    PObject * Clone() const;
};


//
// Key
//

class GCC_H221NonStandardIdentifier;

class GCC_Key : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_Key, PASN_Choice);
#endif
  public:
    GCC_Key(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_object,
      e_h221NonStandard
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_H221NonStandardIdentifier &() const;
#else
    operator GCC_H221NonStandardIdentifier &();
    operator const GCC_H221NonStandardIdentifier &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// NonStandardParameter
//

class GCC_NonStandardParameter : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_NonStandardParameter, PASN_Sequence);
#endif
  public:
    GCC_NonStandardParameter(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_Key m_key;
    PASN_OctetString m_data;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// TextString
//

class GCC_TextString : public PASN_BMPString
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_TextString, PASN_BMPString);
#endif
  public:
    GCC_TextString(unsigned tag = UniversalBMPString, TagClass tagClass = UniversalTagClass);

    GCC_TextString & operator=(const char * v);
    GCC_TextString & operator=(const PString & v);
    GCC_TextString & operator=(const PWCharArray & v);
    GCC_TextString & operator=(const PASN_BMPString & v);
    PObject * Clone() const;
};


//
// SimpleTextString
//

class GCC_SimpleTextString : public PASN_BMPString
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_SimpleTextString, PASN_BMPString);
#endif
  public:
    GCC_SimpleTextString(unsigned tag = UniversalBMPString, TagClass tagClass = UniversalTagClass);

    GCC_SimpleTextString & operator=(const char * v);
    GCC_SimpleTextString & operator=(const PString & v);
    GCC_SimpleTextString & operator=(const PWCharArray & v);
    GCC_SimpleTextString & operator=(const PASN_BMPString & v);
    PObject * Clone() const;
};


//
// SimpleNumericString
//

class GCC_SimpleNumericString : public PASN_NumericString
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_SimpleNumericString, PASN_NumericString);
#endif
  public:
    GCC_SimpleNumericString(unsigned tag = UniversalNumericString, TagClass tagClass = UniversalTagClass);

    GCC_SimpleNumericString & operator=(const char * v);
    GCC_SimpleNumericString & operator=(const PString & v);
    PObject * Clone() const;
};


//
// DialingString
//

class GCC_DialingString : public PASN_NumericString
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_DialingString, PASN_NumericString);
#endif
  public:
    GCC_DialingString(unsigned tag = UniversalNumericString, TagClass tagClass = UniversalTagClass);

    GCC_DialingString & operator=(const char * v);
    GCC_DialingString & operator=(const PString & v);
    PObject * Clone() const;
};


//
// SubAddressString
//

class GCC_SubAddressString : public PASN_NumericString
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_SubAddressString, PASN_NumericString);
#endif
  public:
    GCC_SubAddressString(unsigned tag = UniversalNumericString, TagClass tagClass = UniversalTagClass);

    GCC_SubAddressString & operator=(const char * v);
    GCC_SubAddressString & operator=(const PString & v);
    PObject * Clone() const;
};


//
// ExtraDialingString
//

class GCC_ExtraDialingString : public PASN_BMPString
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ExtraDialingString, PASN_BMPString);
#endif
  public:
    GCC_ExtraDialingString(unsigned tag = UniversalBMPString, TagClass tagClass = UniversalTagClass);

    GCC_ExtraDialingString & operator=(const char * v);
    GCC_ExtraDialingString & operator=(const PString & v);
    GCC_ExtraDialingString & operator=(const PWCharArray & v);
    GCC_ExtraDialingString & operator=(const PASN_BMPString & v);
    PObject * Clone() const;
};


//
// UserData
//

class GCC_UserData_subtype;

class GCC_UserData : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_UserData, PASN_Array);
#endif
  public:
    GCC_UserData(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_UserData_subtype & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// Password
//

class GCC_Password : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_Password, PASN_Sequence);
#endif
  public:
    GCC_Password(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_text
    };

    GCC_SimpleNumericString m_numeric;
    GCC_SimpleTextString m_text;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// PasswordSelector
//

class GCC_SimpleNumericString;
class GCC_SimpleTextString;

class GCC_PasswordSelector : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_PasswordSelector, PASN_Choice);
#endif
  public:
    GCC_PasswordSelector(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_numeric,
      e_text
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_SimpleNumericString &() const;
#else
    operator GCC_SimpleNumericString &();
    operator const GCC_SimpleNumericString &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_SimpleTextString &() const;
#else
    operator GCC_SimpleTextString &();
    operator const GCC_SimpleTextString &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// ChallengeResponseItem
//

class GCC_PasswordSelector;
class GCC_UserData;

class GCC_ChallengeResponseItem : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ChallengeResponseItem, PASN_Choice);
#endif
  public:
    GCC_ChallengeResponseItem(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_passwordString,
      e_responseData
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_PasswordSelector &() const;
#else
    operator GCC_PasswordSelector &();
    operator const GCC_PasswordSelector &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_UserData &() const;
#else
    operator GCC_UserData &();
    operator const GCC_UserData &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// ChallengeResponseAlgorithm
//

class GCC_NonStandardParameter;

class GCC_ChallengeResponseAlgorithm : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ChallengeResponseAlgorithm, PASN_Choice);
#endif
  public:
    GCC_ChallengeResponseAlgorithm(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_passwordInTheClear,
      e_nonStandardAlgorithm
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_NonStandardParameter &() const;
#else
    operator GCC_NonStandardParameter &();
    operator const GCC_NonStandardParameter &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// ChallengeItem
//

class GCC_ChallengeItem : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ChallengeItem, PASN_Sequence);
#endif
  public:
    GCC_ChallengeItem(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_ChallengeResponseAlgorithm m_responseAlgorithm;
    GCC_UserData m_challengeData;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ChallengeResponse
//

class GCC_ChallengeResponse : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ChallengeResponse, PASN_Sequence);
#endif
  public:
    GCC_ChallengeResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    PASN_Integer m_challengeTag;
    GCC_ChallengeResponseAlgorithm m_responseAlgorithm;
    GCC_ChallengeResponseItem m_responseItem;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// PasswordChallengeRequestResponse
//

class GCC_PasswordSelector;
class GCC_PasswordChallengeRequestResponse_challengeRequestResponse;

class GCC_PasswordChallengeRequestResponse : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_PasswordChallengeRequestResponse, PASN_Choice);
#endif
  public:
    GCC_PasswordChallengeRequestResponse(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_passwordInTheClear,
      e_challengeRequestResponse
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_PasswordSelector &() const;
#else
    operator GCC_PasswordSelector &();
    operator const GCC_PasswordSelector &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_PasswordChallengeRequestResponse_challengeRequestResponse &() const;
#else
    operator GCC_PasswordChallengeRequestResponse_challengeRequestResponse &();
    operator const GCC_PasswordChallengeRequestResponse_challengeRequestResponse &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// ConferenceName
//

class GCC_ConferenceName : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceName, PASN_Sequence);
#endif
  public:
    GCC_ConferenceName(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_text
    };

    GCC_SimpleNumericString m_numeric;
    GCC_SimpleTextString m_text;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceNameSelector
//

class GCC_SimpleNumericString;
class GCC_SimpleTextString;

class GCC_ConferenceNameSelector : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceNameSelector, PASN_Choice);
#endif
  public:
    GCC_ConferenceNameSelector(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_numeric,
      e_text
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_SimpleNumericString &() const;
#else
    operator GCC_SimpleNumericString &();
    operator const GCC_SimpleNumericString &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_SimpleTextString &() const;
#else
    operator GCC_SimpleTextString &();
    operator const GCC_SimpleTextString &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// ConferenceNameModifier
//

class GCC_ConferenceNameModifier : public GCC_SimpleNumericString
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceNameModifier, GCC_SimpleNumericString);
#endif
  public:
    GCC_ConferenceNameModifier(unsigned tag = UniversalNumericString, TagClass tagClass = UniversalTagClass);

    GCC_ConferenceNameModifier & operator=(const char * v);
    GCC_ConferenceNameModifier & operator=(const PString & v);
    PObject * Clone() const;
};


//
// Privilege
//

class GCC_Privilege : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_Privilege, PASN_Enumeration);
#endif
  public:
    GCC_Privilege(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_terminate,
      e_ejectUser,
      e_add,
      e_lockUnlock,
      e_transfer
    };

    GCC_Privilege & operator=(unsigned v);
    PObject * Clone() const;
};


//
// TerminationMethod
//

class GCC_TerminationMethod : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_TerminationMethod, PASN_Enumeration);
#endif
  public:
    GCC_TerminationMethod(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_automatic,
      e_manual
    };

    GCC_TerminationMethod & operator=(unsigned v);
    PObject * Clone() const;
};


//
// ConferencePriorityScheme
//

class GCC_NonStandardParameter;

class GCC_ConferencePriorityScheme : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferencePriorityScheme, PASN_Choice);
#endif
  public:
    GCC_ConferencePriorityScheme(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_nonStandardScheme
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_NonStandardParameter &() const;
#else
    operator GCC_NonStandardParameter &();
    operator const GCC_NonStandardParameter &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// ConferencePriority
//

class GCC_ConferencePriority : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferencePriority, PASN_Sequence);
#endif
  public:
    GCC_ConferencePriority(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    PASN_Integer m_priority;
    GCC_ConferencePriorityScheme m_scheme;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// NetworkAddress
//

class GCC_NetworkAddress_subtype;

class GCC_NetworkAddress : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_NetworkAddress, PASN_Array);
#endif
  public:
    GCC_NetworkAddress(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_NetworkAddress_subtype & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// NodeType
//

class GCC_NodeType : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_NodeType, PASN_Enumeration);
#endif
  public:
    GCC_NodeType(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_terminal,
      e_multiportTerminal,
      e_mcu
    };

    GCC_NodeType & operator=(unsigned v);
    PObject * Clone() const;
};


//
// NodeProperties
//

class GCC_NodeProperties : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_NodeProperties, PASN_Sequence);
#endif
  public:
    GCC_NodeProperties(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    PASN_Boolean m_managementDevice;
    PASN_Boolean m_peripheralDevice;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// AsymmetryIndicator
//

class GCC_AsymmetryIndicator : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_AsymmetryIndicator, PASN_Choice);
#endif
  public:
    GCC_AsymmetryIndicator(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_callingNode,
      e_calledNode,
      e_unknown
    };

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// AlternativeNodeID
//

class GCC_AlternativeNodeID : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_AlternativeNodeID, PASN_Choice);
#endif
  public:
    GCC_AlternativeNodeID(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_h243NodeID
    };

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// ConferenceDescriptor
//

class GCC_ConferenceDescriptor : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceDescriptor, PASN_Sequence);
#endif
  public:
    GCC_ConferenceDescriptor(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_conferenceNameModifier,
      e_conferenceDescription,
      e_networkAddress,
      e_defaultConferenceFlag
    };

    GCC_ConferenceName m_conferenceName;
    GCC_ConferenceNameModifier m_conferenceNameModifier;
    GCC_TextString m_conferenceDescription;
    PASN_Boolean m_lockedConference;
    PASN_Boolean m_passwordInTheClearRequired;
    GCC_NetworkAddress m_networkAddress;
    PASN_Boolean m_defaultConferenceFlag;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// SessionKey
//

class GCC_SessionKey : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_SessionKey, PASN_Sequence);
#endif
  public:
    GCC_SessionKey(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_sessionID
    };

    GCC_Key m_applicationProtocolKey;
    GCC_ChannelID m_sessionID;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ChannelType
//

class GCC_ChannelType : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ChannelType, PASN_Enumeration);
#endif
  public:
    GCC_ChannelType(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_static,
      e_dynamicMulticast,
      e_dynamicPrivate,
      e_dynamicUserId
    };

    GCC_ChannelType & operator=(unsigned v);
    PObject * Clone() const;
};


//
// CapabilityID
//

class GCC_Key;

class GCC_CapabilityID : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_CapabilityID, PASN_Choice);
#endif
  public:
    GCC_CapabilityID(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_standard,
      e_nonStandard
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_Key &() const;
#else
    operator GCC_Key &();
    operator const GCC_Key &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// CapabilityClass
//

class GCC_CapabilityClass : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_CapabilityClass, PASN_Choice);
#endif
  public:
    GCC_CapabilityClass(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_logical,
      e_unsignedMin,
      e_unsignedMax
    };

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// EntityID
//

class GCC_EntityID : public PASN_Integer
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_EntityID, PASN_Integer);
#endif
  public:
    GCC_EntityID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_EntityID & operator=(int v);
    GCC_EntityID & operator=(unsigned v);
    PObject * Clone() const;
};


//
// RegistryKey
//

class GCC_RegistryKey : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistryKey, PASN_Sequence);
#endif
  public:
    GCC_RegistryKey(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_SessionKey m_sessionKey;
    PASN_OctetString m_resourceID;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RegistryItem
//

class GCC_DynamicChannelID;
class GCC_DynamicTokenID;

class GCC_RegistryItem : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistryItem, PASN_Choice);
#endif
  public:
    GCC_RegistryItem(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_channelID,
      e_tokenID,
      e_parameter,
      e_vacant
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_DynamicChannelID &() const;
#else
    operator GCC_DynamicChannelID &();
    operator const GCC_DynamicChannelID &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_DynamicTokenID &() const;
#else
    operator GCC_DynamicTokenID &();
    operator const GCC_DynamicTokenID &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// RegistryEntryOwner
//

class GCC_RegistryEntryOwner_owned;

class GCC_RegistryEntryOwner : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistryEntryOwner, PASN_Choice);
#endif
  public:
    GCC_RegistryEntryOwner(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_owned,
      e_notOwned
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RegistryEntryOwner_owned &() const;
#else
    operator GCC_RegistryEntryOwner_owned &();
    operator const GCC_RegistryEntryOwner_owned &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// RegistryModificationRights
//

class GCC_RegistryModificationRights : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistryModificationRights, PASN_Enumeration);
#endif
  public:
    GCC_RegistryModificationRights(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_owner,
      e_session,
      e_public
    };

    GCC_RegistryModificationRights & operator=(unsigned v);
    PObject * Clone() const;
};


//
// UserIDIndication
//

class GCC_UserIDIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_UserIDIndication, PASN_Sequence);
#endif
  public:
    GCC_UserIDIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    PASN_Integer m_tag;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceQueryRequest
//

class GCC_ConferenceQueryRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceQueryRequest, PASN_Sequence);
#endif
  public:
    GCC_ConferenceQueryRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_asymmetryIndicator,
      e_userData
    };

    GCC_NodeType m_nodeType;
    GCC_AsymmetryIndicator m_asymmetryIndicator;
    GCC_UserData m_userData;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceJoinRequest
//

class GCC_ConferenceJoinRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceJoinRequest, PASN_Sequence);
#endif
  public:
    GCC_ConferenceJoinRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_conferenceName,
      e_conferenceNameModifier,
      e_tag,
      e_password,
      e_convenerPassword,
      e_callerIdentifier,
      e_userData
    };

    GCC_ConferenceNameSelector m_conferenceName;
    GCC_ConferenceNameModifier m_conferenceNameModifier;
    PASN_Integer m_tag;
    GCC_PasswordChallengeRequestResponse m_password;
    GCC_PasswordSelector m_convenerPassword;
    GCC_TextString m_callerIdentifier;
    GCC_UserData m_userData;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceAddRequest
//

class GCC_ConferenceAddRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceAddRequest, PASN_Sequence);
#endif
  public:
    GCC_ConferenceAddRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_addingMCU,
      e_userData
    };

    GCC_NetworkAddress m_networkAddress;
    GCC_UserID m_requestingNode;
    PASN_Integer m_tag;
    GCC_UserID m_addingMCU;
    GCC_UserData m_userData;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceLockRequest
//

class GCC_ConferenceLockRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceLockRequest, PASN_Sequence);
#endif
  public:
    GCC_ConferenceLockRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);


    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    PObject * Clone() const;
};


//
// ConferenceLockIndication
//

class GCC_ConferenceLockIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceLockIndication, PASN_Sequence);
#endif
  public:
    GCC_ConferenceLockIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);


    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    PObject * Clone() const;
};


//
// ConferenceUnlockRequest
//

class GCC_ConferenceUnlockRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceUnlockRequest, PASN_Sequence);
#endif
  public:
    GCC_ConferenceUnlockRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);


    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    PObject * Clone() const;
};


//
// ConferenceUnlockIndication
//

class GCC_ConferenceUnlockIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceUnlockIndication, PASN_Sequence);
#endif
  public:
    GCC_ConferenceUnlockIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);


    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    PObject * Clone() const;
};


//
// RegistryRegisterChannelRequest
//

class GCC_RegistryRegisterChannelRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistryRegisterChannelRequest, PASN_Sequence);
#endif
  public:
    GCC_RegistryRegisterChannelRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_EntityID m_entityID;
    GCC_RegistryKey m_key;
    GCC_DynamicChannelID m_channelID;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RegistryAssignTokenRequest
//

class GCC_RegistryAssignTokenRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistryAssignTokenRequest, PASN_Sequence);
#endif
  public:
    GCC_RegistryAssignTokenRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_EntityID m_entityID;
    GCC_RegistryKey m_key;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RegistrySetParameterRequest
//

class GCC_RegistrySetParameterRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistrySetParameterRequest, PASN_Sequence);
#endif
  public:
    GCC_RegistrySetParameterRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_modificationRights
    };

    GCC_EntityID m_entityID;
    GCC_RegistryKey m_key;
    PASN_OctetString m_parameter;
    GCC_RegistryModificationRights m_modificationRights;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RegistryRetrieveEntryRequest
//

class GCC_RegistryRetrieveEntryRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistryRetrieveEntryRequest, PASN_Sequence);
#endif
  public:
    GCC_RegistryRetrieveEntryRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_EntityID m_entityID;
    GCC_RegistryKey m_key;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RegistryDeleteEntryRequest
//

class GCC_RegistryDeleteEntryRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistryDeleteEntryRequest, PASN_Sequence);
#endif
  public:
    GCC_RegistryDeleteEntryRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_EntityID m_entityID;
    GCC_RegistryKey m_key;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RegistryMonitorEntryRequest
//

class GCC_RegistryMonitorEntryRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistryMonitorEntryRequest, PASN_Sequence);
#endif
  public:
    GCC_RegistryMonitorEntryRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_EntityID m_entityID;
    GCC_RegistryKey m_key;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RegistryMonitorEntryIndication
//

class GCC_RegistryMonitorEntryIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistryMonitorEntryIndication, PASN_Sequence);
#endif
  public:
    GCC_RegistryMonitorEntryIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_modificationRights
    };

    GCC_RegistryKey m_key;
    GCC_RegistryItem m_item;
    GCC_RegistryEntryOwner m_owner;
    GCC_RegistryModificationRights m_modificationRights;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RegistryAllocateHandleRequest
//

class GCC_RegistryAllocateHandleRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistryAllocateHandleRequest, PASN_Sequence);
#endif
  public:
    GCC_RegistryAllocateHandleRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_EntityID m_entityID;
    PASN_Integer m_numberOfHandles;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConductorAssignIndication
//

class GCC_ConductorAssignIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConductorAssignIndication, PASN_Sequence);
#endif
  public:
    GCC_ConductorAssignIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_UserID m_conductingNode;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConductorReleaseIndication
//

class GCC_ConductorReleaseIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConductorReleaseIndication, PASN_Sequence);
#endif
  public:
    GCC_ConductorReleaseIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);


    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    PObject * Clone() const;
};


//
// ConductorPermissionAskIndication
//

class GCC_ConductorPermissionAskIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConductorPermissionAskIndication, PASN_Sequence);
#endif
  public:
    GCC_ConductorPermissionAskIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    PASN_Boolean m_grantFlag;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceTimeRemainingIndication
//

class GCC_ConferenceTimeRemainingIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceTimeRemainingIndication, PASN_Sequence);
#endif
  public:
    GCC_ConferenceTimeRemainingIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_nodeID
    };

    GCC_Time m_timeRemaining;
    GCC_UserID m_nodeID;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceTimeInquireIndication
//

class GCC_ConferenceTimeInquireIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceTimeInquireIndication, PASN_Sequence);
#endif
  public:
    GCC_ConferenceTimeInquireIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    PASN_Boolean m_nodeSpecificTimeFlag;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceTimeExtendIndication
//

class GCC_ConferenceTimeExtendIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceTimeExtendIndication, PASN_Sequence);
#endif
  public:
    GCC_ConferenceTimeExtendIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_Time m_timeToExtend;
    PASN_Boolean m_nodeSpecificTimeFlag;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceAssistanceIndication
//

class GCC_ConferenceAssistanceIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceAssistanceIndication, PASN_Sequence);
#endif
  public:
    GCC_ConferenceAssistanceIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_userData
    };

    GCC_UserData m_userData;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// TextMessageIndication
//

class GCC_TextMessageIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_TextMessageIndication, PASN_Sequence);
#endif
  public:
    GCC_TextMessageIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_TextString m_message;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// NonStandardPDU
//

class GCC_NonStandardPDU : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_NonStandardPDU, PASN_Sequence);
#endif
  public:
    GCC_NonStandardPDU(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_NonStandardParameter m_data;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConnectData
//

class GCC_ConnectData : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConnectData, PASN_Sequence);
#endif
  public:
    GCC_ConnectData(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_Key m_t124Identifier;
    PASN_OctetString m_connectPDU;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConnectGCCPDU
//

class GCC_ConferenceCreateRequest;
class GCC_ConferenceCreateResponse;
class GCC_ConferenceQueryRequest;
class GCC_ConferenceQueryResponse;
class GCC_ConferenceJoinRequest;
class GCC_ConferenceJoinResponse;
class GCC_ConferenceInviteRequest;
class GCC_ConferenceInviteResponse;

class GCC_ConnectGCCPDU : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConnectGCCPDU, PASN_Choice);
#endif
  public:
    GCC_ConnectGCCPDU(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_conferenceCreateRequest,
      e_conferenceCreateResponse,
      e_conferenceQueryRequest,
      e_conferenceQueryResponse,
      e_conferenceJoinRequest,
      e_conferenceJoinResponse,
      e_conferenceInviteRequest,
      e_conferenceInviteResponse
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceCreateRequest &() const;
#else
    operator GCC_ConferenceCreateRequest &();
    operator const GCC_ConferenceCreateRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceCreateResponse &() const;
#else
    operator GCC_ConferenceCreateResponse &();
    operator const GCC_ConferenceCreateResponse &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceQueryRequest &() const;
#else
    operator GCC_ConferenceQueryRequest &();
    operator const GCC_ConferenceQueryRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceQueryResponse &() const;
#else
    operator GCC_ConferenceQueryResponse &();
    operator const GCC_ConferenceQueryResponse &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceJoinRequest &() const;
#else
    operator GCC_ConferenceJoinRequest &();
    operator const GCC_ConferenceJoinRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceJoinResponse &() const;
#else
    operator GCC_ConferenceJoinResponse &();
    operator const GCC_ConferenceJoinResponse &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceInviteRequest &() const;
#else
    operator GCC_ConferenceInviteRequest &();
    operator const GCC_ConferenceInviteRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceInviteResponse &() const;
#else
    operator GCC_ConferenceInviteResponse &();
    operator const GCC_ConferenceInviteResponse &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// GCCPDU
//

class GCC_RequestPDU;
class GCC_ResponsePDU;
class GCC_IndicationPDU;

class GCC_GCCPDU : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_GCCPDU, PASN_Choice);
#endif
  public:
    GCC_GCCPDU(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_request,
      e_response,
      e_indication
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RequestPDU &() const;
#else
    operator GCC_RequestPDU &();
    operator const GCC_RequestPDU &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ResponsePDU &() const;
#else
    operator GCC_ResponsePDU &();
    operator const GCC_ResponsePDU &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_IndicationPDU &() const;
#else
    operator GCC_IndicationPDU &();
    operator const GCC_IndicationPDU &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// RequestPDU
//

class GCC_ConferenceJoinRequest;
class GCC_ConferenceAddRequest;
class GCC_ConferenceLockRequest;
class GCC_ConferenceUnlockRequest;
class GCC_ConferenceTerminateRequest;
class GCC_ConferenceEjectUserRequest;
class GCC_ConferenceTransferRequest;
class GCC_RegistryRegisterChannelRequest;
class GCC_RegistryAssignTokenRequest;
class GCC_RegistrySetParameterRequest;
class GCC_RegistryRetrieveEntryRequest;
class GCC_RegistryDeleteEntryRequest;
class GCC_RegistryMonitorEntryRequest;
class GCC_RegistryAllocateHandleRequest;
class GCC_NonStandardPDU;

class GCC_RequestPDU : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RequestPDU, PASN_Choice);
#endif
  public:
    GCC_RequestPDU(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_conferenceJoinRequest,
      e_conferenceAddRequest,
      e_conferenceLockRequest,
      e_conferenceUnlockRequest,
      e_conferenceTerminateRequest,
      e_conferenceEjectUserRequest,
      e_conferenceTransferRequest,
      e_registryRegisterChannelRequest,
      e_registryAssignTokenRequest,
      e_registrySetParameterRequest,
      e_registryRetrieveEntryRequest,
      e_registryDeleteEntryRequest,
      e_registryMonitorEntryRequest,
      e_registryAllocateHandleRequest,
      e_nonStandardRequest
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceJoinRequest &() const;
#else
    operator GCC_ConferenceJoinRequest &();
    operator const GCC_ConferenceJoinRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceAddRequest &() const;
#else
    operator GCC_ConferenceAddRequest &();
    operator const GCC_ConferenceAddRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceLockRequest &() const;
#else
    operator GCC_ConferenceLockRequest &();
    operator const GCC_ConferenceLockRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceUnlockRequest &() const;
#else
    operator GCC_ConferenceUnlockRequest &();
    operator const GCC_ConferenceUnlockRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceTerminateRequest &() const;
#else
    operator GCC_ConferenceTerminateRequest &();
    operator const GCC_ConferenceTerminateRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceEjectUserRequest &() const;
#else
    operator GCC_ConferenceEjectUserRequest &();
    operator const GCC_ConferenceEjectUserRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceTransferRequest &() const;
#else
    operator GCC_ConferenceTransferRequest &();
    operator const GCC_ConferenceTransferRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RegistryRegisterChannelRequest &() const;
#else
    operator GCC_RegistryRegisterChannelRequest &();
    operator const GCC_RegistryRegisterChannelRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RegistryAssignTokenRequest &() const;
#else
    operator GCC_RegistryAssignTokenRequest &();
    operator const GCC_RegistryAssignTokenRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RegistrySetParameterRequest &() const;
#else
    operator GCC_RegistrySetParameterRequest &();
    operator const GCC_RegistrySetParameterRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RegistryRetrieveEntryRequest &() const;
#else
    operator GCC_RegistryRetrieveEntryRequest &();
    operator const GCC_RegistryRetrieveEntryRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RegistryDeleteEntryRequest &() const;
#else
    operator GCC_RegistryDeleteEntryRequest &();
    operator const GCC_RegistryDeleteEntryRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RegistryMonitorEntryRequest &() const;
#else
    operator GCC_RegistryMonitorEntryRequest &();
    operator const GCC_RegistryMonitorEntryRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RegistryAllocateHandleRequest &() const;
#else
    operator GCC_RegistryAllocateHandleRequest &();
    operator const GCC_RegistryAllocateHandleRequest &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_NonStandardPDU &() const;
#else
    operator GCC_NonStandardPDU &();
    operator const GCC_NonStandardPDU &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// ResponsePDU
//

class GCC_ConferenceJoinResponse;
class GCC_ConferenceAddResponse;
class GCC_ConferenceLockResponse;
class GCC_ConferenceUnlockResponse;
class GCC_ConferenceTerminateResponse;
class GCC_ConferenceEjectUserResponse;
class GCC_ConferenceTransferResponse;
class GCC_RegistryResponse;
class GCC_RegistryAllocateHandleResponse;
class GCC_FunctionNotSupportedResponse;
class GCC_NonStandardPDU;

class GCC_ResponsePDU : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ResponsePDU, PASN_Choice);
#endif
  public:
    GCC_ResponsePDU(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_conferenceJoinResponse,
      e_conferenceAddResponse,
      e_conferenceLockResponse,
      e_conferenceUnlockResponse,
      e_conferenceTerminateResponse,
      e_conferenceEjectUserResponse,
      e_conferenceTransferResponse,
      e_registryResponse,
      e_registryAllocateHandleResponse,
      e_functionNotSupportedResponse,
      e_nonStandardResponse
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceJoinResponse &() const;
#else
    operator GCC_ConferenceJoinResponse &();
    operator const GCC_ConferenceJoinResponse &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceAddResponse &() const;
#else
    operator GCC_ConferenceAddResponse &();
    operator const GCC_ConferenceAddResponse &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceLockResponse &() const;
#else
    operator GCC_ConferenceLockResponse &();
    operator const GCC_ConferenceLockResponse &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceUnlockResponse &() const;
#else
    operator GCC_ConferenceUnlockResponse &();
    operator const GCC_ConferenceUnlockResponse &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceTerminateResponse &() const;
#else
    operator GCC_ConferenceTerminateResponse &();
    operator const GCC_ConferenceTerminateResponse &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceEjectUserResponse &() const;
#else
    operator GCC_ConferenceEjectUserResponse &();
    operator const GCC_ConferenceEjectUserResponse &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceTransferResponse &() const;
#else
    operator GCC_ConferenceTransferResponse &();
    operator const GCC_ConferenceTransferResponse &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RegistryResponse &() const;
#else
    operator GCC_RegistryResponse &();
    operator const GCC_RegistryResponse &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RegistryAllocateHandleResponse &() const;
#else
    operator GCC_RegistryAllocateHandleResponse &();
    operator const GCC_RegistryAllocateHandleResponse &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_FunctionNotSupportedResponse &() const;
#else
    operator GCC_FunctionNotSupportedResponse &();
    operator const GCC_FunctionNotSupportedResponse &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_NonStandardPDU &() const;
#else
    operator GCC_NonStandardPDU &();
    operator const GCC_NonStandardPDU &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// IndicationPDU
//

class GCC_UserIDIndication;
class GCC_ConferenceLockIndication;
class GCC_ConferenceUnlockIndication;
class GCC_ConferenceTerminateIndication;
class GCC_ConferenceEjectUserIndication;
class GCC_ConferenceTransferIndication;
class GCC_RosterUpdateIndication;
class GCC_ApplicationInvokeIndication;
class GCC_RegistryMonitorEntryIndication;
class GCC_ConductorAssignIndication;
class GCC_ConductorReleaseIndication;
class GCC_ConductorPermissionAskIndication;
class GCC_ConductorPermissionGrantIndication;
class GCC_ConferenceTimeRemainingIndication;
class GCC_ConferenceTimeInquireIndication;
class GCC_ConferenceTimeExtendIndication;
class GCC_ConferenceAssistanceIndication;
class GCC_TextMessageIndication;
class GCC_NonStandardPDU;

class GCC_IndicationPDU : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_IndicationPDU, PASN_Choice);
#endif
  public:
    GCC_IndicationPDU(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_userIDIndication,
      e_conferenceLockIndication,
      e_conferenceUnlockIndication,
      e_conferenceTerminateIndication,
      e_conferenceEjectUserIndication,
      e_conferenceTransferIndication,
      e_rosterUpdateIndication,
      e_applicationInvokeIndication,
      e_registryMonitorEntryIndication,
      e_conductorAssignIndication,
      e_conductorReleaseIndication,
      e_conductorPermissionAskIndication,
      e_conductorPermissionGrantIndication,
      e_conferenceTimeRemainingIndication,
      e_conferenceTimeInquireIndication,
      e_conferenceTimeExtendIndication,
      e_conferenceAssistanceIndication,
      e_textMessageIndication,
      e_nonStandardIndication
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_UserIDIndication &() const;
#else
    operator GCC_UserIDIndication &();
    operator const GCC_UserIDIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceLockIndication &() const;
#else
    operator GCC_ConferenceLockIndication &();
    operator const GCC_ConferenceLockIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceUnlockIndication &() const;
#else
    operator GCC_ConferenceUnlockIndication &();
    operator const GCC_ConferenceUnlockIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceTerminateIndication &() const;
#else
    operator GCC_ConferenceTerminateIndication &();
    operator const GCC_ConferenceTerminateIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceEjectUserIndication &() const;
#else
    operator GCC_ConferenceEjectUserIndication &();
    operator const GCC_ConferenceEjectUserIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceTransferIndication &() const;
#else
    operator GCC_ConferenceTransferIndication &();
    operator const GCC_ConferenceTransferIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RosterUpdateIndication &() const;
#else
    operator GCC_RosterUpdateIndication &();
    operator const GCC_RosterUpdateIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ApplicationInvokeIndication &() const;
#else
    operator GCC_ApplicationInvokeIndication &();
    operator const GCC_ApplicationInvokeIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RegistryMonitorEntryIndication &() const;
#else
    operator GCC_RegistryMonitorEntryIndication &();
    operator const GCC_RegistryMonitorEntryIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConductorAssignIndication &() const;
#else
    operator GCC_ConductorAssignIndication &();
    operator const GCC_ConductorAssignIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConductorReleaseIndication &() const;
#else
    operator GCC_ConductorReleaseIndication &();
    operator const GCC_ConductorReleaseIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConductorPermissionAskIndication &() const;
#else
    operator GCC_ConductorPermissionAskIndication &();
    operator const GCC_ConductorPermissionAskIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConductorPermissionGrantIndication &() const;
#else
    operator GCC_ConductorPermissionGrantIndication &();
    operator const GCC_ConductorPermissionGrantIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceTimeRemainingIndication &() const;
#else
    operator GCC_ConferenceTimeRemainingIndication &();
    operator const GCC_ConferenceTimeRemainingIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceTimeInquireIndication &() const;
#else
    operator GCC_ConferenceTimeInquireIndication &();
    operator const GCC_ConferenceTimeInquireIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceTimeExtendIndication &() const;
#else
    operator GCC_ConferenceTimeExtendIndication &();
    operator const GCC_ConferenceTimeExtendIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ConferenceAssistanceIndication &() const;
#else
    operator GCC_ConferenceAssistanceIndication &();
    operator const GCC_ConferenceAssistanceIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_TextMessageIndication &() const;
#else
    operator GCC_TextMessageIndication &();
    operator const GCC_TextMessageIndication &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_NonStandardPDU &() const;
#else
    operator GCC_NonStandardPDU &();
    operator const GCC_NonStandardPDU &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// UserData_subtype
//

class GCC_UserData_subtype : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_UserData_subtype, PASN_Sequence);
#endif
  public:
    GCC_UserData_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_value
    };

    GCC_Key m_key;
    PASN_OctetString m_value;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ArrayOf_ChallengeItem
//

class GCC_ChallengeItem;

class GCC_ArrayOf_ChallengeItem : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ArrayOf_ChallengeItem, PASN_Array);
#endif
  public:
    GCC_ArrayOf_ChallengeItem(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_ChallengeItem & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// NetworkAddress_subtype
//

class GCC_NetworkAddress_subtype_aggregatedChannel;
class GCC_NetworkAddress_subtype_transportConnection;
class GCC_NonStandardParameter;

class GCC_NetworkAddress_subtype : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_NetworkAddress_subtype, PASN_Choice);
#endif
  public:
    GCC_NetworkAddress_subtype(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_aggregatedChannel,
      e_transportConnection,
      e_nonStandard
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_NetworkAddress_subtype_aggregatedChannel &() const;
#else
    operator GCC_NetworkAddress_subtype_aggregatedChannel &();
    operator const GCC_NetworkAddress_subtype_aggregatedChannel &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_NetworkAddress_subtype_transportConnection &() const;
#else
    operator GCC_NetworkAddress_subtype_transportConnection &();
    operator const GCC_NetworkAddress_subtype_transportConnection &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_NonStandardParameter &() const;
#else
    operator GCC_NonStandardParameter &();
    operator const GCC_NonStandardParameter &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// ArrayOf_TextString
//

class GCC_TextString;

class GCC_ArrayOf_TextString : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ArrayOf_TextString, PASN_Array);
#endif
  public:
    GCC_ArrayOf_TextString(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_TextString & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// ApplicationRecord_nonCollapsingCapabilities
//

class GCC_ApplicationRecord_nonCollapsingCapabilities_subtype;

class GCC_ApplicationRecord_nonCollapsingCapabilities : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ApplicationRecord_nonCollapsingCapabilities, PASN_Array);
#endif
  public:
    GCC_ApplicationRecord_nonCollapsingCapabilities(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_ApplicationRecord_nonCollapsingCapabilities_subtype & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// ApplicationInvokeSpecifier_expectedCapabilitySet
//

class GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype;

class GCC_ApplicationInvokeSpecifier_expectedCapabilitySet : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ApplicationInvokeSpecifier_expectedCapabilitySet, PASN_Array);
#endif
  public:
    GCC_ApplicationInvokeSpecifier_expectedCapabilitySet(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// RegistryEntryOwner_owned
//

class GCC_RegistryEntryOwner_owned : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistryEntryOwner_owned, PASN_Sequence);
#endif
  public:
    GCC_RegistryEntryOwner_owned(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_UserID m_nodeID;
    GCC_EntityID m_entityID;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ArrayOf_Privilege
//

class GCC_Privilege;

class GCC_ArrayOf_Privilege : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ArrayOf_Privilege, PASN_Array);
#endif
  public:
    GCC_ArrayOf_Privilege(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_Privilege & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// ConferenceCreateResponse_result
//

class GCC_ConferenceCreateResponse_result : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceCreateResponse_result, PASN_Enumeration);
#endif
  public:
    GCC_ConferenceCreateResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_success,
      e_userRejected,
      e_resourcesNotAvailable,
      e_rejectedForSymmetryBreaking,
      e_lockedConferenceNotSupported
    };

    GCC_ConferenceCreateResponse_result & operator=(unsigned v);
    PObject * Clone() const;
};


//
// ArrayOf_ConferenceDescriptor
//

class GCC_ConferenceDescriptor;

class GCC_ArrayOf_ConferenceDescriptor : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ArrayOf_ConferenceDescriptor, PASN_Array);
#endif
  public:
    GCC_ArrayOf_ConferenceDescriptor(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_ConferenceDescriptor & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// ConferenceQueryResponse_result
//

class GCC_ConferenceQueryResponse_result : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceQueryResponse_result, PASN_Enumeration);
#endif
  public:
    GCC_ConferenceQueryResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_success,
      e_userRejected
    };

    GCC_ConferenceQueryResponse_result & operator=(unsigned v);
    PObject * Clone() const;
};


//
// ConferenceJoinResponse_result
//

class GCC_ConferenceJoinResponse_result : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceJoinResponse_result, PASN_Enumeration);
#endif
  public:
    GCC_ConferenceJoinResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_success,
      e_userRejected,
      e_invalidConference,
      e_invalidPassword,
      e_invalidConvenerPassword,
      e_challengeResponseRequired,
      e_invalidChallengeResponse
    };

    GCC_ConferenceJoinResponse_result & operator=(unsigned v);
    PObject * Clone() const;
};


//
// ConferenceInviteResponse_result
//

class GCC_ConferenceInviteResponse_result : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceInviteResponse_result, PASN_Enumeration);
#endif
  public:
    GCC_ConferenceInviteResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_success,
      e_userRejected
    };

    GCC_ConferenceInviteResponse_result & operator=(unsigned v);
    PObject * Clone() const;
};


//
// ConferenceAddResponse_result
//

class GCC_ConferenceAddResponse_result : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceAddResponse_result, PASN_Enumeration);
#endif
  public:
    GCC_ConferenceAddResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_success,
      e_invalidRequester,
      e_invalidNetworkType,
      e_invalidNetworkAddress,
      e_addedNodeBusy,
      e_networkBusy,
      e_noPortsAvailable,
      e_connectionUnsuccessful
    };

    GCC_ConferenceAddResponse_result & operator=(unsigned v);
    PObject * Clone() const;
};


//
// ConferenceLockResponse_result
//

class GCC_ConferenceLockResponse_result : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceLockResponse_result, PASN_Enumeration);
#endif
  public:
    GCC_ConferenceLockResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_success,
      e_invalidRequester,
      e_alreadyLocked
    };

    GCC_ConferenceLockResponse_result & operator=(unsigned v);
    PObject * Clone() const;
};


//
// ConferenceUnlockResponse_result
//

class GCC_ConferenceUnlockResponse_result : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceUnlockResponse_result, PASN_Enumeration);
#endif
  public:
    GCC_ConferenceUnlockResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_success,
      e_invalidRequester,
      e_alreadyUnlocked
    };

    GCC_ConferenceUnlockResponse_result & operator=(unsigned v);
    PObject * Clone() const;
};


//
// ConferenceTerminateRequest_reason
//

class GCC_ConferenceTerminateRequest_reason : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceTerminateRequest_reason, PASN_Enumeration);
#endif
  public:
    GCC_ConferenceTerminateRequest_reason(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_userInitiated,
      e_timedConferenceTermination
    };

    GCC_ConferenceTerminateRequest_reason & operator=(unsigned v);
    PObject * Clone() const;
};


//
// ConferenceTerminateResponse_result
//

class GCC_ConferenceTerminateResponse_result : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceTerminateResponse_result, PASN_Enumeration);
#endif
  public:
    GCC_ConferenceTerminateResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_success,
      e_invalidRequester
    };

    GCC_ConferenceTerminateResponse_result & operator=(unsigned v);
    PObject * Clone() const;
};


//
// ConferenceTerminateIndication_reason
//

class GCC_ConferenceTerminateIndication_reason : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceTerminateIndication_reason, PASN_Enumeration);
#endif
  public:
    GCC_ConferenceTerminateIndication_reason(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_userInitiated,
      e_timedConferenceTermination
    };

    GCC_ConferenceTerminateIndication_reason & operator=(unsigned v);
    PObject * Clone() const;
};


//
// ConferenceEjectUserRequest_reason
//

class GCC_ConferenceEjectUserRequest_reason : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceEjectUserRequest_reason, PASN_Enumeration);
#endif
  public:
    GCC_ConferenceEjectUserRequest_reason(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_userInitiated
    };

    GCC_ConferenceEjectUserRequest_reason & operator=(unsigned v);
    PObject * Clone() const;
};


//
// ConferenceEjectUserResponse_result
//

class GCC_ConferenceEjectUserResponse_result : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceEjectUserResponse_result, PASN_Enumeration);
#endif
  public:
    GCC_ConferenceEjectUserResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_success,
      e_invalidRequester,
      e_invalidNode
    };

    GCC_ConferenceEjectUserResponse_result & operator=(unsigned v);
    PObject * Clone() const;
};


//
// ConferenceEjectUserIndication_reason
//

class GCC_ConferenceEjectUserIndication_reason : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceEjectUserIndication_reason, PASN_Enumeration);
#endif
  public:
    GCC_ConferenceEjectUserIndication_reason(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_userInitiated,
      e_higherNodeDisconnected,
      e_higherNodeEjected
    };

    GCC_ConferenceEjectUserIndication_reason & operator=(unsigned v);
    PObject * Clone() const;
};


//
// ArrayOf_UserID
//

class GCC_UserID;

class GCC_ArrayOf_UserID : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ArrayOf_UserID, PASN_Array);
#endif
  public:
    GCC_ArrayOf_UserID(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_UserID & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// ConferenceTransferResponse_result
//

class GCC_ConferenceTransferResponse_result : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceTransferResponse_result, PASN_Enumeration);
#endif
  public:
    GCC_ConferenceTransferResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_success,
      e_invalidRequester
    };

    GCC_ConferenceTransferResponse_result & operator=(unsigned v);
    PObject * Clone() const;
};


//
// RosterUpdateIndication_applicationInformation
//

class GCC_RosterUpdateIndication_applicationInformation_subtype;

class GCC_RosterUpdateIndication_applicationInformation : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation, PASN_Array);
#endif
  public:
    GCC_RosterUpdateIndication_applicationInformation(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_RosterUpdateIndication_applicationInformation_subtype & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// ArrayOf_ApplicationInvokeSpecifier
//

class GCC_ApplicationInvokeSpecifier;

class GCC_ArrayOf_ApplicationInvokeSpecifier : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ArrayOf_ApplicationInvokeSpecifier, PASN_Array);
#endif
  public:
    GCC_ArrayOf_ApplicationInvokeSpecifier(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_ApplicationInvokeSpecifier & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// RegistryAllocateHandleResponse_result
//

class GCC_RegistryAllocateHandleResponse_result : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistryAllocateHandleResponse_result, PASN_Enumeration);
#endif
  public:
    GCC_RegistryAllocateHandleResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_successful,
      e_noHandlesAvailable
    };

    GCC_RegistryAllocateHandleResponse_result & operator=(unsigned v);
    PObject * Clone() const;
};


//
// RegistryResponse_primitiveType
//

class GCC_RegistryResponse_primitiveType : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistryResponse_primitiveType, PASN_Enumeration);
#endif
  public:
    GCC_RegistryResponse_primitiveType(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_registerChannel,
      e_assignToken,
      e_setParameter,
      e_retrieveEntry,
      e_deleteEntry,
      e_monitorEntry
    };

    GCC_RegistryResponse_primitiveType & operator=(unsigned v);
    PObject * Clone() const;
};


//
// RegistryResponse_result
//

class GCC_RegistryResponse_result : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistryResponse_result, PASN_Enumeration);
#endif
  public:
    GCC_RegistryResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_successful,
      e_belongsToOther,
      e_tooManyEntries,
      e_inconsistentType,
      e_entryNotFound,
      e_entryAlreadyExists,
      e_invalidRequester
    };

    GCC_RegistryResponse_result & operator=(unsigned v);
    PObject * Clone() const;
};


//
// NetworkAddress_subtype_transportConnection
//

class GCC_NetworkAddress_subtype_transportConnection : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_NetworkAddress_subtype_transportConnection, PASN_Sequence);
#endif
  public:
    GCC_NetworkAddress_subtype_transportConnection(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_transportSelector
    };

    PASN_OctetString m_nsapAddress;
    PASN_OctetString m_transportSelector;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ApplicationRecord_nonCollapsingCapabilities_subtype
//

class GCC_ApplicationRecord_nonCollapsingCapabilities_subtype : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ApplicationRecord_nonCollapsingCapabilities_subtype, PASN_Sequence);
#endif
  public:
    GCC_ApplicationRecord_nonCollapsingCapabilities_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_applicationData
    };

    GCC_CapabilityID m_capabilityID;
    PASN_OctetString m_applicationData;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ApplicationInvokeSpecifier_expectedCapabilitySet_subtype
//

class GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype, PASN_Sequence);
#endif
  public:
    GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_CapabilityID m_capabilityID;
    GCC_CapabilityClass m_capabilityClass;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RosterUpdateIndication_nodeInformation_nodeRecordList
//

class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh;
class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update;

class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList, PASN_Choice);
#endif
  public:
    GCC_RosterUpdateIndication_nodeInformation_nodeRecordList(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_noChange,
      e_refresh,
      e_update
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh &() const;
#else
    operator GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh &();
    operator const GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update &() const;
#else
    operator GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update &();
    operator const GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// NetworkAddress_subtype_aggregatedChannel_transferModes
//

class GCC_NetworkAddress_subtype_aggregatedChannel_transferModes : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_NetworkAddress_subtype_aggregatedChannel_transferModes, PASN_Sequence);
#endif
  public:
    GCC_NetworkAddress_subtype_aggregatedChannel_transferModes(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    PASN_Boolean m_speech;
    PASN_Boolean m_voice_band;
    PASN_Boolean m_digital_56k;
    PASN_Boolean m_digital_64k;
    PASN_Boolean m_digital_128k;
    PASN_Boolean m_digital_192k;
    PASN_Boolean m_digital_256k;
    PASN_Boolean m_digital_320k;
    PASN_Boolean m_digital_384k;
    PASN_Boolean m_digital_512k;
    PASN_Boolean m_digital_768k;
    PASN_Boolean m_digital_1152k;
    PASN_Boolean m_digital_1472k;
    PASN_Boolean m_digital_1536k;
    PASN_Boolean m_digital_1920k;
    PASN_Boolean m_packet_mode;
    PASN_Boolean m_frame_mode;
    PASN_Boolean m_atm;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility
//

class GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility, PASN_Sequence);
#endif
  public:
    GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    PASN_Boolean m_telephony3kHz;
    PASN_Boolean m_telephony7kHz;
    PASN_Boolean m_videotelephony;
    PASN_Boolean m_videoconference;
    PASN_Boolean m_audiographic;
    PASN_Boolean m_audiovisual;
    PASN_Boolean m_multimedia;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RosterUpdateIndication_nodeInformation_nodeRecordList_refresh
//

class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype;

class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh, PASN_Array);
#endif
  public:
    GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// RosterUpdateIndication_nodeInformation_nodeRecordList_update
//

class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype;

class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update, PASN_Array);
#endif
  public:
    GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// RosterUpdateIndication_applicationInformation_subtype_applicationRecordList
//

class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh;
class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update;

class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList, PASN_Choice);
#endif
  public:
    GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_noChange,
      e_refresh,
      e_update
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh &() const;
#else
    operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh &();
    operator const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update &() const;
#else
    operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update &();
    operator const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList
//

class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh;

class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList, PASN_Choice);
#endif
  public:
    GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_noChange,
      e_refresh
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh &() const;
#else
    operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh &();
    operator const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh
//

class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype;

class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh, PASN_Array);
#endif
  public:
    GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update
//

class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype;

class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update, PASN_Array);
#endif
  public:
    GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh
//

class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype;

class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh, PASN_Array);
#endif
  public:
    GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate
//

class GCC_NodeRecord;

class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate, PASN_Choice);
#endif
  public:
    GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_addRecord,
      e_replaceRecord,
      e_removeRecord
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_NodeRecord &() const;
#else
    operator GCC_NodeRecord &();
    operator const GCC_NodeRecord &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype
//

class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype, PASN_Sequence);
#endif
  public:
    GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_CapabilityID m_capabilityID;
    GCC_CapabilityClass m_capabilityClass;
    PASN_Integer m_numberOfEntities;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate
//

class GCC_ApplicationRecord;

class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate, PASN_Choice);
#endif
  public:
    GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_addRecord,
      e_replaceRecord,
      e_removeRecord
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_ApplicationRecord &() const;
#else
    operator GCC_ApplicationRecord &();
    operator const GCC_ApplicationRecord &() const;
#endif

    PBoolean CreateObject();
    PObject * Clone() const;
};


//
// ChallengeRequest
//

class GCC_ChallengeRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ChallengeRequest, PASN_Sequence);
#endif
  public:
    GCC_ChallengeRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    PASN_Integer m_challengeTag;
    GCC_ArrayOf_ChallengeItem m_challengeSet;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// NodeRecord
//

class GCC_NodeRecord : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_NodeRecord, PASN_Sequence);
#endif
  public:
    GCC_NodeRecord(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_superiorNode,
      e_nodeName,
      e_participantsList,
      e_siteInformation,
      e_networkAddress,
      e_alternativeNodeID,
      e_userData
    };

    GCC_UserID m_superiorNode;
    GCC_NodeType m_nodeType;
    GCC_NodeProperties m_nodeProperties;
    GCC_TextString m_nodeName;
    GCC_ArrayOf_TextString m_participantsList;
    GCC_TextString m_siteInformation;
    GCC_NetworkAddress m_networkAddress;
    GCC_AlternativeNodeID m_alternativeNodeID;
    GCC_UserData m_userData;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ApplicationRecord
//

class GCC_ApplicationRecord : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ApplicationRecord, PASN_Sequence);
#endif
  public:
    GCC_ApplicationRecord(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_startupChannel,
      e_applicationUserID,
      e_nonCollapsingCapabilities
    };

    PASN_Boolean m_applicationActive;
    PASN_Boolean m_conductingOperationCapable;
    GCC_ChannelType m_startupChannel;
    GCC_UserID m_applicationUserID;
    GCC_ApplicationRecord_nonCollapsingCapabilities m_nonCollapsingCapabilities;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ApplicationInvokeSpecifier
//

class GCC_ApplicationInvokeSpecifier : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ApplicationInvokeSpecifier, PASN_Sequence);
#endif
  public:
    GCC_ApplicationInvokeSpecifier(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_expectedCapabilitySet,
      e_startupChannel
    };

    GCC_SessionKey m_sessionKey;
    GCC_ApplicationInvokeSpecifier_expectedCapabilitySet m_expectedCapabilitySet;
    GCC_ChannelType m_startupChannel;
    PASN_Boolean m_mandatoryFlag;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceCreateRequest
//

class GCC_ConferenceCreateRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceCreateRequest, PASN_Sequence);
#endif
  public:
    GCC_ConferenceCreateRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_convenerPassword,
      e_password,
      e_conductorPrivileges,
      e_conductedPrivileges,
      e_nonConductedPrivileges,
      e_conferenceDescription,
      e_callerIdentifier,
      e_userData,
      e_conferencePriority
    };

    GCC_ConferenceName m_conferenceName;
    GCC_Password m_convenerPassword;
    GCC_Password m_password;
    PASN_Boolean m_lockedConference;
    PASN_Boolean m_listedConference;
    PASN_Boolean m_conductibleConference;
    GCC_TerminationMethod m_terminationMethod;
    GCC_ArrayOf_Privilege m_conductorPrivileges;
    GCC_ArrayOf_Privilege m_conductedPrivileges;
    GCC_ArrayOf_Privilege m_nonConductedPrivileges;
    GCC_TextString m_conferenceDescription;
    GCC_TextString m_callerIdentifier;
    GCC_UserData m_userData;
    GCC_ConferencePriority m_conferencePriority;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceCreateResponse
//

class GCC_ConferenceCreateResponse : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceCreateResponse, PASN_Sequence);
#endif
  public:
    GCC_ConferenceCreateResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_userData
    };

    GCC_UserID m_nodeID;
    PASN_Integer m_tag;
    GCC_ConferenceCreateResponse_result m_result;
    GCC_UserData m_userData;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceQueryResponse
//

class GCC_ConferenceQueryResponse : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceQueryResponse, PASN_Sequence);
#endif
  public:
    GCC_ConferenceQueryResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_asymmetryIndicator,
      e_userData,
      e_waitForInvitationFlag,
      e_noUnlistedConferenceFlag
    };

    GCC_NodeType m_nodeType;
    GCC_AsymmetryIndicator m_asymmetryIndicator;
    GCC_ArrayOf_ConferenceDescriptor m_conferenceList;
    GCC_ConferenceQueryResponse_result m_result;
    GCC_UserData m_userData;
    PASN_Boolean m_waitForInvitationFlag;
    PASN_Boolean m_noUnlistedConferenceFlag;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceJoinResponse
//

class GCC_ConferenceJoinResponse : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceJoinResponse, PASN_Sequence);
#endif
  public:
    GCC_ConferenceJoinResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_nodeID,
      e_conferenceNameAlias,
      e_conductorPrivileges,
      e_conductedPrivileges,
      e_nonConductedPrivileges,
      e_conferenceDescription,
      e_password,
      e_userData
    };

    GCC_UserID m_nodeID;
    GCC_UserID m_topNodeID;
    PASN_Integer m_tag;
    GCC_ConferenceNameSelector m_conferenceNameAlias;
    PASN_Boolean m_passwordInTheClearRequired;
    PASN_Boolean m_lockedConference;
    PASN_Boolean m_listedConference;
    PASN_Boolean m_conductibleConference;
    GCC_TerminationMethod m_terminationMethod;
    GCC_ArrayOf_Privilege m_conductorPrivileges;
    GCC_ArrayOf_Privilege m_conductedPrivileges;
    GCC_ArrayOf_Privilege m_nonConductedPrivileges;
    GCC_TextString m_conferenceDescription;
    GCC_PasswordChallengeRequestResponse m_password;
    GCC_ConferenceJoinResponse_result m_result;
    GCC_UserData m_userData;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceInviteRequest
//

class GCC_ConferenceInviteRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceInviteRequest, PASN_Sequence);
#endif
  public:
    GCC_ConferenceInviteRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_conductorPrivileges,
      e_conductedPrivileges,
      e_nonConductedPrivileges,
      e_conferenceDescription,
      e_callerIdentifier,
      e_userData,
      e_conferencePriority
    };

    GCC_ConferenceName m_conferenceName;
    GCC_UserID m_nodeID;
    GCC_UserID m_topNodeID;
    PASN_Integer m_tag;
    PASN_Boolean m_passwordInTheClearRequired;
    PASN_Boolean m_lockedConference;
    PASN_Boolean m_listedConference;
    PASN_Boolean m_conductibleConference;
    GCC_TerminationMethod m_terminationMethod;
    GCC_ArrayOf_Privilege m_conductorPrivileges;
    GCC_ArrayOf_Privilege m_conductedPrivileges;
    GCC_ArrayOf_Privilege m_nonConductedPrivileges;
    GCC_TextString m_conferenceDescription;
    GCC_TextString m_callerIdentifier;
    GCC_UserData m_userData;
    GCC_ConferencePriority m_conferencePriority;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceInviteResponse
//

class GCC_ConferenceInviteResponse : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceInviteResponse, PASN_Sequence);
#endif
  public:
    GCC_ConferenceInviteResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_userData
    };

    GCC_ConferenceInviteResponse_result m_result;
    GCC_UserData m_userData;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceAddResponse
//

class GCC_ConferenceAddResponse : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceAddResponse, PASN_Sequence);
#endif
  public:
    GCC_ConferenceAddResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_userData
    };

    PASN_Integer m_tag;
    GCC_ConferenceAddResponse_result m_result;
    GCC_UserData m_userData;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceLockResponse
//

class GCC_ConferenceLockResponse : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceLockResponse, PASN_Sequence);
#endif
  public:
    GCC_ConferenceLockResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_ConferenceLockResponse_result m_result;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceUnlockResponse
//

class GCC_ConferenceUnlockResponse : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceUnlockResponse, PASN_Sequence);
#endif
  public:
    GCC_ConferenceUnlockResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_ConferenceUnlockResponse_result m_result;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceTerminateRequest
//

class GCC_ConferenceTerminateRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceTerminateRequest, PASN_Sequence);
#endif
  public:
    GCC_ConferenceTerminateRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_ConferenceTerminateRequest_reason m_reason;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceTerminateResponse
//

class GCC_ConferenceTerminateResponse : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceTerminateResponse, PASN_Sequence);
#endif
  public:
    GCC_ConferenceTerminateResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_ConferenceTerminateResponse_result m_result;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceTerminateIndication
//

class GCC_ConferenceTerminateIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceTerminateIndication, PASN_Sequence);
#endif
  public:
    GCC_ConferenceTerminateIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_ConferenceTerminateIndication_reason m_reason;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceEjectUserRequest
//

class GCC_ConferenceEjectUserRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceEjectUserRequest, PASN_Sequence);
#endif
  public:
    GCC_ConferenceEjectUserRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_UserID m_nodeToEject;
    GCC_ConferenceEjectUserRequest_reason m_reason;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceEjectUserResponse
//

class GCC_ConferenceEjectUserResponse : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceEjectUserResponse, PASN_Sequence);
#endif
  public:
    GCC_ConferenceEjectUserResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_UserID m_nodeToEject;
    GCC_ConferenceEjectUserResponse_result m_result;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceEjectUserIndication
//

class GCC_ConferenceEjectUserIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceEjectUserIndication, PASN_Sequence);
#endif
  public:
    GCC_ConferenceEjectUserIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_UserID m_nodeToEject;
    GCC_ConferenceEjectUserIndication_reason m_reason;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceTransferRequest
//

class GCC_ConferenceTransferRequest : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceTransferRequest, PASN_Sequence);
#endif
  public:
    GCC_ConferenceTransferRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_conferenceNameModifier,
      e_networkAddress,
      e_transferringNodes,
      e_password
    };

    GCC_ConferenceNameSelector m_conferenceName;
    GCC_ConferenceNameModifier m_conferenceNameModifier;
    GCC_NetworkAddress m_networkAddress;
    GCC_ArrayOf_UserID m_transferringNodes;
    GCC_PasswordSelector m_password;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceTransferResponse
//

class GCC_ConferenceTransferResponse : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceTransferResponse, PASN_Sequence);
#endif
  public:
    GCC_ConferenceTransferResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_conferenceNameModifier,
      e_transferringNodes
    };

    GCC_ConferenceNameSelector m_conferenceName;
    GCC_ConferenceNameModifier m_conferenceNameModifier;
    GCC_ArrayOf_UserID m_transferringNodes;
    GCC_ConferenceTransferResponse_result m_result;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceTransferIndication
//

class GCC_ConferenceTransferIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceTransferIndication, PASN_Sequence);
#endif
  public:
    GCC_ConferenceTransferIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_conferenceNameModifier,
      e_networkAddress,
      e_transferringNodes,
      e_password
    };

    GCC_ConferenceNameSelector m_conferenceName;
    GCC_ConferenceNameModifier m_conferenceNameModifier;
    GCC_NetworkAddress m_networkAddress;
    GCC_ArrayOf_UserID m_transferringNodes;
    GCC_PasswordSelector m_password;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ApplicationInvokeIndication
//

class GCC_ApplicationInvokeIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ApplicationInvokeIndication, PASN_Sequence);
#endif
  public:
    GCC_ApplicationInvokeIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_destinationNodes
    };

    GCC_ArrayOf_ApplicationInvokeSpecifier m_applicationProtocolEntiyList;
    GCC_ArrayOf_UserID m_destinationNodes;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RegistryAllocateHandleResponse
//

class GCC_RegistryAllocateHandleResponse : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistryAllocateHandleResponse, PASN_Sequence);
#endif
  public:
    GCC_RegistryAllocateHandleResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_EntityID m_entityID;
    PASN_Integer m_numberOfHandles;
    GCC_Handle m_firstHandle;
    GCC_RegistryAllocateHandleResponse_result m_result;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RegistryResponse
//

class GCC_RegistryResponse : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RegistryResponse, PASN_Sequence);
#endif
  public:
    GCC_RegistryResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_modificationRights
    };

    GCC_EntityID m_entityID;
    GCC_RegistryResponse_primitiveType m_primitiveType;
    GCC_RegistryKey m_key;
    GCC_RegistryItem m_item;
    GCC_RegistryEntryOwner m_owner;
    GCC_RegistryModificationRights m_modificationRights;
    GCC_RegistryResponse_result m_result;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConductorPermissionGrantIndication
//

class GCC_ConductorPermissionGrantIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConductorPermissionGrantIndication, PASN_Sequence);
#endif
  public:
    GCC_ConductorPermissionGrantIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_waitingList
    };

    GCC_ArrayOf_UserID m_permissionList;
    GCC_ArrayOf_UserID m_waitingList;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// FunctionNotSupportedResponse
//

class GCC_FunctionNotSupportedResponse : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_FunctionNotSupportedResponse, PASN_Sequence);
#endif
  public:
    GCC_FunctionNotSupportedResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_RequestPDU m_request;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// PasswordChallengeRequestResponse_challengeRequestResponse
//

class GCC_PasswordChallengeRequestResponse_challengeRequestResponse : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_PasswordChallengeRequestResponse_challengeRequestResponse, PASN_Sequence);
#endif
  public:
    GCC_PasswordChallengeRequestResponse_challengeRequestResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_challengeRequest,
      e_challengeResponse
    };

    GCC_ChallengeRequest m_challengeRequest;
    GCC_ChallengeResponse m_challengeResponse;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RosterUpdateIndication_nodeInformation
//

class GCC_RosterUpdateIndication_nodeInformation : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation, PASN_Sequence);
#endif
  public:
    GCC_RosterUpdateIndication_nodeInformation(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_RosterUpdateIndication_nodeInformation_nodeRecordList m_nodeRecordList;
    PASN_Integer m_rosterInstanceNumber;
    PASN_Boolean m_nodesAdded;
    PASN_Boolean m_nodesRemoved;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// NetworkAddress_subtype_aggregatedChannel
//

class GCC_NetworkAddress_subtype_aggregatedChannel : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_NetworkAddress_subtype_aggregatedChannel, PASN_Sequence);
#endif
  public:
    GCC_NetworkAddress_subtype_aggregatedChannel(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_subAddress,
      e_extraDialing,
      e_highLayerCompatibility
    };

    GCC_NetworkAddress_subtype_aggregatedChannel_transferModes m_transferModes;
    GCC_DialingString m_internationalNumber;
    GCC_SubAddressString m_subAddress;
    GCC_ExtraDialingString m_extraDialing;
    GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility m_highLayerCompatibility;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RosterUpdateIndication_applicationInformation_subtype
//

class GCC_RosterUpdateIndication_applicationInformation_subtype : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype, PASN_Sequence);
#endif
  public:
    GCC_RosterUpdateIndication_applicationInformation_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_SessionKey m_sessionKey;
    GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList m_applicationRecordList;
    GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList m_applicationCapabilitiesList;
    PASN_Integer m_rosterInstanceNumber;
    PASN_Boolean m_peerEntitiesAdded;
    PASN_Boolean m_peerEntitiesRemoved;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype
//

class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype, PASN_Sequence);
#endif
  public:
    GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_UserID m_nodeID;
    GCC_NodeRecord m_nodeRecord;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype
//

class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype, PASN_Sequence);
#endif
  public:
    GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_UserID m_nodeID;
    GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate m_nodeUpdate;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype
//

class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype, PASN_Sequence);
#endif
  public:
    GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_UserID m_nodeID;
    GCC_EntityID m_entityID;
    GCC_ApplicationRecord m_applicationRecord;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype
//

class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype, PASN_Sequence);
#endif
  public:
    GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_UserID m_nodeID;
    GCC_EntityID m_entityID;
    GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate m_applicationUpdate;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// RosterUpdateIndication
//

class GCC_RosterUpdateIndication : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_RosterUpdateIndication, PASN_Sequence);
#endif
  public:
    GCC_RosterUpdateIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    PASN_Boolean m_fullRefresh;
    GCC_RosterUpdateIndication_nodeInformation m_nodeInformation;
    GCC_RosterUpdateIndication_applicationInformation m_applicationInformation;

    PINDEX GetDataLength() const;
    PBoolean Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


#endif // __GCC_H

#endif // if ! H323_DISABLE_GCC


// End of gccpdu.h