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

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

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

#ifndef RSRES_HH
#define RSRES_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 "RSPRO.hh"

#if TTCN3_VERSION != 90000
#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 RSRES_HH
#endif

namespace RSRES {

/* Forward declarations of classes */

class ConnectionState;
class ConnectionState_template;
class JsBank;
class JsBank_template;
class JsBanks;
class JsBanks_template;
class JsClient;
class JsClient_template;
class JsClients;
class JsClients_template;
class SlotmapState;
class SlotmapState_template;
class JsSlotmap;
class JsSlotmap_template;
class JsSlotmaps;
class JsSlotmaps_template;
class JsRoot;
class JsRoot_template;

} /* end of namespace */

#ifndef RSRES_HH
#define RSRES_HH

namespace RSRES {

/* Class definitions */

class ConnectionState : public Base_Type { // enum
friend class ConnectionState_template;
public:
enum enum_type { INIT = 0, ESTABLISHED = 1, CONNECTED__CLIENT = 2, CONNECTED__BANKD = 3, UNKNOWN_VALUE = 4, UNBOUND_VALUE = 5 };
private:
enum_type enum_value;

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

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

boolean operator==(enum_type other_value) const;
boolean operator==(const ConnectionState& other_value) const;
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const ConnectionState& other_value) const { return !(*this == other_value); }
boolean operator<(enum_type other_value) const;
boolean operator<(const ConnectionState& other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const ConnectionState& other_value) const;
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const ConnectionState& other_value) const { return !(*this > other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const ConnectionState& 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);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const ConnectionState& 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 JSON_encode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean) const;
int JSON_decode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean, boolean, int p_chosen_field = CHOSEN_FIELD_UNSET);
};

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

void copy_template(const ConnectionState_template& other_value);

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

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

boolean match(ConnectionState::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const ConnectionState& other_value, boolean legacy = FALSE) const;
ConnectionState::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
ConnectionState_template& list_item(unsigned int list_index);
void log() const;
void log_match(const ConnectionState& 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 JsBank : public Base_Type {
  CHARSTRING field_peer;
  ConnectionState field_state;
  RSPRO::ComponentIdentity field_component__id;
  INTEGER field_bankId;
  INTEGER field_numberOfSlots;
public:
  JsBank();
  JsBank(const CHARSTRING& par_peer,
    const ConnectionState& par_state,
    const RSPRO::ComponentIdentity& par_component__id,
    const INTEGER& par_bankId,
    const INTEGER& par_numberOfSlots);
  JsBank(const JsBank& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  JsBank& operator=(const JsBank& other_value);
  boolean operator==(const JsBank& other_value) const;
  inline boolean operator!=(const JsBank& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline CHARSTRING& peer()
    {return field_peer;}
  inline const CHARSTRING& peer() const
    {return field_peer;}
  inline ConnectionState& state()
    {return field_state;}
  inline const ConnectionState& state() const
    {return field_state;}
  inline RSPRO::ComponentIdentity& component__id()
    {return field_component__id;}
  inline const RSPRO::ComponentIdentity& component__id() const
    {return field_component__id;}
  inline INTEGER& bankId()
    {return field_bankId;}
  inline const INTEGER& bankId() const
    {return field_bankId;}
  inline INTEGER& numberOfSlots()
    {return field_numberOfSlots;}
  inline const INTEGER& numberOfSlots() const
    {return field_numberOfSlots;}
  inline int size_of() const
    {return 5;}
  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 JSON_encode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean) const;
int JSON_decode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean, boolean, int p_chosen_field = CHOSEN_FIELD_UNSET);
};

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

void set_specific();
void copy_value(const JsBank& other_value);
void copy_template(const JsBank_template& other_value);

public:
JsBank_template();
JsBank_template(template_sel other_value);
JsBank_template(const JsBank& other_value);
JsBank_template(const OPTIONAL<JsBank>& other_value);
JsBank_template(JsBank_template* p_precondition, JsBank_template* p_implied_template);
JsBank_template(Dynamic_Match_Interface<JsBank>* p_dyn_match);
JsBank_template(const JsBank_template& other_value);
~JsBank_template();
JsBank_template& operator=(template_sel other_value);
JsBank_template& operator=(const JsBank& other_value);
JsBank_template& operator=(const OPTIONAL<JsBank>& other_value);
JsBank_template& operator=(const JsBank_template& other_value);
boolean match(const JsBank& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
JsBank valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
JsBank_template& list_item(unsigned int list_index) const;
CHARSTRING_template& peer();
const CHARSTRING_template& peer() const;
ConnectionState_template& state();
const ConnectionState_template& state() const;
RSPRO::ComponentIdentity_template& component__id();
const RSPRO::ComponentIdentity_template& component__id() const;
INTEGER_template& bankId();
const INTEGER_template& bankId() const;
INTEGER_template& numberOfSlots();
const INTEGER_template& numberOfSlots() const;
int size_of() const;
void log() const;
void log_match(const JsBank& match_value, boolean legacy = FALSE) const;
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 JsBanks : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
JsBank **value_elements;
} *val_ptr;

static const JsBank UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const JsBanks& other_value);

public:
  typedef JsBank of_type;
JsBanks();
JsBanks(null_type other_value);
JsBanks(const JsBanks& other_value);
~JsBanks();

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

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

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

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

JsBanks operator+(const JsBanks& other_value) const;

JsBanks substr(int index, int returncount) const;

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

JsBanks replace(int index, int len, const JsBanks_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 JSON_encode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean) const;
int JSON_decode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean, boolean, int p_chosen_field = CHOSEN_FIELD_UNSET);
};

class JsBanks_template : public Base_Record_Of_Template {
union {
struct {
int n_elements;
JsBank_template **value_elements;
} single_value;
struct {
unsigned int n_values;
JsBanks_template *list_value;
} value_list;
struct {
JsBanks_template* precondition;
JsBanks_template* implied_template;
} implication_;
dynmatch_struct<JsBanks>* dyn_match;
};
void copy_value(const JsBanks& other_value);
void copy_template(const JsBanks_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);

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

void clean_up();
JsBanks_template& operator=(template_sel other_value);
JsBanks_template& operator=(null_type other_value);
JsBanks_template& operator=(const JsBanks& other_value);
JsBanks_template& operator=(const OPTIONAL<JsBanks>& other_value);
JsBanks_template& operator=(const JsBanks_template& other_value);

JsBank_template& operator[](int index_value);
JsBank_template& operator[](const INTEGER& index_value);
const JsBank_template& operator[](int index_value) const;
const JsBank_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 JsBanks& other_value, boolean legacy = FALSE) const;
inline boolean is_bound() const 
  {return template_selection != UNINITIALIZED_TEMPLATE; }
boolean is_value() const;
JsBanks valueof() const;
JsBanks substr(int index, int returncount) const;

JsBanks replace(int index, int len, const JsBanks_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
JsBanks_template& list_item(unsigned int list_index);
void log() const;
void log_match(const JsBanks& 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;
boolean get_istemplate_kind(const char* type) const;
};

class JsClient : public Base_Type {
  CHARSTRING field_peer;
  ConnectionState field_state;
  RSPRO::ComponentIdentity field_component__id;
public:
  JsClient();
  JsClient(const CHARSTRING& par_peer,
    const ConnectionState& par_state,
    const RSPRO::ComponentIdentity& par_component__id);
  JsClient(const JsClient& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  JsClient& operator=(const JsClient& other_value);
  boolean operator==(const JsClient& other_value) const;
  inline boolean operator!=(const JsClient& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline CHARSTRING& peer()
    {return field_peer;}
  inline const CHARSTRING& peer() const
    {return field_peer;}
  inline ConnectionState& state()
    {return field_state;}
  inline const ConnectionState& state() const
    {return field_state;}
  inline RSPRO::ComponentIdentity& component__id()
    {return field_component__id;}
  inline const RSPRO::ComponentIdentity& component__id() const
    {return field_component__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 JSON_encode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean) const;
int JSON_decode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean, boolean, int p_chosen_field = CHOSEN_FIELD_UNSET);
};

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

void set_specific();
void copy_value(const JsClient& other_value);
void copy_template(const JsClient_template& other_value);

public:
JsClient_template();
JsClient_template(template_sel other_value);
JsClient_template(const JsClient& other_value);
JsClient_template(const OPTIONAL<JsClient>& other_value);
JsClient_template(JsClient_template* p_precondition, JsClient_template* p_implied_template);
JsClient_template(Dynamic_Match_Interface<JsClient>* p_dyn_match);
JsClient_template(const JsClient_template& other_value);
~JsClient_template();
JsClient_template& operator=(template_sel other_value);
JsClient_template& operator=(const JsClient& other_value);
JsClient_template& operator=(const OPTIONAL<JsClient>& other_value);
JsClient_template& operator=(const JsClient_template& other_value);
boolean match(const JsClient& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
JsClient valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
JsClient_template& list_item(unsigned int list_index) const;
CHARSTRING_template& peer();
const CHARSTRING_template& peer() const;
ConnectionState_template& state();
const ConnectionState_template& state() const;
RSPRO::ComponentIdentity_template& component__id();
const RSPRO::ComponentIdentity_template& component__id() const;
int size_of() const;
void log() const;
void log_match(const JsClient& match_value, boolean legacy = FALSE) const;
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 JsClients : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
JsClient **value_elements;
} *val_ptr;

static const JsClient UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const JsClients& other_value);

public:
  typedef JsClient of_type;
JsClients();
JsClients(null_type other_value);
JsClients(const JsClients& other_value);
~JsClients();

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

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

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

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

JsClients operator+(const JsClients& other_value) const;

JsClients substr(int index, int returncount) const;

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

JsClients replace(int index, int len, const JsClients_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 JSON_encode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean) const;
int JSON_decode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean, boolean, int p_chosen_field = CHOSEN_FIELD_UNSET);
};

class JsClients_template : public Base_Record_Of_Template {
union {
struct {
int n_elements;
JsClient_template **value_elements;
} single_value;
struct {
unsigned int n_values;
JsClients_template *list_value;
} value_list;
struct {
JsClients_template* precondition;
JsClients_template* implied_template;
} implication_;
dynmatch_struct<JsClients>* dyn_match;
};
void copy_value(const JsClients& other_value);
void copy_template(const JsClients_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);

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

void clean_up();
JsClients_template& operator=(template_sel other_value);
JsClients_template& operator=(null_type other_value);
JsClients_template& operator=(const JsClients& other_value);
JsClients_template& operator=(const OPTIONAL<JsClients>& other_value);
JsClients_template& operator=(const JsClients_template& other_value);

JsClient_template& operator[](int index_value);
JsClient_template& operator[](const INTEGER& index_value);
const JsClient_template& operator[](int index_value) const;
const JsClient_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 JsClients& other_value, boolean legacy = FALSE) const;
inline boolean is_bound() const 
  {return template_selection != UNINITIALIZED_TEMPLATE; }
boolean is_value() const;
JsClients valueof() const;
JsClients substr(int index, int returncount) const;

JsClients replace(int index, int len, const JsClients_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
JsClients_template& list_item(unsigned int list_index);
void log() const;
void log_match(const JsClients& 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;
boolean get_istemplate_kind(const char* type) const;
};

class SlotmapState : public Base_Type { // enum
friend class SlotmapState_template;
public:
enum enum_type { NEW = 0, UNACKNOWLEDGED = 1, ACTIVE = 2, DELETE__REQ = 3, DELETING = 4, UNKNOWN_VALUE = 5, UNBOUND_VALUE = 6 };
private:
enum_type enum_value;

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

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

boolean operator==(enum_type other_value) const;
boolean operator==(const SlotmapState& other_value) const;
inline boolean operator!=(enum_type other_value) const { return !(*this == other_value); }
inline boolean operator!=(const SlotmapState& other_value) const { return !(*this == other_value); }
boolean operator<(enum_type other_value) const;
boolean operator<(const SlotmapState& other_value) const;
boolean operator>(enum_type other_value) const;
boolean operator>(const SlotmapState& other_value) const;
inline boolean operator<=(enum_type other_value) const { return !(*this > other_value); }
inline boolean operator<=(const SlotmapState& other_value) const { return !(*this > other_value); }
inline boolean operator>=(enum_type other_value) const { return !(*this < other_value); }
inline boolean operator>=(const SlotmapState& 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);
static boolean is_valid_enum(int int_par);

static int enum2int(enum_type enum_par);
static int enum2int(const SlotmapState& 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 JSON_encode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean) const;
int JSON_decode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean, boolean, int p_chosen_field = CHOSEN_FIELD_UNSET);
};

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

void copy_template(const SlotmapState_template& other_value);

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

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

boolean match(SlotmapState::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const SlotmapState& other_value, boolean legacy = FALSE) const;
SlotmapState::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
SlotmapState_template& list_item(unsigned int list_index);
void log() const;
void log_match(const SlotmapState& 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 JsSlotmap : public Base_Type {
  RSPRO::BankSlot field_bank;
  RSPRO::ClientSlot field_client;
  OPTIONAL< SlotmapState > field_state;
public:
  JsSlotmap();
  JsSlotmap(const RSPRO::BankSlot& par_bank,
    const RSPRO::ClientSlot& par_client,
    const OPTIONAL< SlotmapState >& par_state);
  JsSlotmap(const JsSlotmap& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  JsSlotmap& operator=(const JsSlotmap& other_value);
  boolean operator==(const JsSlotmap& other_value) const;
  inline boolean operator!=(const JsSlotmap& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline RSPRO::BankSlot& bank()
    {return field_bank;}
  inline const RSPRO::BankSlot& bank() const
    {return field_bank;}
  inline RSPRO::ClientSlot& client()
    {return field_client;}
  inline const RSPRO::ClientSlot& client() const
    {return field_client;}
  inline OPTIONAL< SlotmapState >& state()
    {return field_state;}
  inline const OPTIONAL< SlotmapState >& state() const
    {return field_state;}
  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 JSON_encode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean) const;
int JSON_decode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean, boolean, int p_chosen_field = CHOSEN_FIELD_UNSET);
};

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

void set_specific();
void copy_value(const JsSlotmap& other_value);
void copy_template(const JsSlotmap_template& other_value);

public:
JsSlotmap_template();
JsSlotmap_template(template_sel other_value);
JsSlotmap_template(const JsSlotmap& other_value);
JsSlotmap_template(const OPTIONAL<JsSlotmap>& other_value);
JsSlotmap_template(JsSlotmap_template* p_precondition, JsSlotmap_template* p_implied_template);
JsSlotmap_template(Dynamic_Match_Interface<JsSlotmap>* p_dyn_match);
JsSlotmap_template(const JsSlotmap_template& other_value);
~JsSlotmap_template();
JsSlotmap_template& operator=(template_sel other_value);
JsSlotmap_template& operator=(const JsSlotmap& other_value);
JsSlotmap_template& operator=(const OPTIONAL<JsSlotmap>& other_value);
JsSlotmap_template& operator=(const JsSlotmap_template& other_value);
boolean match(const JsSlotmap& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
JsSlotmap valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
JsSlotmap_template& list_item(unsigned int list_index) const;
RSPRO::BankSlot_template& bank();
const RSPRO::BankSlot_template& bank() const;
RSPRO::ClientSlot_template& client();
const RSPRO::ClientSlot_template& client() const;
SlotmapState_template& state();
const SlotmapState_template& state() const;
int size_of() const;
void log() const;
void log_match(const JsSlotmap& match_value, boolean legacy = FALSE) const;
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 JsSlotmaps : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
JsSlotmap **value_elements;
} *val_ptr;

static const JsSlotmap UNBOUND_ELEM;
private:
friend boolean operator==(null_type null_value, const JsSlotmaps& other_value);

public:
  typedef JsSlotmap of_type;
JsSlotmaps();
JsSlotmaps(null_type other_value);
JsSlotmaps(const JsSlotmaps& other_value);
~JsSlotmaps();

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

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

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

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

JsSlotmaps operator+(const JsSlotmaps& other_value) const;

JsSlotmaps substr(int index, int returncount) const;

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

JsSlotmaps replace(int index, int len, const JsSlotmaps_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 JSON_encode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean) const;
int JSON_decode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean, boolean, int p_chosen_field = CHOSEN_FIELD_UNSET);
};

class JsSlotmaps_template : public Base_Record_Of_Template {
union {
struct {
int n_elements;
JsSlotmap_template **value_elements;
} single_value;
struct {
unsigned int n_values;
JsSlotmaps_template *list_value;
} value_list;
struct {
JsSlotmaps_template* precondition;
JsSlotmaps_template* implied_template;
} implication_;
dynmatch_struct<JsSlotmaps>* dyn_match;
};
void copy_value(const JsSlotmaps& other_value);
void copy_template(const JsSlotmaps_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);

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

void clean_up();
JsSlotmaps_template& operator=(template_sel other_value);
JsSlotmaps_template& operator=(null_type other_value);
JsSlotmaps_template& operator=(const JsSlotmaps& other_value);
JsSlotmaps_template& operator=(const OPTIONAL<JsSlotmaps>& other_value);
JsSlotmaps_template& operator=(const JsSlotmaps_template& other_value);

JsSlotmap_template& operator[](int index_value);
JsSlotmap_template& operator[](const INTEGER& index_value);
const JsSlotmap_template& operator[](int index_value) const;
const JsSlotmap_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 JsSlotmaps& other_value, boolean legacy = FALSE) const;
inline boolean is_bound() const 
  {return template_selection != UNINITIALIZED_TEMPLATE; }
boolean is_value() const;
JsSlotmaps valueof() const;
JsSlotmaps substr(int index, int returncount) const;

JsSlotmaps replace(int index, int len, const JsSlotmaps_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
JsSlotmaps_template& list_item(unsigned int list_index);
void log() const;
void log_match(const JsSlotmaps& 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;
boolean get_istemplate_kind(const char* type) const;
};

class JsRoot : public Base_Type {
  OPTIONAL< JsClients > field_clients;
  OPTIONAL< JsBanks > field_banks;
  OPTIONAL< JsSlotmaps > field_slotmaps;
public:
  JsRoot();
  JsRoot(const OPTIONAL< JsClients >& par_clients,
    const OPTIONAL< JsBanks >& par_banks,
    const OPTIONAL< JsSlotmaps >& par_slotmaps);
  JsRoot(const JsRoot& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  JsRoot& operator=(const JsRoot& other_value);
  boolean operator==(const JsRoot& other_value) const;
  inline boolean operator!=(const JsRoot& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline OPTIONAL< JsClients >& clients()
    {return field_clients;}
  inline const OPTIONAL< JsClients >& clients() const
    {return field_clients;}
  inline OPTIONAL< JsBanks >& banks()
    {return field_banks;}
  inline const OPTIONAL< JsBanks >& banks() const
    {return field_banks;}
  inline OPTIONAL< JsSlotmaps >& slotmaps()
    {return field_slotmaps;}
  inline const OPTIONAL< JsSlotmaps >& slotmaps() const
    {return field_slotmaps;}
  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 JSON_encode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean) const;
int JSON_decode(const TTCN_Typedescriptor_t&, JSON_Tokenizer&, boolean, boolean, int p_chosen_field = CHOSEN_FIELD_UNSET);
};

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

void set_specific();
void copy_value(const JsRoot& other_value);
void copy_template(const JsRoot_template& other_value);

public:
JsRoot_template();
JsRoot_template(template_sel other_value);
JsRoot_template(const JsRoot& other_value);
JsRoot_template(const OPTIONAL<JsRoot>& other_value);
JsRoot_template(JsRoot_template* p_precondition, JsRoot_template* p_implied_template);
JsRoot_template(Dynamic_Match_Interface<JsRoot>* p_dyn_match);
JsRoot_template(const JsRoot_template& other_value);
~JsRoot_template();
JsRoot_template& operator=(template_sel other_value);
JsRoot_template& operator=(const JsRoot& other_value);
JsRoot_template& operator=(const OPTIONAL<JsRoot>& other_value);
JsRoot_template& operator=(const JsRoot_template& other_value);
boolean match(const JsRoot& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
JsRoot valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
JsRoot_template& list_item(unsigned int list_index) const;
JsClients_template& clients();
const JsClients_template& clients() const;
JsBanks_template& banks();
const JsBanks_template& banks() const;
JsSlotmaps_template& slotmaps();
const JsSlotmaps_template& slotmaps() const;
int size_of() const;
void log() const;
void log_match(const JsRoot& match_value, boolean legacy = FALSE) const;
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 ConnectionState_encoder(const ConnectionState& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER ConnectionState_decoder(OCTETSTRING& input_stream, ConnectionState& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void JsBank_peer_encoder(const CHARSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER JsBank_peer_decoder(OCTETSTRING& input_stream, CHARSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void JsBank_encoder(const JsBank& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER JsBank_decoder(OCTETSTRING& input_stream, JsBank& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern boolean operator==(null_type null_value, const JsBanks& other_value);
inline boolean operator!=(null_type null_value, const JsBanks& other_value) { return !(null_value == other_value); }
extern void JsBanks_encoder(const JsBanks& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER JsBanks_decoder(OCTETSTRING& input_stream, JsBanks& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern JsBank_template tr__JsBank(const ConnectionState_template& state, const RSPRO::ComponentIdentity_template& comp__id, const INTEGER_template& bank__id, const INTEGER_template& num__of__slots);
extern void JsClient_peer_encoder(const CHARSTRING& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER JsClient_peer_decoder(OCTETSTRING& input_stream, CHARSTRING& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void JsClient_encoder(const JsClient& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER JsClient_decoder(OCTETSTRING& input_stream, JsClient& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern boolean operator==(null_type null_value, const JsClients& other_value);
inline boolean operator!=(null_type null_value, const JsClients& other_value) { return !(null_value == other_value); }
extern void JsClients_encoder(const JsClients& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER JsClients_decoder(OCTETSTRING& input_stream, JsClients& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern JsClient_template tr__JsClient(const ConnectionState_template& state, const RSPRO::ComponentIdentity_template& comp__id);
extern void SlotmapState_encoder(const SlotmapState& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER SlotmapState_decoder(OCTETSTRING& input_stream, SlotmapState& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern void JsSlotmap_encoder(const JsSlotmap& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER JsSlotmap_decoder(OCTETSTRING& input_stream, JsSlotmap& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern boolean operator==(null_type null_value, const JsSlotmaps& other_value);
inline boolean operator!=(null_type null_value, const JsSlotmaps& other_value) { return !(null_value == other_value); }
extern void JsSlotmaps_encoder(const JsSlotmaps& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER JsSlotmaps_decoder(OCTETSTRING& input_stream, JsSlotmaps& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern JsSlotmap_template ts__JsSlotmap(const RSPRO::BankSlot_template& bslot, const RSPRO::ClientSlot_template& cslot, const SlotmapState_template& state);
extern JsSlotmap_template tr__JsSlotmap(const RSPRO::BankSlot_template& bslot, const RSPRO::ClientSlot_template& cslot, const SlotmapState_template& state);
extern void JsRoot_encoder(const JsRoot& input_value, OCTETSTRING& output_stream, const UNIVERSAL_CHARSTRING& coding_name);
extern INTEGER JsRoot_decoder(OCTETSTRING& input_stream, JsRoot& output_value, const UNIVERSAL_CHARSTRING& coding_name);
extern OCTETSTRING f__enc__JsRoot(const JsRoot& inp);
extern JsRoot f__dec__JsRoot(const OCTETSTRING& inp);
extern OCTETSTRING f__enc__JsSlotmap(const JsSlotmap& inp);
extern JsSlotmap f__dec__JsSlotmap(const OCTETSTRING& inp);
extern void pre_init_module();
extern void post_init_module();

/* Global variable declarations */

extern const TTCN_JSONdescriptor_t ConnectionState_json_;
extern const TTCN_Typedescriptor_t ConnectionState_descr_;
extern UNIVERSAL_CHARSTRING ConnectionState_default_coding;
extern const XERdescriptor_t JsBank_peer_xer_;
extern const TTCN_Typedescriptor_t JsBank_peer_descr_;
extern UNIVERSAL_CHARSTRING JsBank_peer_default_coding;
extern const TTCN_Typedescriptor_t JsBank_state_descr_;
extern UNIVERSAL_CHARSTRING JsBank_state_default_coding;
extern const TTCN_OERdescriptor_t JsBank_component__id_oer_;
extern const ASN_PERdescriptor_t JsBank_component__id_per_;
static PerConstraint JsBank_component__id_per_cons_;
extern const TTCN_Typedescriptor_t JsBank_component__id_descr_;
extern UNIVERSAL_CHARSTRING JsBank_component__id_default_coding;
extern const TTCN_OERdescriptor_t JsBank_bankId_oer_;
extern const ASN_PERdescriptor_t JsBank_bankId_per_;
extern const TTCN_Typedescriptor_t JsBank_bankId_descr_;
extern UNIVERSAL_CHARSTRING JsBank_bankId_default_coding;
extern const TTCN_OERdescriptor_t JsBank_numberOfSlots_oer_;
extern const ASN_PERdescriptor_t JsBank_numberOfSlots_per_;
extern const TTCN_Typedescriptor_t JsBank_numberOfSlots_descr_;
extern UNIVERSAL_CHARSTRING JsBank_numberOfSlots_default_coding;
extern const TTCN_JSONdescriptor_t JsBank_json_;
extern const TTCN_Typedescriptor_t JsBank_descr_;
extern UNIVERSAL_CHARSTRING JsBank_default_coding;
extern const TTCN_JSONdescriptor_t JsBanks_json_;
extern const TTCN_Typedescriptor_t JsBanks_descr_;
extern const TTCN_Typedescriptor_t JsBanks_0_descr_;
extern UNIVERSAL_CHARSTRING JsBanks_0_default_coding;
extern UNIVERSAL_CHARSTRING JsBanks_default_coding;
extern const XERdescriptor_t JsClient_peer_xer_;
extern const TTCN_Typedescriptor_t JsClient_peer_descr_;
extern UNIVERSAL_CHARSTRING JsClient_peer_default_coding;
extern const TTCN_Typedescriptor_t JsClient_state_descr_;
extern UNIVERSAL_CHARSTRING JsClient_state_default_coding;
extern const TTCN_OERdescriptor_t JsClient_component__id_oer_;
extern const ASN_PERdescriptor_t JsClient_component__id_per_;
static PerConstraint JsClient_component__id_per_cons_;
extern const TTCN_Typedescriptor_t JsClient_component__id_descr_;
extern UNIVERSAL_CHARSTRING JsClient_component__id_default_coding;
extern const TTCN_JSONdescriptor_t JsClient_json_;
extern const TTCN_Typedescriptor_t JsClient_descr_;
extern UNIVERSAL_CHARSTRING JsClient_default_coding;
extern const TTCN_JSONdescriptor_t JsClients_json_;
extern const TTCN_Typedescriptor_t JsClients_descr_;
extern const TTCN_Typedescriptor_t JsClients_0_descr_;
extern UNIVERSAL_CHARSTRING JsClients_0_default_coding;
extern UNIVERSAL_CHARSTRING JsClients_default_coding;
extern const TTCN_JSONdescriptor_t SlotmapState_json_;
extern const TTCN_Typedescriptor_t SlotmapState_descr_;
extern UNIVERSAL_CHARSTRING SlotmapState_default_coding;
extern const TTCN_OERdescriptor_t JsSlotmap_bank_oer_;
extern const ASN_PERdescriptor_t JsSlotmap_bank_per_;
static PerConstraint JsSlotmap_bank_per_cons_;
extern const TTCN_Typedescriptor_t JsSlotmap_bank_descr_;
extern UNIVERSAL_CHARSTRING JsSlotmap_bank_default_coding;
extern const TTCN_OERdescriptor_t JsSlotmap_client_oer_;
extern const ASN_PERdescriptor_t JsSlotmap_client_per_;
static PerConstraint JsSlotmap_client_per_cons_;
extern const TTCN_Typedescriptor_t JsSlotmap_client_descr_;
extern UNIVERSAL_CHARSTRING JsSlotmap_client_default_coding;
extern const TTCN_JSONdescriptor_t JsSlotmap_json_;
extern const TTCN_Typedescriptor_t JsSlotmap_descr_;
extern const TTCN_Typedescriptor_t JsSlotmap_state_descr_;
extern UNIVERSAL_CHARSTRING JsSlotmap_state_default_coding;
extern UNIVERSAL_CHARSTRING JsSlotmap_default_coding;
extern const TTCN_JSONdescriptor_t JsSlotmaps_json_;
extern const TTCN_Typedescriptor_t JsSlotmaps_descr_;
extern const TTCN_Typedescriptor_t JsSlotmaps_0_descr_;
extern UNIVERSAL_CHARSTRING JsSlotmaps_0_default_coding;
extern UNIVERSAL_CHARSTRING JsSlotmaps_default_coding;
extern const SlotmapState_template& ts__JsSlotmap_state_defval;
extern SlotmapState_template template_ts__JsSlotmap_state_defval;
extern const SlotmapState_template& tr__JsSlotmap_state_defval;
extern SlotmapState_template template_tr__JsSlotmap_state_defval;
extern const TTCN_JSONdescriptor_t JsRoot_json_;
extern const TTCN_Typedescriptor_t JsRoot_descr_;
extern const TTCN_Typedescriptor_t JsRoot_clients_descr_;
extern UNIVERSAL_CHARSTRING JsRoot_clients_default_coding;
extern const TTCN_Typedescriptor_t JsRoot_banks_descr_;
extern UNIVERSAL_CHARSTRING JsRoot_banks_default_coding;
extern const TTCN_Typedescriptor_t JsRoot_slotmaps_descr_;
extern UNIVERSAL_CHARSTRING JsRoot_slotmaps_default_coding;
extern UNIVERSAL_CHARSTRING JsRoot_default_coding;
extern const unsigned char module_checksum[];
extern TTCN_Module module_object;
extern const RuntimeVersionChecker ver_checker;

} /* end of namespace */

#endif