// This C++ header file was generated by the TTCN-3 compiler
// of the TTCN-3 Test Executor version 11.1.0
// The generation of user and time information were disabled by the -D flag.

// Copyright (c) 2000-2025 Ericsson Telecom AB

// Do not edit this file unless you know what you are doing.

#ifndef IPA__Types_HH
#define IPA__Types_HH

#ifdef TITAN_RUNTIME_2
#error Generated code does not match with used runtime.\
 Code was generated without -R option but -DTITAN_RUNTIME_2 was used.
#endif

/* Header file includes */

#include <TTCN3.hh>
#include "Osmocom_Types.hh"

#if TTCN3_VERSION != 110100
#error Version mismatch detected.\
 Please check the version of the TTCN-3 compiler and the base library.\
 Run make clean and rebuild the project if the version of the compiler changed recently.
#endif

#ifndef LINUX
#error This file should be compiled on LINUX
#endif

#undef IPA__Types_HH
#endif

namespace IPA__Types {

/* Forward declarations of classes */

class IpaStreamId;
class IpaStreamId_template;
class IpaExtStreamId;
class IpaExtStreamId_template;
class PDU__IPA;
class PDU__IPA_template;
class IpaCcmMsgtype;
class IpaCcmMsgtype_template;
class IpaCcmIdTag;
class IpaCcmIdTag_template;
class IpaCcmGetPart;
class IpaCcmGetPart_template;
class IpaCcmIdGet;
class IpaCcmIdGet_template;
class IpaCcmRespPart;
class IpaCcmRespPart_template;
class IpaCcmIdResp;
class IpaCcmIdResp_template;
class IpaCcmUnion;
class IpaCcmUnion_template;
class PDU__IPA__CCM;
class PDU__IPA__CCM_template;
class IpaUnitId;
class IpaUnitId_template;

} /* end of namespace */

#ifndef IPA__Types_HH
#define IPA__Types_HH

namespace IPA__Types {

/* Class definitions */

class IpaStreamId : public Base_Type { // enum
friend class IpaStreamId_template;
public:
enum enum_type { IPAC__PROTO__RSL__TRX0 = 0, IPAC__PROTO__RSL__TRX1 = 1, IPAC__PROTO__RSL__TRX2 = 2, IPAC__PROTO__RSL__TRX3 = 3, IPAC__PROTO__OSMO = 238, IPAC__PROTO__MGCP__OLD = 252, IPAC__PROTO__SCCP = 253, IPAC__PROTO__CCM = 254, IPAC__PROTO__OML = 255, UNKNOWN_VALUE = 4, UNBOUND_VALUE = 5 };
private:
enum_type enum_value;

public:
IpaStreamId();
IpaStreamId(int other_value);
IpaStreamId(enum_type other_value);
IpaStreamId(const IpaStreamId& other_value);

IpaStreamId& operator=(int other_value);
IpaStreamId& operator=(enum_type other_value);
IpaStreamId& operator=(const IpaStreamId& other_value);

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const IpaStreamId& other_value) const;
inline boolean operator!=(int other_value) const { return !(*this == other_value); }
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const IpaStreamId& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const IpaStreamId& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const IpaStreamId& other_value) const;
inline boolean operator<=(int other_value) const { return !(*this > other_value); }
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const IpaStreamId& other_value) const { return !(*this > other_value); }
inline boolean operator>=(int other_value) const { return !(*this < other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const IpaStreamId& other_value) const { return !(*this < other_value); }

static const char *enum_to_str(enum_type enum_par);
static enum_type str_to_enum(const char *str_par, const int* int_par = NULL, const int* int_par2 = NULL);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const IpaStreamId& enum_par);
int as_int() const { return enum2int(enum_value); }
void from_int(int p_val) { *this = p_val; }
void int2enum(int int_val);
operator enum_type() const;
inline boolean is_bound() const { return enum_value != UNBOUND_VALUE; }
inline boolean is_value() const { return enum_value != UNBOUND_VALUE; }
inline void clean_up(){ enum_value = UNBOUND_VALUE; }
inline boolean is_present() const { return is_bound(); }
void log() const;
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class IpaStreamId_template : public Base_Template {
union {
IpaStreamId::enum_type single_value;
struct {
unsigned int n_values;
IpaStreamId_template *list_value;
} value_list;
struct {
IpaStreamId_template* precondition;
IpaStreamId_template* implied_template;
} implication_;
dynmatch_struct<IpaStreamId>* dyn_match;
};

void copy_template(const IpaStreamId_template& other_value);

public:
IpaStreamId_template();
IpaStreamId_template(template_sel other_value);
IpaStreamId_template(int other_value);
IpaStreamId_template(IpaStreamId::enum_type other_value);
IpaStreamId_template(const IpaStreamId& other_value);
IpaStreamId_template(const OPTIONAL<IpaStreamId>& other_value);
IpaStreamId_template(IpaStreamId_template* p_precondition, IpaStreamId_template* p_implied_template);
IpaStreamId_template(Dynamic_Match_Interface<IpaStreamId>* p_dyn_match);
IpaStreamId_template(const IpaStreamId_template& other_value);
~IpaStreamId_template();

boolean is_bound() const;
boolean is_value() const;
void clean_up();
IpaStreamId_template& operator=(template_sel other_value);
IpaStreamId_template& operator=(int other_value);
IpaStreamId_template& operator=(IpaStreamId::enum_type other_value);
IpaStreamId_template& operator=(const IpaStreamId& other_value);
IpaStreamId_template& operator=(const OPTIONAL<IpaStreamId>& other_value);
IpaStreamId_template& operator=(const IpaStreamId_template& other_value);

boolean match(IpaStreamId::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const IpaStreamId& other_value, boolean legacy = FALSE) const;
IpaStreamId::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
IpaStreamId_template& list_item(unsigned int list_index);
void log() const;
void log_match(const IpaStreamId& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
};

class IpaExtStreamId : public Base_Type { // enum
friend class IpaExtStreamId_template;
public:
enum enum_type { IPAC__PROTO__EXT__CTRL = 0, IPAC__PROTO__EXT__MGCP = 1, IPAC__PROTO__EXT__LAC = 2, IPAC__PROTO__EXT__SMSC = 3, IPAC__PROTO__EXT__ORC = 4, IPAC__PROTO__EXT__GSUP = 5, IPAC__PROTO__EXT__OAP = 6, IPAC__PROTO__EXT__RSPRO = 7, IPAC__PROTO__EXT__OSMO__PCU = 8, UNKNOWN_VALUE = 9, UNBOUND_VALUE = 10 };
private:
enum_type enum_value;

public:
IpaExtStreamId();
IpaExtStreamId(int other_value);
IpaExtStreamId(enum_type other_value);
IpaExtStreamId(const IpaExtStreamId& other_value);

IpaExtStreamId& operator=(int other_value);
IpaExtStreamId& operator=(enum_type other_value);
IpaExtStreamId& operator=(const IpaExtStreamId& other_value);

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const IpaExtStreamId& other_value) const;
inline boolean operator!=(int other_value) const { return !(*this == other_value); }
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const IpaExtStreamId& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const IpaExtStreamId& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const IpaExtStreamId& other_value) const;
inline boolean operator<=(int other_value) const { return !(*this > other_value); }
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const IpaExtStreamId& other_value) const { return !(*this > other_value); }
inline boolean operator>=(int other_value) const { return !(*this < other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const IpaExtStreamId& other_value) const { return !(*this < other_value); }

static const char *enum_to_str(enum_type enum_par);
static enum_type str_to_enum(const char *str_par, const int* int_par = NULL, const int* int_par2 = NULL);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const IpaExtStreamId& enum_par);
int as_int() const { return enum2int(enum_value); }
void from_int(int p_val) { *this = p_val; }
void int2enum(int int_val);
operator enum_type() const;
inline boolean is_bound() const { return enum_value != UNBOUND_VALUE; }
inline boolean is_value() const { return enum_value != UNBOUND_VALUE; }
inline void clean_up(){ enum_value = UNBOUND_VALUE; }
inline boolean is_present() const { return is_bound(); }
void log() const;
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class IpaExtStreamId_template : public Base_Template {
union {
IpaExtStreamId::enum_type single_value;
struct {
unsigned int n_values;
IpaExtStreamId_template *list_value;
} value_list;
struct {
IpaExtStreamId_template* precondition;
IpaExtStreamId_template* implied_template;
} implication_;
dynmatch_struct<IpaExtStreamId>* dyn_match;
};

void copy_template(const IpaExtStreamId_template& other_value);

public:
IpaExtStreamId_template();
IpaExtStreamId_template(template_sel other_value);
IpaExtStreamId_template(int other_value);
IpaExtStreamId_template(IpaExtStreamId::enum_type other_value);
IpaExtStreamId_template(const IpaExtStreamId& other_value);
IpaExtStreamId_template(const OPTIONAL<IpaExtStreamId>& other_value);
IpaExtStreamId_template(IpaExtStreamId_template* p_precondition, IpaExtStreamId_template* p_implied_template);
IpaExtStreamId_template(Dynamic_Match_Interface<IpaExtStreamId>* p_dyn_match);
IpaExtStreamId_template(const IpaExtStreamId_template& other_value);
~IpaExtStreamId_template();

boolean is_bound() const;
boolean is_value() const;
void clean_up();
IpaExtStreamId_template& operator=(template_sel other_value);
IpaExtStreamId_template& operator=(int other_value);
IpaExtStreamId_template& operator=(IpaExtStreamId::enum_type other_value);
IpaExtStreamId_template& operator=(const IpaExtStreamId& other_value);
IpaExtStreamId_template& operator=(const OPTIONAL<IpaExtStreamId>& other_value);
IpaExtStreamId_template& operator=(const IpaExtStreamId_template& other_value);

boolean match(IpaExtStreamId::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const IpaExtStreamId& other_value, boolean legacy = FALSE) const;
IpaExtStreamId::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
IpaExtStreamId_template& list_item(unsigned int list_index);
void log() const;
void log_match(const IpaExtStreamId& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
};

class PDU__IPA : public Base_Type {
  INTEGER field_lengthInd;
  IpaStreamId field_streamId;
  OPTIONAL< IpaExtStreamId > field_streamIdExt;
  OCTETSTRING field_payloadData;
public:
  PDU__IPA();
  PDU__IPA(const INTEGER& par_lengthInd,
    const IpaStreamId& par_streamId,
    const OPTIONAL< IpaExtStreamId >& par_streamIdExt,
    const OCTETSTRING& par_payloadData);
  PDU__IPA(const PDU__IPA& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  PDU__IPA& operator=(const PDU__IPA& other_value);
  boolean operator==(const PDU__IPA& other_value) const;
  inline boolean operator!=(const PDU__IPA& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline INTEGER& lengthInd()
    {return field_lengthInd;}
  inline const INTEGER& lengthInd() const
    {return field_lengthInd;}
  inline IpaStreamId& streamId()
    {return field_streamId;}
  inline const IpaStreamId& streamId() const
    {return field_streamId;}
  inline OPTIONAL< IpaExtStreamId >& streamIdExt()
    {return field_streamIdExt;}
  inline const OPTIONAL< IpaExtStreamId >& streamIdExt() const
    {return field_streamIdExt;}
  inline OCTETSTRING& payloadData()
    {return field_payloadData;}
  inline const OCTETSTRING& payloadData() const
    {return field_payloadData;}
  int size_of() const;
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class PDU__IPA_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
PDU__IPA_template *list_value;
} value_list;
struct {
PDU__IPA_template* precondition;
PDU__IPA_template* implied_template;
} implication_;
dynmatch_struct<PDU__IPA>* dyn_match;
};

void set_specific();
void copy_value(const PDU__IPA& other_value);
void copy_template(const PDU__IPA_template& other_value);

public:
PDU__IPA_template();
PDU__IPA_template(template_sel other_value);
PDU__IPA_template(const PDU__IPA& other_value);
PDU__IPA_template(const OPTIONAL<PDU__IPA>& other_value);
PDU__IPA_template(PDU__IPA_template* p_precondition, PDU__IPA_template* p_implied_template);
PDU__IPA_template(Dynamic_Match_Interface<PDU__IPA>* p_dyn_match);
PDU__IPA_template(const PDU__IPA_template& other_value);
~PDU__IPA_template();
PDU__IPA_template& operator=(template_sel other_value);
PDU__IPA_template& operator=(const PDU__IPA& other_value);
PDU__IPA_template& operator=(const OPTIONAL<PDU__IPA>& other_value);
PDU__IPA_template& operator=(const PDU__IPA_template& other_value);
boolean match(const PDU__IPA& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
PDU__IPA valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
PDU__IPA_template& list_item(unsigned int list_index) const;
INTEGER_template& lengthInd();
const INTEGER_template& lengthInd() const;
IpaStreamId_template& streamId();
const IpaStreamId_template& streamId() const;
IpaExtStreamId_template& streamIdExt();
const IpaExtStreamId_template& streamIdExt() const;
OCTETSTRING_template& payloadData();
const OCTETSTRING_template& payloadData() const;
int size_of() const;
void log() const;
void log_match(const PDU__IPA& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class IpaCcmMsgtype : public Base_Type { // enum
friend class IpaCcmMsgtype_template;
public:
enum enum_type { IPAC__MSGT__PING = 0, IPAC__MSGT__PONG = 1, IPAC__MSGT__ID__GET = 4, IPAC__MSGT__ID__RESP = 5, IPAC__MSGT__ID__ACK = 6, UNKNOWN_VALUE = 2, UNBOUND_VALUE = 3 };
private:
enum_type enum_value;

public:
IpaCcmMsgtype();
IpaCcmMsgtype(int other_value);
IpaCcmMsgtype(enum_type other_value);
IpaCcmMsgtype(const IpaCcmMsgtype& other_value);

IpaCcmMsgtype& operator=(int other_value);
IpaCcmMsgtype& operator=(enum_type other_value);
IpaCcmMsgtype& operator=(const IpaCcmMsgtype& other_value);

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const IpaCcmMsgtype& other_value) const;
inline boolean operator!=(int other_value) const { return !(*this == other_value); }
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const IpaCcmMsgtype& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const IpaCcmMsgtype& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const IpaCcmMsgtype& other_value) const;
inline boolean operator<=(int other_value) const { return !(*this > other_value); }
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const IpaCcmMsgtype& other_value) const { return !(*this > other_value); }
inline boolean operator>=(int other_value) const { return !(*this < other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const IpaCcmMsgtype& other_value) const { return !(*this < other_value); }

static const char *enum_to_str(enum_type enum_par);
static enum_type str_to_enum(const char *str_par, const int* int_par = NULL, const int* int_par2 = NULL);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const IpaCcmMsgtype& enum_par);
int as_int() const { return enum2int(enum_value); }
void from_int(int p_val) { *this = p_val; }
void int2enum(int int_val);
operator enum_type() const;
inline boolean is_bound() const { return enum_value != UNBOUND_VALUE; }
inline boolean is_value() const { return enum_value != UNBOUND_VALUE; }
inline void clean_up(){ enum_value = UNBOUND_VALUE; }
inline boolean is_present() const { return is_bound(); }
void log() const;
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class IpaCcmMsgtype_template : public Base_Template {
union {
IpaCcmMsgtype::enum_type single_value;
struct {
unsigned int n_values;
IpaCcmMsgtype_template *list_value;
} value_list;
struct {
IpaCcmMsgtype_template* precondition;
IpaCcmMsgtype_template* implied_template;
} implication_;
dynmatch_struct<IpaCcmMsgtype>* dyn_match;
};

void copy_template(const IpaCcmMsgtype_template& other_value);

public:
IpaCcmMsgtype_template();
IpaCcmMsgtype_template(template_sel other_value);
IpaCcmMsgtype_template(int other_value);
IpaCcmMsgtype_template(IpaCcmMsgtype::enum_type other_value);
IpaCcmMsgtype_template(const IpaCcmMsgtype& other_value);
IpaCcmMsgtype_template(const OPTIONAL<IpaCcmMsgtype>& other_value);
IpaCcmMsgtype_template(IpaCcmMsgtype_template* p_precondition, IpaCcmMsgtype_template* p_implied_template);
IpaCcmMsgtype_template(Dynamic_Match_Interface<IpaCcmMsgtype>* p_dyn_match);
IpaCcmMsgtype_template(const IpaCcmMsgtype_template& other_value);
~IpaCcmMsgtype_template();

boolean is_bound() const;
boolean is_value() const;
void clean_up();
IpaCcmMsgtype_template& operator=(template_sel other_value);
IpaCcmMsgtype_template& operator=(int other_value);
IpaCcmMsgtype_template& operator=(IpaCcmMsgtype::enum_type other_value);
IpaCcmMsgtype_template& operator=(const IpaCcmMsgtype& other_value);
IpaCcmMsgtype_template& operator=(const OPTIONAL<IpaCcmMsgtype>& other_value);
IpaCcmMsgtype_template& operator=(const IpaCcmMsgtype_template& other_value);

boolean match(IpaCcmMsgtype::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const IpaCcmMsgtype& other_value, boolean legacy = FALSE) const;
IpaCcmMsgtype::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
IpaCcmMsgtype_template& list_item(unsigned int list_index);
void log() const;
void log_match(const IpaCcmMsgtype& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
};

class IpaCcmIdTag : public Base_Type { // enum
friend class IpaCcmIdTag_template;
public:
enum enum_type { IPAC__IDTAG__SERNR = 0, IPAC__IDTAG__UNITNAME = 1, IPAC__IDTAG__LOCATION1 = 2, IPAC__IDTAG__LOCATION2 = 3, IPAC__IDTAG__EQUIPVERS = 4, IPAC__IDTAG__SWVERSION = 5, IPAC__IDTAG__IPADDR = 6, IPAC__IDTAG__MACADDR = 7, IPAC__IDTAG__UNITID = 8, IPAC__IDTAG__OSMO__RAND = 35, UNKNOWN_VALUE = 9, UNBOUND_VALUE = 10 };
private:
enum_type enum_value;

public:
IpaCcmIdTag();
IpaCcmIdTag(int other_value);
IpaCcmIdTag(enum_type other_value);
IpaCcmIdTag(const IpaCcmIdTag& other_value);

IpaCcmIdTag& operator=(int other_value);
IpaCcmIdTag& operator=(enum_type other_value);
IpaCcmIdTag& operator=(const IpaCcmIdTag& other_value);

boolean operator==(int other_value) const;
boolean operator==(enum_type other_value) const;
boolean operator==(const IpaCcmIdTag& other_value) const;
inline boolean operator!=(int other_value) const { return !(*this == other_value); }
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const IpaCcmIdTag& other_value) const { return !(*this == other_value); }
boolean operator<(int other_value) const;
boolean operator<(enum_type other_value) const;
boolean operator<(const IpaCcmIdTag& other_value) const;
boolean operator>(int other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const IpaCcmIdTag& other_value) const;
inline boolean operator<=(int other_value) const { return !(*this > other_value); }
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const IpaCcmIdTag& other_value) const { return !(*this > other_value); }
inline boolean operator>=(int other_value) const { return !(*this < other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const IpaCcmIdTag& other_value) const { return !(*this < other_value); }

static const char *enum_to_str(enum_type enum_par);
static enum_type str_to_enum(const char *str_par, const int* int_par = NULL, const int* int_par2 = NULL);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const IpaCcmIdTag& enum_par);
int as_int() const { return enum2int(enum_value); }
void from_int(int p_val) { *this = p_val; }
void int2enum(int int_val);
operator enum_type() const;
inline boolean is_bound() const { return enum_value != UNBOUND_VALUE; }
inline boolean is_value() const { return enum_value != UNBOUND_VALUE; }
inline void clean_up(){ enum_value = UNBOUND_VALUE; }
inline boolean is_present() const { return is_bound(); }
void log() const;
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class IpaCcmIdTag_template : public Base_Template {
union {
IpaCcmIdTag::enum_type single_value;
struct {
unsigned int n_values;
IpaCcmIdTag_template *list_value;
} value_list;
struct {
IpaCcmIdTag_template* precondition;
IpaCcmIdTag_template* implied_template;
} implication_;
dynmatch_struct<IpaCcmIdTag>* dyn_match;
};

void copy_template(const IpaCcmIdTag_template& other_value);

public:
IpaCcmIdTag_template();
IpaCcmIdTag_template(template_sel other_value);
IpaCcmIdTag_template(int other_value);
IpaCcmIdTag_template(IpaCcmIdTag::enum_type other_value);
IpaCcmIdTag_template(const IpaCcmIdTag& other_value);
IpaCcmIdTag_template(const OPTIONAL<IpaCcmIdTag>& other_value);
IpaCcmIdTag_template(IpaCcmIdTag_template* p_precondition, IpaCcmIdTag_template* p_implied_template);
IpaCcmIdTag_template(Dynamic_Match_Interface<IpaCcmIdTag>* p_dyn_match);
IpaCcmIdTag_template(const IpaCcmIdTag_template& other_value);
~IpaCcmIdTag_template();

boolean is_bound() const;
boolean is_value() const;
void clean_up();
IpaCcmIdTag_template& operator=(template_sel other_value);
IpaCcmIdTag_template& operator=(int other_value);
IpaCcmIdTag_template& operator=(IpaCcmIdTag::enum_type other_value);
IpaCcmIdTag_template& operator=(const IpaCcmIdTag& other_value);
IpaCcmIdTag_template& operator=(const OPTIONAL<IpaCcmIdTag>& other_value);
IpaCcmIdTag_template& operator=(const IpaCcmIdTag_template& other_value);

boolean match(IpaCcmIdTag::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const IpaCcmIdTag& other_value, boolean legacy = FALSE) const;
IpaCcmIdTag::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
IpaCcmIdTag_template& list_item(unsigned int list_index);
void log() const;
void log_match(const IpaCcmIdTag& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
};

class IpaCcmGetPart : public Base_Type {
  INTEGER field_len;
  IpaCcmIdTag field_tag;
public:
  IpaCcmGetPart();
  IpaCcmGetPart(const INTEGER& par_len,
    const IpaCcmIdTag& par_tag);
  IpaCcmGetPart(const IpaCcmGetPart& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  IpaCcmGetPart& operator=(const IpaCcmGetPart& other_value);
  boolean operator==(const IpaCcmGetPart& other_value) const;
  inline boolean operator!=(const IpaCcmGetPart& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline INTEGER& len()
    {return field_len;}
  inline const INTEGER& len() const
    {return field_len;}
  inline IpaCcmIdTag& tag()
    {return field_tag;}
  inline const IpaCcmIdTag& tag() const
    {return field_tag;}
  inline int size_of() const
    {return 2;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class IpaCcmGetPart_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
IpaCcmGetPart_template *list_value;
} value_list;
struct {
IpaCcmGetPart_template* precondition;
IpaCcmGetPart_template* implied_template;
} implication_;
dynmatch_struct<IpaCcmGetPart>* dyn_match;
};

void set_specific();
void copy_value(const IpaCcmGetPart& other_value);
void copy_template(const IpaCcmGetPart_template& other_value);

public:
IpaCcmGetPart_template();
IpaCcmGetPart_template(template_sel other_value);
IpaCcmGetPart_template(const IpaCcmGetPart& other_value);
IpaCcmGetPart_template(const OPTIONAL<IpaCcmGetPart>& other_value);
IpaCcmGetPart_template(IpaCcmGetPart_template* p_precondition, IpaCcmGetPart_template* p_implied_template);
IpaCcmGetPart_template(Dynamic_Match_Interface<IpaCcmGetPart>* p_dyn_match);
IpaCcmGetPart_template(const IpaCcmGetPart_template& other_value);
~IpaCcmGetPart_template();
IpaCcmGetPart_template& operator=(template_sel other_value);
IpaCcmGetPart_template& operator=(const IpaCcmGetPart& other_value);
IpaCcmGetPart_template& operator=(const OPTIONAL<IpaCcmGetPart>& other_value);
IpaCcmGetPart_template& operator=(const IpaCcmGetPart_template& other_value);
boolean match(const IpaCcmGetPart& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
IpaCcmGetPart valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
IpaCcmGetPart_template& list_item(unsigned int list_index) const;
INTEGER_template& len();
const INTEGER_template& len() const;
IpaCcmIdTag_template& tag();
const IpaCcmIdTag_template& tag() const;
int size_of() const;
void log() const;
void log_match(const IpaCcmGetPart& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class IpaCcmIdGet : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
IpaCcmGetPart **value_elements;
} *val_ptr;

static const IpaCcmGetPart UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const IpaCcmIdGet& other_value);
static boolean compare_function(const Base_Type *left_ptr, int left_index, const Base_Type *right_ptr, int right_index);

public:
  typedef IpaCcmGetPart of_type;
IpaCcmIdGet();
IpaCcmIdGet(null_type other_value);
IpaCcmIdGet(const IpaCcmIdGet& other_value);
~IpaCcmIdGet();

void clean_up();
IpaCcmIdGet& operator=(null_type other_value);
IpaCcmIdGet& operator=(const IpaCcmIdGet& other_value);

boolean operator==(null_type other_value) const;
boolean operator==(const IpaCcmIdGet& other_value) const;
inline boolean operator!=(null_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const IpaCcmIdGet& other_value) const { return !(*this == other_value); }

IpaCcmGetPart& operator[](int index_value);
IpaCcmGetPart& operator[](const INTEGER& index_value);
const IpaCcmGetPart& operator[](int index_value) const;
const IpaCcmGetPart& operator[](const INTEGER& index_value) const;

IpaCcmIdGet operator<<=(int rotate_count) const;
IpaCcmIdGet operator<<=(const INTEGER& rotate_count) const;
IpaCcmIdGet operator>>=(int rotate_count) const;
IpaCcmIdGet operator>>=(const INTEGER& rotate_count) const;

IpaCcmIdGet operator+(const IpaCcmIdGet& other_value) const;

IpaCcmIdGet substr(int index, int returncount) const;

IpaCcmIdGet replace(int index, int len, const IpaCcmIdGet& repl) const;

IpaCcmIdGet replace(int index, int len, const IpaCcmIdGet_template& repl) const;

void set_size(int new_size);
inline boolean is_bound() const {return val_ptr != NULL; }
inline boolean is_present() const { return is_bound(); }
boolean is_value() const;
int size_of() const;
int n_elem() const { return size_of(); }
int lengthof() const;
void log() const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class IpaCcmIdGet_template : public Restricted_Length_Template {
union {
struct {
int n_elements;
IpaCcmGetPart_template **value_elements;
} single_value;
struct {
unsigned int n_values;
IpaCcmIdGet_template *list_value;
} value_list;
struct {
IpaCcmIdGet_template* precondition;
IpaCcmIdGet_template* implied_template;
} implication_;
dynmatch_struct<IpaCcmIdGet>* dyn_match;
struct {
unsigned int n_items;
IpaCcmGetPart_template *set_items;
} value_set;
};
void copy_value(const IpaCcmIdGet& other_value);
void copy_template(const IpaCcmIdGet_template& other_value);
static boolean match_function_specific(const Base_Type *value_ptr, int value_index, const Restricted_Length_Template *template_ptr, int template_index, boolean legacy);
static boolean match_function_set(const Base_Type *value_ptr, int value_index, const Restricted_Length_Template *template_ptr, int template_index, boolean legacy);
static void log_function(const Base_Type *value_ptr, const Restricted_Length_Template *template_ptr, int index_value, int index_template, boolean legacy);

public:
IpaCcmIdGet_template();
IpaCcmIdGet_template(template_sel other_value);
IpaCcmIdGet_template(null_type other_value);
IpaCcmIdGet_template(const IpaCcmIdGet& other_value);
IpaCcmIdGet_template(const OPTIONAL<IpaCcmIdGet>& other_value);
IpaCcmIdGet_template(IpaCcmIdGet_template* p_precondition, IpaCcmIdGet_template* p_implied_template);
IpaCcmIdGet_template(Dynamic_Match_Interface<IpaCcmIdGet>* p_dyn_match);
IpaCcmIdGet_template(const IpaCcmIdGet_template& other_value);
~IpaCcmIdGet_template();

void clean_up();
IpaCcmIdGet_template& operator=(template_sel other_value);
IpaCcmIdGet_template& operator=(null_type other_value);
IpaCcmIdGet_template& operator=(const IpaCcmIdGet& other_value);
IpaCcmIdGet_template& operator=(const OPTIONAL<IpaCcmIdGet>& other_value);
IpaCcmIdGet_template& operator=(const IpaCcmIdGet_template& other_value);

IpaCcmGetPart_template& operator[](int index_value);
IpaCcmGetPart_template& operator[](const INTEGER& index_value);
const IpaCcmGetPart_template& operator[](int index_value) const;
const IpaCcmGetPart_template& operator[](const INTEGER& index_value) const;

void set_size(int new_size);
int n_elem() const;
int size_of(boolean is_size) const;
inline int size_of() const { return size_of(TRUE); }
inline int lengthof() const { return size_of(FALSE); }
boolean match(const IpaCcmIdGet& other_value, boolean legacy = FALSE) const;
inline boolean is_bound() const 
  {return template_selection != UNINITIALIZED_TEMPLATE; }
boolean is_value() const;
IpaCcmIdGet valueof() const;
IpaCcmIdGet substr(int index, int returncount) const;

IpaCcmIdGet replace(int index, int len, const IpaCcmIdGet_template& repl) const;

IpaCcmIdGet replace(int index, int len, const IpaCcmIdGet& repl) const;

void set_type(template_sel template_type, unsigned int list_length);
IpaCcmIdGet_template& list_item(unsigned int list_index);
IpaCcmGetPart_template& set_item(unsigned int set_index);
void log() const;
void log_match(const IpaCcmIdGet& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean get_istemplate_kind(const char* type) const;
};

class IpaCcmRespPart : public Base_Type {
  INTEGER field_len;
  IpaCcmIdTag field_tag;
  OCTETSTRING field_data;
public:
  IpaCcmRespPart();
  IpaCcmRespPart(const INTEGER& par_len,
    const IpaCcmIdTag& par_tag,
    const OCTETSTRING& par_data);
  IpaCcmRespPart(const IpaCcmRespPart& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  IpaCcmRespPart& operator=(const IpaCcmRespPart& other_value);
  boolean operator==(const IpaCcmRespPart& other_value) const;
  inline boolean operator!=(const IpaCcmRespPart& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline INTEGER& len()
    {return field_len;}
  inline const INTEGER& len() const
    {return field_len;}
  inline IpaCcmIdTag& tag()
    {return field_tag;}
  inline const IpaCcmIdTag& tag() const
    {return field_tag;}
  inline OCTETSTRING& data()
    {return field_data;}
  inline const OCTETSTRING& data() const
    {return field_data;}
  inline int size_of() const
    {return 3;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class IpaCcmRespPart_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
IpaCcmRespPart_template *list_value;
} value_list;
struct {
IpaCcmRespPart_template* precondition;
IpaCcmRespPart_template* implied_template;
} implication_;
dynmatch_struct<IpaCcmRespPart>* dyn_match;
};

void set_specific();
void copy_value(const IpaCcmRespPart& other_value);
void copy_template(const IpaCcmRespPart_template& other_value);

public:
IpaCcmRespPart_template();
IpaCcmRespPart_template(template_sel other_value);
IpaCcmRespPart_template(const IpaCcmRespPart& other_value);
IpaCcmRespPart_template(const OPTIONAL<IpaCcmRespPart>& other_value);
IpaCcmRespPart_template(IpaCcmRespPart_template* p_precondition, IpaCcmRespPart_template* p_implied_template);
IpaCcmRespPart_template(Dynamic_Match_Interface<IpaCcmRespPart>* p_dyn_match);
IpaCcmRespPart_template(const IpaCcmRespPart_template& other_value);
~IpaCcmRespPart_template();
IpaCcmRespPart_template& operator=(template_sel other_value);
IpaCcmRespPart_template& operator=(const IpaCcmRespPart& other_value);
IpaCcmRespPart_template& operator=(const OPTIONAL<IpaCcmRespPart>& other_value);
IpaCcmRespPart_template& operator=(const IpaCcmRespPart_template& other_value);
boolean match(const IpaCcmRespPart& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
IpaCcmRespPart valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
IpaCcmRespPart_template& list_item(unsigned int list_index) const;
INTEGER_template& len();
const INTEGER_template& len() const;
IpaCcmIdTag_template& tag();
const IpaCcmIdTag_template& tag() const;
OCTETSTRING_template& data();
const OCTETSTRING_template& data() const;
int size_of() const;
void log() const;
void log_match(const IpaCcmRespPart& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class IpaCcmIdResp : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
IpaCcmRespPart **value_elements;
} *val_ptr;

static const IpaCcmRespPart UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const IpaCcmIdResp& other_value);
static boolean compare_function(const Base_Type *left_ptr, int left_index, const Base_Type *right_ptr, int right_index);

public:
  typedef IpaCcmRespPart of_type;
IpaCcmIdResp();
IpaCcmIdResp(null_type other_value);
IpaCcmIdResp(const IpaCcmIdResp& other_value);
~IpaCcmIdResp();

void clean_up();
IpaCcmIdResp& operator=(null_type other_value);
IpaCcmIdResp& operator=(const IpaCcmIdResp& other_value);

boolean operator==(null_type other_value) const;
boolean operator==(const IpaCcmIdResp& other_value) const;
inline boolean operator!=(null_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const IpaCcmIdResp& other_value) const { return !(*this == other_value); }

IpaCcmRespPart& operator[](int index_value);
IpaCcmRespPart& operator[](const INTEGER& index_value);
const IpaCcmRespPart& operator[](int index_value) const;
const IpaCcmRespPart& operator[](const INTEGER& index_value) const;

IpaCcmIdResp operator<<=(int rotate_count) const;
IpaCcmIdResp operator<<=(const INTEGER& rotate_count) const;
IpaCcmIdResp operator>>=(int rotate_count) const;
IpaCcmIdResp operator>>=(const INTEGER& rotate_count) const;

IpaCcmIdResp operator+(const IpaCcmIdResp& other_value) const;

IpaCcmIdResp substr(int index, int returncount) const;

IpaCcmIdResp replace(int index, int len, const IpaCcmIdResp& repl) const;

IpaCcmIdResp replace(int index, int len, const IpaCcmIdResp_template& repl) const;

void set_size(int new_size);
inline boolean is_bound() const {return val_ptr != NULL; }
inline boolean is_present() const { return is_bound(); }
boolean is_value() const;
int size_of() const;
int n_elem() const { return size_of(); }
int lengthof() const;
void log() const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class IpaCcmIdResp_template : public Restricted_Length_Template {
union {
struct {
int n_elements;
IpaCcmRespPart_template **value_elements;
} single_value;
struct {
unsigned int n_values;
IpaCcmIdResp_template *list_value;
} value_list;
struct {
IpaCcmIdResp_template* precondition;
IpaCcmIdResp_template* implied_template;
} implication_;
dynmatch_struct<IpaCcmIdResp>* dyn_match;
struct {
unsigned int n_items;
IpaCcmRespPart_template *set_items;
} value_set;
};
void copy_value(const IpaCcmIdResp& other_value);
void copy_template(const IpaCcmIdResp_template& other_value);
static boolean match_function_specific(const Base_Type *value_ptr, int value_index, const Restricted_Length_Template *template_ptr, int template_index, boolean legacy);
static boolean match_function_set(const Base_Type *value_ptr, int value_index, const Restricted_Length_Template *template_ptr, int template_index, boolean legacy);
static void log_function(const Base_Type *value_ptr, const Restricted_Length_Template *template_ptr, int index_value, int index_template, boolean legacy);

public:
IpaCcmIdResp_template();
IpaCcmIdResp_template(template_sel other_value);
IpaCcmIdResp_template(null_type other_value);
IpaCcmIdResp_template(const IpaCcmIdResp& other_value);
IpaCcmIdResp_template(const OPTIONAL<IpaCcmIdResp>& other_value);
IpaCcmIdResp_template(IpaCcmIdResp_template* p_precondition, IpaCcmIdResp_template* p_implied_template);
IpaCcmIdResp_template(Dynamic_Match_Interface<IpaCcmIdResp>* p_dyn_match);
IpaCcmIdResp_template(const IpaCcmIdResp_template& other_value);
~IpaCcmIdResp_template();

void clean_up();
IpaCcmIdResp_template& operator=(template_sel other_value);
IpaCcmIdResp_template& operator=(null_type other_value);
IpaCcmIdResp_template& operator=(const IpaCcmIdResp& other_value);
IpaCcmIdResp_template& operator=(const OPTIONAL<IpaCcmIdResp>& other_value);
IpaCcmIdResp_template& operator=(const IpaCcmIdResp_template& other_value);

IpaCcmRespPart_template& operator[](int index_value);
IpaCcmRespPart_template& operator[](const INTEGER& index_value);
const IpaCcmRespPart_template& operator[](int index_value) const;
const IpaCcmRespPart_template& operator[](const INTEGER& index_value) const;

void set_size(int new_size);
int n_elem() const;
int size_of(boolean is_size) const;
inline int size_of() const { return size_of(TRUE); }
inline int lengthof() const { return size_of(FALSE); }
boolean match(const IpaCcmIdResp& other_value, boolean legacy = FALSE) const;
inline boolean is_bound() const 
  {return template_selection != UNINITIALIZED_TEMPLATE; }
boolean is_value() const;
IpaCcmIdResp valueof() const;
IpaCcmIdResp substr(int index, int returncount) const;

IpaCcmIdResp replace(int index, int len, const IpaCcmIdResp_template& repl) const;

IpaCcmIdResp replace(int index, int len, const IpaCcmIdResp& repl) const;

void set_type(template_sel template_type, unsigned int list_length);
IpaCcmIdResp_template& list_item(unsigned int list_index);
IpaCcmRespPart_template& set_item(unsigned int set_index);
void log() const;
void log_match(const IpaCcmIdResp& match_value, boolean legacy = FALSE) const;
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
  void set_implicit_omit();
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean get_istemplate_kind(const char* type) const;
};

class IpaCcmUnion : public Base_Type {
public:
enum union_selection_type { UNBOUND_VALUE = 0, ALT_get = 1, ALT_resp = 2, ALT_other = 3 };
private:
union_selection_type union_selection;
union {
IpaCcmIdGet *field_get;
IpaCcmIdResp *field_resp;
OCTETSTRING *field_other;
};
void copy_value(const IpaCcmUnion& other_value);

public:
IpaCcmUnion();
IpaCcmUnion(const IpaCcmUnion& other_value);
~IpaCcmUnion();
IpaCcmUnion& operator=(const IpaCcmUnion& other_value);
boolean operator==(const IpaCcmUnion& other_value) const;
inline boolean operator!=(const IpaCcmUnion& other_value) const { return !(*this == other_value); }
IpaCcmIdGet& get();
const IpaCcmIdGet& get() const;
IpaCcmIdResp& resp();
const IpaCcmIdResp& resp() const;
OCTETSTRING& other();
const OCTETSTRING& other() const;
inline union_selection_type get_selection() const { return union_selection; }
boolean ischosen(union_selection_type checked_selection) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
inline boolean is_present() const { return is_bound(); }
void log() const;
void set_param(Module_Param& param);
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class IpaCcmUnion_template : public Base_Template {
union {
struct {
IpaCcmUnion::union_selection_type union_selection;
union {
IpaCcmIdGet_template *field_get;
IpaCcmIdResp_template *field_resp;
OCTETSTRING_template *field_other;
};
} single_value;
struct {
unsigned int n_values;
IpaCcmUnion_template *list_value;
} value_list;
struct {
IpaCcmUnion_template* precondition;
IpaCcmUnion_template* implied_template;
} implication_;
dynmatch_struct<IpaCcmUnion>* dyn_match;
};
void copy_value(const IpaCcmUnion& other_value);

void copy_template(const IpaCcmUnion_template& other_value);

public:
IpaCcmUnion_template();
IpaCcmUnion_template(template_sel other_value);
IpaCcmUnion_template(const IpaCcmUnion& other_value);
IpaCcmUnion_template(const OPTIONAL<IpaCcmUnion>& other_value);
IpaCcmUnion_template(IpaCcmUnion_template* p_precondition, IpaCcmUnion_template* p_implied_template);
IpaCcmUnion_template(Dynamic_Match_Interface<IpaCcmUnion>* p_dyn_match);
IpaCcmUnion_template(const IpaCcmUnion_template& other_value);
~IpaCcmUnion_template();
void clean_up();
IpaCcmUnion_template& operator=(template_sel other_value);
IpaCcmUnion_template& operator=(const IpaCcmUnion& other_value);
IpaCcmUnion_template& operator=(const OPTIONAL<IpaCcmUnion>& other_value);
IpaCcmUnion_template& operator=(const IpaCcmUnion_template& other_value);
boolean match(const IpaCcmUnion& other_value, boolean legacy = FALSE) const;
boolean is_value() const;IpaCcmUnion valueof() const;
IpaCcmUnion_template& list_item(unsigned int list_index) const;
void set_type(template_sel template_type, unsigned int list_length);
IpaCcmIdGet_template& get();
const IpaCcmIdGet_template& get() const;
IpaCcmIdResp_template& resp();
const IpaCcmIdResp_template& resp() const;
OCTETSTRING_template& other();
const OCTETSTRING_template& other() const;
boolean ischosen(IpaCcmUnion::union_selection_type checked_selection) const;
void log() const;
void log_match(const IpaCcmUnion& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
};

class PDU__IPA__CCM : public Base_Type {
  IpaCcmMsgtype field_msg__type;
  OPTIONAL< IpaCcmUnion > field_u;
public:
  PDU__IPA__CCM();
  PDU__IPA__CCM(const IpaCcmMsgtype& par_msg__type,
    const OPTIONAL< IpaCcmUnion >& par_u);
  PDU__IPA__CCM(const PDU__IPA__CCM& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  PDU__IPA__CCM& operator=(const PDU__IPA__CCM& other_value);
  boolean operator==(const PDU__IPA__CCM& other_value) const;
  inline boolean operator!=(const PDU__IPA__CCM& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline IpaCcmMsgtype& msg__type()
    {return field_msg__type;}
  inline const IpaCcmMsgtype& msg__type() const
    {return field_msg__type;}
  inline OPTIONAL< IpaCcmUnion >& u()
    {return field_u;}
  inline const OPTIONAL< IpaCcmUnion >& u() const
    {return field_u;}
  int size_of() const;
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int RAW_encode(const TTCN_Typedescriptor_t&, RAW_enc_tree&) const;
int RAW_decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, raw_order_t, boolean no_err=FALSE,int sel_field=-1, boolean first_call=TRUE, const RAW_Force_Omit* force_omit = NULL);
};

class PDU__IPA__CCM_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
PDU__IPA__CCM_template *list_value;
} value_list;
struct {
PDU__IPA__CCM_template* precondition;
PDU__IPA__CCM_template* implied_template;
} implication_;
dynmatch_struct<PDU__IPA__CCM>* dyn_match;
};

void set_specific();
void copy_value(const PDU__IPA__CCM& other_value);
void copy_template(const PDU__IPA__CCM_template& other_value);

public:
PDU__IPA__CCM_template();
PDU__IPA__CCM_template(template_sel other_value);
PDU__IPA__CCM_template(const PDU__IPA__CCM& other_value);
PDU__IPA__CCM_template(const OPTIONAL<PDU__IPA__CCM>& other_value);
PDU__IPA__CCM_template(PDU__IPA__CCM_template* p_precondition, PDU__IPA__CCM_template* p_implied_template);
PDU__IPA__CCM_template(Dynamic_Match_Interface<PDU__IPA__CCM>* p_dyn_match);
PDU__IPA__CCM_template(const PDU__IPA__CCM_template& other_value);
~PDU__IPA__CCM_template();
PDU__IPA__CCM_template& operator=(template_sel other_value);
PDU__IPA__CCM_template& operator=(const PDU__IPA__CCM& other_value);
PDU__IPA__CCM_template& operator=(const OPTIONAL<PDU__IPA__CCM>& other_value);
PDU__IPA__CCM_template& operator=(const PDU__IPA__CCM_template& other_value);
boolean match(const PDU__IPA__CCM& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
PDU__IPA__CCM valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
PDU__IPA__CCM_template& list_item(unsigned int list_index) const;
IpaCcmMsgtype_template& msg__type();
const IpaCcmMsgtype_template& msg__type() const;
IpaCcmUnion_template& u();
const IpaCcmUnion_template& u() const;
int size_of() const;
void log() const;
void log_match(const PDU__IPA__CCM& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};

class IpaUnitId : public Base_Type {
  INTEGER field_site__id;
  INTEGER field_bts__id;
  INTEGER field_trx__id;
public:
  IpaUnitId();
  IpaUnitId(const INTEGER& par_site__id,
    const INTEGER& par_bts__id,
    const INTEGER& par_trx__id);
  IpaUnitId(const IpaUnitId& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  IpaUnitId& operator=(const IpaUnitId& other_value);
  boolean operator==(const IpaUnitId& other_value) const;
  inline boolean operator!=(const IpaUnitId& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

inline boolean is_present() const { return is_bound(); }
  boolean is_value() const;

  inline INTEGER& site__id()
    {return field_site__id;}
  inline const INTEGER& site__id() const
    {return field_site__id;}
  inline INTEGER& bts__id()
    {return field_bts__id;}
  inline const INTEGER& bts__id() const
    {return field_bts__id;}
  inline INTEGER& trx__id()
    {return field_trx__id;}
  inline const INTEGER& trx__id() const
    {return field_trx__id;}
  inline int size_of() const
    {return 3;}
  void log() const;
  void set_implicit_omit();
  void set_param(Module_Param& param);
  void encode_text(Text_Buf& text_buf) const;
  void decode_text(Text_Buf& text_buf);
void encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...) const;
void decode(const TTCN_Typedescriptor_t&, TTCN_Buffer&, int, ...);
int TEXT_encode(const TTCN_Typedescriptor_t&, TTCN_Buffer&) const;
int TEXT_decode(const TTCN_Typedescriptor_t&,TTCN_Buffer&, Limit_Token_List&, boolean no_err=FALSE,boolean first_call=TRUE);
};

class IpaUnitId_template : public Base_Template {
struct single_value_struct;
union {
single_value_struct *single_value;
struct {
unsigned int n_values;
IpaUnitId_template *list_value;
} value_list;
struct {
IpaUnitId_template* precondition;
IpaUnitId_template* implied_template;
} implication_;
dynmatch_struct<IpaUnitId>* dyn_match;
};

void set_specific();
void copy_value(const IpaUnitId& other_value);
void copy_template(const IpaUnitId_template& other_value);

public:
IpaUnitId_template();
IpaUnitId_template(template_sel other_value);
IpaUnitId_template(const IpaUnitId& other_value);
IpaUnitId_template(const OPTIONAL<IpaUnitId>& other_value);
IpaUnitId_template(IpaUnitId_template* p_precondition, IpaUnitId_template* p_implied_template);
IpaUnitId_template(Dynamic_Match_Interface<IpaUnitId>* p_dyn_match);
IpaUnitId_template(const IpaUnitId_template& other_value);
~IpaUnitId_template();
IpaUnitId_template& operator=(template_sel other_value);
IpaUnitId_template& operator=(const IpaUnitId& other_value);
IpaUnitId_template& operator=(const OPTIONAL<IpaUnitId>& other_value);
IpaUnitId_template& operator=(const IpaUnitId_template& other_value);
boolean match(const IpaUnitId& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
IpaUnitId valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
IpaUnitId_template& list_item(unsigned int list_index) const;
INTEGER_template& site__id();
const INTEGER_template& site__id() const;
INTEGER_template& bts__id();
const INTEGER_template& bts__id() const;
INTEGER_template& trx__id();
const INTEGER_template& trx__id() const;
int size_of() const;
void log() const;
void log_match(const IpaUnitId& match_value, boolean legacy = FALSE) const;
  void set_implicit_omit();
void encode_text(Text_Buf& text_buf) const;
void decode_text(Text_Buf& text_buf);
void set_param(Module_Param& param);
void check_restriction(template_res t_res, const char* t_name=NULL, boolean legacy = FALSE) const;
boolean is_present(boolean legacy = FALSE) const;
boolean match_omit(boolean legacy = FALSE) const;
};


/* Function prototypes */

extern void IpaStreamId_encoder(const IpaStreamId& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IpaStreamId_decoder(OCTETSTRING& input_stream, IpaStreamId& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void IpaExtStreamId_encoder(const IpaExtStreamId& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IpaExtStreamId_decoder(OCTETSTRING& input_stream, IpaExtStreamId& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern OCTETSTRING enc__PDU__IPA(const PDU__IPA& pdu);
extern PDU__IPA dec__PDU__IPA(const OCTETSTRING& stream);
extern void PDU__IPA_lengthInd_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PDU__IPA_lengthInd_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void PDU__IPA_payloadData_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PDU__IPA_payloadData_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void PDU__IPA_streamIdExt_encoder(const IpaExtStreamId& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PDU__IPA_streamIdExt_decoder(OCTETSTRING& input_stream, IpaExtStreamId& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void PDU__IPA_encoder(const PDU__IPA& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PDU__IPA_decoder(OCTETSTRING& input_stream, PDU__IPA& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern PDU__IPA_template ts__PDU__IPA(const IpaStreamId& id, const OCTETSTRING_template& payload);
extern void IpaCcmMsgtype_encoder(const IpaCcmMsgtype& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IpaCcmMsgtype_decoder(OCTETSTRING& input_stream, IpaCcmMsgtype& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void IpaCcmIdTag_encoder(const IpaCcmIdTag& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IpaCcmIdTag_decoder(OCTETSTRING& input_stream, IpaCcmIdTag& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void IpaCcmGetPart_len_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IpaCcmGetPart_len_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void IpaCcmGetPart_encoder(const IpaCcmGetPart& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IpaCcmGetPart_decoder(OCTETSTRING& input_stream, IpaCcmGetPart& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern boolean operator==(null_type null_value, const IpaCcmIdGet& other_value);
inline boolean operator!=(null_type null_value, const IpaCcmIdGet& other_value) { return !(null_value == other_value); }
extern void IpaCcmIdGet_encoder(const IpaCcmIdGet& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IpaCcmIdGet_decoder(OCTETSTRING& input_stream, IpaCcmIdGet& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void IpaCcmRespPart_len_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IpaCcmRespPart_len_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void IpaCcmRespPart_data_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IpaCcmRespPart_data_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void IpaCcmRespPart_encoder(const IpaCcmRespPart& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IpaCcmRespPart_decoder(OCTETSTRING& input_stream, IpaCcmRespPart& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern boolean operator==(null_type null_value, const IpaCcmIdResp& other_value);
inline boolean operator!=(null_type null_value, const IpaCcmIdResp& other_value) { return !(null_value == other_value); }
extern void IpaCcmIdResp_encoder(const IpaCcmIdResp& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IpaCcmIdResp_decoder(OCTETSTRING& input_stream, IpaCcmIdResp& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void IpaCcmUnion_other_encoder(const OCTETSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IpaCcmUnion_other_decoder(OCTETSTRING& input_stream, OCTETSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void IpaCcmUnion_encoder(const IpaCcmUnion& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IpaCcmUnion_decoder(OCTETSTRING& input_stream, IpaCcmUnion& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void PDU__IPA__CCM_u_encoder(const IpaCcmUnion& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PDU__IPA__CCM_u_decoder(OCTETSTRING& input_stream, IpaCcmUnion& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void PDU__IPA__CCM_encoder(const PDU__IPA__CCM& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER PDU__IPA__CCM_decoder(OCTETSTRING& input_stream, PDU__IPA__CCM& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern OCTETSTRING enc__PDU__IPA__CCM(const PDU__IPA__CCM& pdu);
extern PDU__IPA__CCM dec__PDU__IPA__CCM(const OCTETSTRING& stream);
extern void IpaUnitId_site__id_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IpaUnitId_site__id_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void IpaUnitId_bts__id_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IpaUnitId_bts__id_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void IpaUnitId_trx__id_encoder(const INTEGER& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IpaUnitId_trx__id_decoder(OCTETSTRING& input_stream, INTEGER& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void IpaUnitId_encoder(const IpaUnitId& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER IpaUnitId_decoder(OCTETSTRING& input_stream, IpaUnitId& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern CHARSTRING enc__IpaUnitId(const IpaUnitId& unit__id);
extern IpaUnitId dec__IpaUnitId(const CHARSTRING& stream);
extern IpaUnitId_template ts__IpaUnitId(const INTEGER& site__id, const INTEGER& bts__id, const INTEGER& trx__id);
extern IpaUnitId_template tr__IpaUnitId(const INTEGER_template& site__id, const INTEGER_template& bts__id, const INTEGER_template& trx__id);
extern INTEGER f__ipa__id__resp__find__ie(const IpaCcmIdResp& resp, const IpaCcmIdTag& tag);
extern void pre_init_module();
extern void post_init_module();

/* Global variable declarations */

extern const TTCN_RAWdescriptor_t IpaStreamId_raw_;
extern const TTCN_Typedescriptor_t IpaStreamId_descr_;
extern UNIVERSAL_CHARSTRING IpaStreamId_default_coding;
extern const TTCN_RAWdescriptor_t IpaExtStreamId_raw_;
extern const TTCN_Typedescriptor_t IpaExtStreamId_descr_;
extern UNIVERSAL_CHARSTRING IpaExtStreamId_default_coding;
extern const TTCN_RAWdescriptor_t PDU__IPA_lengthInd_raw_;
extern const XERdescriptor_t PDU__IPA_lengthInd_xer_;
extern const TTCN_OERdescriptor_t PDU__IPA_lengthInd_oer_;
extern const TTCN_Typedescriptor_t PDU__IPA_lengthInd_descr_;
extern UNIVERSAL_CHARSTRING PDU__IPA_lengthInd_default_coding;
extern UNIVERSAL_CHARSTRING PDU__IPA_streamId_default_coding;
extern const XERdescriptor_t PDU__IPA_payloadData_xer_;
extern const TTCN_OERdescriptor_t PDU__IPA_payloadData_oer_;
extern const TTCN_Typedescriptor_t PDU__IPA_payloadData_descr_;
extern UNIVERSAL_CHARSTRING PDU__IPA_payloadData_default_coding;
extern const TTCN_RAWdescriptor_t PDU__IPA_raw_;
extern const TTCN_Typedescriptor_t PDU__IPA_descr_;
extern const TTCN_RAWdescriptor_t PDU__IPA_streamIdExt_raw_;
extern const TTCN_Typedescriptor_t PDU__IPA_streamIdExt_descr_;
extern UNIVERSAL_CHARSTRING PDU__IPA_streamIdExt_default_coding;
extern UNIVERSAL_CHARSTRING PDU__IPA_default_coding;
extern const TTCN_RAWdescriptor_t IpaCcmMsgtype_raw_;
extern const TTCN_Typedescriptor_t IpaCcmMsgtype_descr_;
extern UNIVERSAL_CHARSTRING IpaCcmMsgtype_default_coding;
extern const TTCN_RAWdescriptor_t IpaCcmIdTag_raw_;
extern const TTCN_Typedescriptor_t IpaCcmIdTag_descr_;
extern UNIVERSAL_CHARSTRING IpaCcmIdTag_default_coding;
extern const TTCN_RAWdescriptor_t IpaCcmGetPart_len_raw_;
extern const XERdescriptor_t IpaCcmGetPart_len_xer_;
extern const TTCN_OERdescriptor_t IpaCcmGetPart_len_oer_;
extern const TTCN_Typedescriptor_t IpaCcmGetPart_len_descr_;
extern UNIVERSAL_CHARSTRING IpaCcmGetPart_len_default_coding;
extern UNIVERSAL_CHARSTRING IpaCcmGetPart_tag_default_coding;
extern const TTCN_RAWdescriptor_t IpaCcmGetPart_raw_;
extern const TTCN_Typedescriptor_t IpaCcmGetPart_descr_;
extern UNIVERSAL_CHARSTRING IpaCcmGetPart_default_coding;
extern const TTCN_RAWdescriptor_t IpaCcmIdGet_raw_;
extern const TTCN_Typedescriptor_t IpaCcmIdGet_descr_;
extern UNIVERSAL_CHARSTRING IpaCcmIdGet_0_default_coding;
extern UNIVERSAL_CHARSTRING IpaCcmIdGet_default_coding;
extern const TTCN_RAWdescriptor_t IpaCcmRespPart_len_raw_;
extern const XERdescriptor_t IpaCcmRespPart_len_xer_;
extern const TTCN_OERdescriptor_t IpaCcmRespPart_len_oer_;
extern const TTCN_Typedescriptor_t IpaCcmRespPart_len_descr_;
extern UNIVERSAL_CHARSTRING IpaCcmRespPart_len_default_coding;
extern UNIVERSAL_CHARSTRING IpaCcmRespPart_tag_default_coding;
extern const XERdescriptor_t IpaCcmRespPart_data_xer_;
extern const TTCN_OERdescriptor_t IpaCcmRespPart_data_oer_;
extern const TTCN_Typedescriptor_t IpaCcmRespPart_data_descr_;
extern UNIVERSAL_CHARSTRING IpaCcmRespPart_data_default_coding;
extern const TTCN_RAWdescriptor_t IpaCcmRespPart_raw_;
extern const TTCN_Typedescriptor_t IpaCcmRespPart_descr_;
extern UNIVERSAL_CHARSTRING IpaCcmRespPart_default_coding;
extern const TTCN_RAWdescriptor_t IpaCcmIdResp_raw_;
extern const TTCN_Typedescriptor_t IpaCcmIdResp_descr_;
extern UNIVERSAL_CHARSTRING IpaCcmIdResp_0_default_coding;
extern UNIVERSAL_CHARSTRING IpaCcmIdResp_default_coding;
extern const TTCN_RAWdescriptor_t IpaCcmUnion_raw_;
extern const TTCN_Typedescriptor_t IpaCcmUnion_descr_;
extern UNIVERSAL_CHARSTRING IpaCcmUnion_get_default_coding;
extern UNIVERSAL_CHARSTRING IpaCcmUnion_resp_default_coding;
extern const XERdescriptor_t IpaCcmUnion_other_xer_;
extern const TTCN_OERdescriptor_t IpaCcmUnion_other_oer_;
extern const TTCN_Typedescriptor_t IpaCcmUnion_other_descr_;
extern UNIVERSAL_CHARSTRING IpaCcmUnion_other_default_coding;
extern UNIVERSAL_CHARSTRING IpaCcmUnion_default_coding;
extern UNIVERSAL_CHARSTRING PDU__IPA__CCM_msg__type_default_coding;
extern const TTCN_RAWdescriptor_t PDU__IPA__CCM_raw_;
extern const TTCN_Typedescriptor_t PDU__IPA__CCM_descr_;
extern const TTCN_RAWdescriptor_t PDU__IPA__CCM_u_raw_;
extern const TTCN_Typedescriptor_t PDU__IPA__CCM_u_descr_;
extern UNIVERSAL_CHARSTRING PDU__IPA__CCM_u_default_coding;
extern UNIVERSAL_CHARSTRING PDU__IPA__CCM_default_coding;
extern const XERdescriptor_t IpaUnitId_site__id_xer_;
extern const TTCN_Typedescriptor_t IpaUnitId_site__id_descr_;
extern UNIVERSAL_CHARSTRING IpaUnitId_site__id_default_coding;
extern const XERdescriptor_t IpaUnitId_bts__id_xer_;
extern const TTCN_Typedescriptor_t IpaUnitId_bts__id_descr_;
extern UNIVERSAL_CHARSTRING IpaUnitId_bts__id_default_coding;
extern const TTCN_TEXTdescriptor_t IpaUnitId_trx__id_text_;
extern const XERdescriptor_t IpaUnitId_trx__id_xer_;
extern const TTCN_Typedescriptor_t IpaUnitId_trx__id_descr_;
extern UNIVERSAL_CHARSTRING IpaUnitId_trx__id_default_coding;
extern const TTCN_TEXTdescriptor_t IpaUnitId_text_;
extern const TTCN_Typedescriptor_t IpaUnitId_descr_;
extern UNIVERSAL_CHARSTRING IpaUnitId_default_coding;
extern const INTEGER& ts__IpaUnitId_site__id_defval;
extern INTEGER const_ts__IpaUnitId_site__id_defval;
extern const INTEGER& ts__IpaUnitId_bts__id_defval;
extern INTEGER const_ts__IpaUnitId_bts__id_defval;
extern const INTEGER& ts__IpaUnitId_trx__id_defval;
extern INTEGER const_ts__IpaUnitId_trx__id_defval;
extern const INTEGER_template& tr__IpaUnitId_site__id_defval;
extern INTEGER_template template_tr__IpaUnitId_site__id_defval;
extern const INTEGER_template& tr__IpaUnitId_bts__id_defval;
extern INTEGER_template template_tr__IpaUnitId_bts__id_defval;
extern const INTEGER_template& tr__IpaUnitId_trx__id_defval;
extern INTEGER_template template_tr__IpaUnitId_trx__id_defval;
extern const CHARSTRING cs_0;
extern const unsigned char module_checksum[];
extern TTCN_Module module_object;
extern const RuntimeVersionChecker ver_checker;

} /* end of namespace */

#endif
