// 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 Prometheus__Checker_HH
#define Prometheus__Checker_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 "Misc_Helpers.hh"
#include "Socket_API_Definitions.hh"
#include "Osmocom_Types.hh"
#include "HTTP_Adapter.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 Prometheus__Checker_HH
#endif

namespace Prometheus__Checker {

/* Forward declarations of classes */

class PrometheusMetricType;
class PrometheusMetricType_template;
class PrometheusMetricKey;
class PrometheusMetricKey_template;
class PrometheusMetricKeys;
class PrometheusMetricKeys_template;
class PrometheusMetric;
class PrometheusMetric_template;
class PrometheusMetrics;
class PrometheusMetrics_template;
class PrometheusExpect;
class PrometheusExpect_template;
class PrometheusExpects;
class PrometheusExpects_template;
class PrometheusResultType;
class PrometheusResultType_template;
class PrometheusExpectResult;
class PrometheusExpectResult_template;

} /* end of namespace */

#ifndef Prometheus__Checker_HH
#define Prometheus__Checker_HH

namespace Prometheus__Checker {

/* Type definitions */

typedef COMPONENT Prometheus__Checker__CT;
typedef COMPONENT_template Prometheus__Checker__CT_template;

/* Class definitions */

class PrometheusMetricType : public Base_Type { // enum
friend class PrometheusMetricType_template;
public:
enum enum_type { COUNTER = 0, GAUGE = 1, UNKNOWN_VALUE = 2, UNBOUND_VALUE = 3 };
private:
enum_type enum_value;

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

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

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

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

void copy_template(const PrometheusMetricType_template& other_value);

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

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

boolean match(PrometheusMetricType::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const PrometheusMetricType& other_value, boolean legacy = FALSE) const;
PrometheusMetricType::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
PrometheusMetricType_template& list_item(unsigned int list_index);
void log() const;
void log_match(const PrometheusMetricType& 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 PrometheusMetricKey {
  CHARSTRING field_name;
  PrometheusMetricType field_mtype;
public:
  PrometheusMetricKey();
  PrometheusMetricKey(const CHARSTRING& par_name,
    const PrometheusMetricType& par_mtype);
  PrometheusMetricKey(const PrometheusMetricKey& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  PrometheusMetricKey& operator=(const PrometheusMetricKey& other_value);
  boolean operator==(const PrometheusMetricKey& other_value) const;
  inline boolean operator!=(const PrometheusMetricKey& 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& name()
    {return field_name;}
  inline const CHARSTRING& name() const
    {return field_name;}
  inline PrometheusMetricType& mtype()
    {return field_mtype;}
  inline const PrometheusMetricType& mtype() const
    {return field_mtype;}
  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);
};

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

void set_specific();
void copy_value(const PrometheusMetricKey& other_value);
void copy_template(const PrometheusMetricKey_template& other_value);

public:
PrometheusMetricKey_template();
PrometheusMetricKey_template(template_sel other_value);
PrometheusMetricKey_template(const PrometheusMetricKey& other_value);
PrometheusMetricKey_template(const OPTIONAL<PrometheusMetricKey>& other_value);
PrometheusMetricKey_template(PrometheusMetricKey_template* p_precondition, PrometheusMetricKey_template* p_implied_template);
PrometheusMetricKey_template(Dynamic_Match_Interface<PrometheusMetricKey>* p_dyn_match);
PrometheusMetricKey_template(const PrometheusMetricKey_template& other_value);
~PrometheusMetricKey_template();
PrometheusMetricKey_template& operator=(template_sel other_value);
PrometheusMetricKey_template& operator=(const PrometheusMetricKey& other_value);
PrometheusMetricKey_template& operator=(const OPTIONAL<PrometheusMetricKey>& other_value);
PrometheusMetricKey_template& operator=(const PrometheusMetricKey_template& other_value);
boolean match(const PrometheusMetricKey& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
PrometheusMetricKey valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
PrometheusMetricKey_template& list_item(unsigned int list_index) const;
CHARSTRING_template& name();
const CHARSTRING_template& name() const;
PrometheusMetricType_template& mtype();
const PrometheusMetricType_template& mtype() const;
int size_of() const;
void log() const;
void log_match(const PrometheusMetricKey& 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 PrometheusMetricKeys : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
PrometheusMetricKey **value_elements;
} *val_ptr;

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

public:
  typedef PrometheusMetricKey of_type;
PrometheusMetricKeys();
PrometheusMetricKeys(null_type other_value);
PrometheusMetricKeys(const PrometheusMetricKeys& other_value);
~PrometheusMetricKeys();

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

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

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

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

PrometheusMetricKeys operator+(const PrometheusMetricKeys& other_value) const;

PrometheusMetricKeys substr(int index, int returncount) const;

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

PrometheusMetricKeys replace(int index, int len, const PrometheusMetricKeys_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);
};

class PrometheusMetricKeys_template : public Restricted_Length_Template {
union {
struct {
int n_elements;
PrometheusMetricKey_template **value_elements;
} single_value;
struct {
unsigned int n_values;
PrometheusMetricKeys_template *list_value;
} value_list;
struct {
PrometheusMetricKeys_template* precondition;
PrometheusMetricKeys_template* implied_template;
} implication_;
dynmatch_struct<PrometheusMetricKeys>* dyn_match;
struct {
unsigned int n_items;
PrometheusMetricKey_template *set_items;
} value_set;
};
void copy_value(const PrometheusMetricKeys& other_value);
void copy_template(const PrometheusMetricKeys_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:
PrometheusMetricKeys_template();
PrometheusMetricKeys_template(template_sel other_value);
PrometheusMetricKeys_template(null_type other_value);
PrometheusMetricKeys_template(const PrometheusMetricKeys& other_value);
PrometheusMetricKeys_template(const OPTIONAL<PrometheusMetricKeys>& other_value);
PrometheusMetricKeys_template(PrometheusMetricKeys_template* p_precondition, PrometheusMetricKeys_template* p_implied_template);
PrometheusMetricKeys_template(Dynamic_Match_Interface<PrometheusMetricKeys>* p_dyn_match);
PrometheusMetricKeys_template(const PrometheusMetricKeys_template& other_value);
~PrometheusMetricKeys_template();

void clean_up();
PrometheusMetricKeys_template& operator=(template_sel other_value);
PrometheusMetricKeys_template& operator=(null_type other_value);
PrometheusMetricKeys_template& operator=(const PrometheusMetricKeys& other_value);
PrometheusMetricKeys_template& operator=(const OPTIONAL<PrometheusMetricKeys>& other_value);
PrometheusMetricKeys_template& operator=(const PrometheusMetricKeys_template& other_value);

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

PrometheusMetricKeys replace(int index, int len, const PrometheusMetricKeys_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
PrometheusMetricKeys_template& list_item(unsigned int list_index);
PrometheusMetricKey_template& set_item(unsigned int set_index);
void log() const;
void log_match(const PrometheusMetricKeys& 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 PrometheusMetric {
  PrometheusMetricKey field_key;
  INTEGER field_val;
public:
  PrometheusMetric();
  PrometheusMetric(const PrometheusMetricKey& par_key,
    const INTEGER& par_val);
  PrometheusMetric(const PrometheusMetric& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  PrometheusMetric& operator=(const PrometheusMetric& other_value);
  boolean operator==(const PrometheusMetric& other_value) const;
  inline boolean operator!=(const PrometheusMetric& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline PrometheusMetricKey& key()
    {return field_key;}
  inline const PrometheusMetricKey& key() const
    {return field_key;}
  inline INTEGER& val()
    {return field_val;}
  inline const INTEGER& val() const
    {return field_val;}
  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);
};

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

void set_specific();
void copy_value(const PrometheusMetric& other_value);
void copy_template(const PrometheusMetric_template& other_value);

public:
PrometheusMetric_template();
PrometheusMetric_template(template_sel other_value);
PrometheusMetric_template(const PrometheusMetric& other_value);
PrometheusMetric_template(const OPTIONAL<PrometheusMetric>& other_value);
PrometheusMetric_template(PrometheusMetric_template* p_precondition, PrometheusMetric_template* p_implied_template);
PrometheusMetric_template(Dynamic_Match_Interface<PrometheusMetric>* p_dyn_match);
PrometheusMetric_template(const PrometheusMetric_template& other_value);
~PrometheusMetric_template();
PrometheusMetric_template& operator=(template_sel other_value);
PrometheusMetric_template& operator=(const PrometheusMetric& other_value);
PrometheusMetric_template& operator=(const OPTIONAL<PrometheusMetric>& other_value);
PrometheusMetric_template& operator=(const PrometheusMetric_template& other_value);
boolean match(const PrometheusMetric& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
PrometheusMetric valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
PrometheusMetric_template& list_item(unsigned int list_index) const;
PrometheusMetricKey_template& key();
const PrometheusMetricKey_template& key() const;
INTEGER_template& val();
const INTEGER_template& val() const;
int size_of() const;
void log() const;
void log_match(const PrometheusMetric& 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 PrometheusMetrics : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
PrometheusMetric **value_elements;
} *val_ptr;

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

public:
  typedef PrometheusMetric of_type;
PrometheusMetrics();
PrometheusMetrics(null_type other_value);
PrometheusMetrics(const PrometheusMetrics& other_value);
~PrometheusMetrics();

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

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

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

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

PrometheusMetrics operator+(const PrometheusMetrics& other_value) const;

PrometheusMetrics substr(int index, int returncount) const;

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

PrometheusMetrics replace(int index, int len, const PrometheusMetrics_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);
};

class PrometheusMetrics_template : public Restricted_Length_Template {
union {
struct {
int n_elements;
PrometheusMetric_template **value_elements;
} single_value;
struct {
unsigned int n_values;
PrometheusMetrics_template *list_value;
} value_list;
struct {
PrometheusMetrics_template* precondition;
PrometheusMetrics_template* implied_template;
} implication_;
dynmatch_struct<PrometheusMetrics>* dyn_match;
struct {
unsigned int n_items;
PrometheusMetric_template *set_items;
} value_set;
};
void copy_value(const PrometheusMetrics& other_value);
void copy_template(const PrometheusMetrics_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:
PrometheusMetrics_template();
PrometheusMetrics_template(template_sel other_value);
PrometheusMetrics_template(null_type other_value);
PrometheusMetrics_template(const PrometheusMetrics& other_value);
PrometheusMetrics_template(const OPTIONAL<PrometheusMetrics>& other_value);
PrometheusMetrics_template(PrometheusMetrics_template* p_precondition, PrometheusMetrics_template* p_implied_template);
PrometheusMetrics_template(Dynamic_Match_Interface<PrometheusMetrics>* p_dyn_match);
PrometheusMetrics_template(const PrometheusMetrics_template& other_value);
~PrometheusMetrics_template();

void clean_up();
PrometheusMetrics_template& operator=(template_sel other_value);
PrometheusMetrics_template& operator=(null_type other_value);
PrometheusMetrics_template& operator=(const PrometheusMetrics& other_value);
PrometheusMetrics_template& operator=(const OPTIONAL<PrometheusMetrics>& other_value);
PrometheusMetrics_template& operator=(const PrometheusMetrics_template& other_value);

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

PrometheusMetrics replace(int index, int len, const PrometheusMetrics_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
PrometheusMetrics_template& list_item(unsigned int list_index);
PrometheusMetric_template& set_item(unsigned int set_index);
void log() const;
void log_match(const PrometheusMetrics& 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 PrometheusExpect {
  PrometheusMetricKey field_key;
  INTEGER field_min;
  INTEGER field_max;
public:
  PrometheusExpect();
  PrometheusExpect(const PrometheusMetricKey& par_key,
    const INTEGER& par_min,
    const INTEGER& par_max);
  PrometheusExpect(const PrometheusExpect& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  PrometheusExpect& operator=(const PrometheusExpect& other_value);
  boolean operator==(const PrometheusExpect& other_value) const;
  inline boolean operator!=(const PrometheusExpect& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline PrometheusMetricKey& key()
    {return field_key;}
  inline const PrometheusMetricKey& key() const
    {return field_key;}
  inline INTEGER& min()
    {return field_min;}
  inline const INTEGER& min() const
    {return field_min;}
  inline INTEGER& max()
    {return field_max;}
  inline const INTEGER& max() const
    {return field_max;}
  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);
};

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

void set_specific();
void copy_value(const PrometheusExpect& other_value);
void copy_template(const PrometheusExpect_template& other_value);

public:
PrometheusExpect_template();
PrometheusExpect_template(template_sel other_value);
PrometheusExpect_template(const PrometheusExpect& other_value);
PrometheusExpect_template(const OPTIONAL<PrometheusExpect>& other_value);
PrometheusExpect_template(PrometheusExpect_template* p_precondition, PrometheusExpect_template* p_implied_template);
PrometheusExpect_template(Dynamic_Match_Interface<PrometheusExpect>* p_dyn_match);
PrometheusExpect_template(const PrometheusExpect_template& other_value);
~PrometheusExpect_template();
PrometheusExpect_template& operator=(template_sel other_value);
PrometheusExpect_template& operator=(const PrometheusExpect& other_value);
PrometheusExpect_template& operator=(const OPTIONAL<PrometheusExpect>& other_value);
PrometheusExpect_template& operator=(const PrometheusExpect_template& other_value);
boolean match(const PrometheusExpect& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
PrometheusExpect valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
PrometheusExpect_template& list_item(unsigned int list_index) const;
PrometheusMetricKey_template& key();
const PrometheusMetricKey_template& key() const;
INTEGER_template& min();
const INTEGER_template& min() const;
INTEGER_template& max();
const INTEGER_template& max() const;
int size_of() const;
void log() const;
void log_match(const PrometheusExpect& 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 PrometheusExpects : public Base_Type {
struct recordof_setof_struct {
int ref_count;
int n_elements;
PrometheusExpect **value_elements;
} *val_ptr;

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

public:
  typedef PrometheusExpect of_type;
PrometheusExpects();
PrometheusExpects(null_type other_value);
PrometheusExpects(const PrometheusExpects& other_value);
~PrometheusExpects();

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

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

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

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

PrometheusExpects operator+(const PrometheusExpects& other_value) const;

PrometheusExpects substr(int index, int returncount) const;

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

PrometheusExpects replace(int index, int len, const PrometheusExpects_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);
};

class PrometheusExpects_template : public Restricted_Length_Template {
union {
struct {
int n_elements;
PrometheusExpect_template **value_elements;
} single_value;
struct {
unsigned int n_values;
PrometheusExpects_template *list_value;
} value_list;
struct {
PrometheusExpects_template* precondition;
PrometheusExpects_template* implied_template;
} implication_;
dynmatch_struct<PrometheusExpects>* dyn_match;
struct {
unsigned int n_items;
PrometheusExpect_template *set_items;
} value_set;
};
void copy_value(const PrometheusExpects& other_value);
void copy_template(const PrometheusExpects_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:
PrometheusExpects_template();
PrometheusExpects_template(template_sel other_value);
PrometheusExpects_template(null_type other_value);
PrometheusExpects_template(const PrometheusExpects& other_value);
PrometheusExpects_template(const OPTIONAL<PrometheusExpects>& other_value);
PrometheusExpects_template(PrometheusExpects_template* p_precondition, PrometheusExpects_template* p_implied_template);
PrometheusExpects_template(Dynamic_Match_Interface<PrometheusExpects>* p_dyn_match);
PrometheusExpects_template(const PrometheusExpects_template& other_value);
~PrometheusExpects_template();

void clean_up();
PrometheusExpects_template& operator=(template_sel other_value);
PrometheusExpects_template& operator=(null_type other_value);
PrometheusExpects_template& operator=(const PrometheusExpects& other_value);
PrometheusExpects_template& operator=(const OPTIONAL<PrometheusExpects>& other_value);
PrometheusExpects_template& operator=(const PrometheusExpects_template& other_value);

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

PrometheusExpects replace(int index, int len, const PrometheusExpects_template& repl) const;

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

void set_type(template_sel template_type, unsigned int list_length);
PrometheusExpects_template& list_item(unsigned int list_index);
PrometheusExpect_template& set_item(unsigned int set_index);
void log() const;
void log_match(const PrometheusExpects& 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 PrometheusResultType : public Base_Type { // enum
friend class PrometheusResultType_template;
public:
enum enum_type { e__Matched = 0, e__Mismatched = 1, e__NotFound = 2, UNKNOWN_VALUE = 3, UNBOUND_VALUE = 4 };
private:
enum_type enum_value;

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

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

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

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

void copy_template(const PrometheusResultType_template& other_value);

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

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

boolean match(PrometheusResultType::enum_type other_value, boolean legacy = FALSE) const;
boolean match(const PrometheusResultType& other_value, boolean legacy = FALSE) const;
PrometheusResultType::enum_type valueof() const;
void set_type(template_sel template_type, unsigned int list_length = 0);
PrometheusResultType_template& list_item(unsigned int list_index);
void log() const;
void log_match(const PrometheusResultType& 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 PrometheusExpectResult {
  PrometheusResultType field_kind;
  INTEGER field_idx;
public:
  PrometheusExpectResult();
  PrometheusExpectResult(const PrometheusResultType& par_kind,
    const INTEGER& par_idx);
  PrometheusExpectResult(const PrometheusExpectResult& other_value);
  inline boolean is_component() { return FALSE; }
  void clean_up();
const TTCN_Typedescriptor_t* get_descriptor() const;
  PrometheusExpectResult& operator=(const PrometheusExpectResult& other_value);
  boolean operator==(const PrometheusExpectResult& other_value) const;
  inline boolean operator!=(const PrometheusExpectResult& other_value) const
    { return !(*this == other_value); }

  boolean is_bound() const;

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

  inline PrometheusResultType& kind()
    {return field_kind;}
  inline const PrometheusResultType& kind() const
    {return field_kind;}
  inline INTEGER& idx()
    {return field_idx;}
  inline const INTEGER& idx() const
    {return field_idx;}
  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);
};

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

void set_specific();
void copy_value(const PrometheusExpectResult& other_value);
void copy_template(const PrometheusExpectResult_template& other_value);

public:
PrometheusExpectResult_template();
PrometheusExpectResult_template(template_sel other_value);
PrometheusExpectResult_template(const PrometheusExpectResult& other_value);
PrometheusExpectResult_template(const OPTIONAL<PrometheusExpectResult>& other_value);
PrometheusExpectResult_template(PrometheusExpectResult_template* p_precondition, PrometheusExpectResult_template* p_implied_template);
PrometheusExpectResult_template(Dynamic_Match_Interface<PrometheusExpectResult>* p_dyn_match);
PrometheusExpectResult_template(const PrometheusExpectResult_template& other_value);
~PrometheusExpectResult_template();
PrometheusExpectResult_template& operator=(template_sel other_value);
PrometheusExpectResult_template& operator=(const PrometheusExpectResult& other_value);
PrometheusExpectResult_template& operator=(const OPTIONAL<PrometheusExpectResult>& other_value);
PrometheusExpectResult_template& operator=(const PrometheusExpectResult_template& other_value);
boolean match(const PrometheusExpectResult& other_value, boolean legacy = FALSE) const;
boolean is_bound() const;
boolean is_value() const;
void clean_up();
PrometheusExpectResult valueof() const;
void set_type(template_sel template_type, unsigned int list_length);
PrometheusExpectResult_template& list_item(unsigned int list_index) const;
PrometheusResultType_template& kind();
const PrometheusResultType_template& kind() const;
INTEGER_template& idx();
const INTEGER_template& idx() const;
int size_of() const;
void log() const;
void log_match(const PrometheusExpectResult& 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 boolean operator==(null_type null_value, const PrometheusMetricKeys& other_value);
inline boolean operator!=(null_type null_value, const PrometheusMetricKeys& other_value) { return !(null_value == other_value); }
extern boolean operator==(null_type null_value, const PrometheusMetrics& other_value);
inline boolean operator!=(null_type null_value, const PrometheusMetrics& other_value) { return !(null_value == other_value); }
extern boolean operator==(null_type null_value, const PrometheusExpects& other_value);
inline boolean operator!=(null_type null_value, const PrometheusExpects& other_value) { return !(null_value == other_value); }
extern PrometheusMetricKey_template ts__PrometheusMetricKey(const CHARSTRING_template& name, const PrometheusMetricType_template& mtype);
extern PrometheusMetric_template ts__PrometheusMetric(const CHARSTRING_template& name, const PrometheusMetricType_template& mtype, const INTEGER_template& val);
extern PrometheusExpect_template ts__PrometheusExpect(const CHARSTRING_template& name, const PrometheusMetricType_template& mtype, const INTEGER_template& min, const INTEGER_template& max);
extern void f__prometheus__init(const CHARSTRING& http__host, const INTEGER& http__port);
extern void start_f__prometheus__init(const COMPONENT& component_reference, const CHARSTRING& http__host, const INTEGER& http__port);
extern PrometheusMetricType f__prometheus__metric__mtype__from__string(const CHARSTRING& str);
extern PrometheusMetrics f__prometheus__parse__http__response(const CHARSTRING& body);
extern CHARSTRING f__prometheus__get__http__metrics();
extern void start_f__prometheus__get__http__metrics(const COMPONENT& component_reference);
extern PrometheusMetrics f__prometheus__get__metrics();
extern void start_f__prometheus__get__metrics(const COMPONENT& component_reference);
extern BOOLEAN f__prometheus__metrics__update__value(PrometheusMetrics& metrics, General__Types::Booleans& seen, const PrometheusMetric& it);
extern PrometheusMetricKeys f__prometheus__keys__from__expect(const PrometheusExpects& expects);
extern PrometheusMetrics f__prometheus__snapshot(const PrometheusMetricKeys& keys, const FLOAT& time__out);
extern void start_f__prometheus__snapshot(const COMPONENT& component_reference, const PrometheusMetricKeys& keys, const FLOAT& time__out);
extern BOOLEAN f__compare__PrometheusMetricKey(const PrometheusMetricKey& a, const PrometheusMetricKey& b);
extern BOOLEAN get__val__from__snapshot(INTEGER& val, const PrometheusMetric& metric, const PrometheusMetrics& snapshot);
extern BOOLEAN f__compare__expect(const PrometheusMetric& metric, const PrometheusExpect& expect, const BOOLEAN& use__snapshot, const PrometheusMetrics& snapshot);
extern PrometheusExpectResult f__prometheus__metric__expects(const PrometheusExpects& expects, const PrometheusMetric& metric, const BOOLEAN& use__snapshot, const PrometheusMetrics& snapshot);
extern BOOLEAN f__prometheus__expect__ext(const PrometheusExpects& expects, const BOOLEAN& wait__converge, const BOOLEAN& use__snapshot, const PrometheusMetrics& snapshot, const FLOAT& time__out);
extern void start_f__prometheus__expect__ext(const COMPONENT& component_reference, const PrometheusExpects& expects, const BOOLEAN& wait__converge, const BOOLEAN& use__snapshot, const PrometheusMetrics& snapshot, const FLOAT& time__out);
extern BOOLEAN f__prometheus__expect(const PrometheusExpects& expects, const BOOLEAN& wait__converge, const FLOAT& time__out);
extern void start_f__prometheus__expect(const COMPONENT& component_reference, const PrometheusExpects& expects, const BOOLEAN& wait__converge, const FLOAT& time__out);
extern BOOLEAN f__prometheus__expect__from__snapshot(const PrometheusExpects& expects, const BOOLEAN& wait__converge, const PrometheusMetrics& snapshot, const FLOAT& time__out);
extern void start_f__prometheus__expect__from__snapshot(const COMPONENT& component_reference, const PrometheusExpects& expects, const BOOLEAN& wait__converge, const PrometheusMetrics& snapshot, const FLOAT& time__out);
extern void pre_init_module();
extern void post_init_module();
extern boolean set_module_param(Module_Param& param);
extern void log_module_param();
extern boolean init_comp_type(const char *component_type, boolean init_base_comps);
extern boolean init_system_port(const char* component_type, const char* port_name);
extern boolean start_ptc_function(const char *function_name, Text_Buf& function_arguments);

/* Global variable declarations */

extern const INTEGER& c__prometheus__default__http__port;
extern INTEGER const_c__prometheus__default__http__port;
extern const TTCN_Typedescriptor_t PrometheusMetricType_descr_;
extern const XERdescriptor_t PrometheusMetricKey_name_xer_;
extern const TTCN_Typedescriptor_t PrometheusMetricKey_name_descr_;
extern const TTCN_Typedescriptor_t PrometheusMetricKey_descr_;
extern const TTCN_Typedescriptor_t PrometheusMetricKeys_descr_;
extern const XERdescriptor_t PrometheusMetric_val_xer_;
extern const TTCN_Typedescriptor_t PrometheusMetric_val_descr_;
extern const TTCN_Typedescriptor_t PrometheusMetric_descr_;
extern const TTCN_Typedescriptor_t PrometheusMetrics_descr_;
extern const XERdescriptor_t PrometheusExpect_min_xer_;
extern const TTCN_Typedescriptor_t PrometheusExpect_min_descr_;
extern const XERdescriptor_t PrometheusExpect_max_xer_;
extern const TTCN_Typedescriptor_t PrometheusExpect_max_descr_;
extern const TTCN_Typedescriptor_t PrometheusExpect_descr_;
extern const TTCN_Typedescriptor_t PrometheusExpects_descr_;
extern const BOOLEAN& mp__enable__stats;
extern BOOLEAN modulepar_mp__enable__stats;
extern const TTCN_Typedescriptor_t PrometheusResultType_descr_;
extern const XERdescriptor_t PrometheusExpectResult_idx_xer_;
extern const TTCN_Typedescriptor_t PrometheusExpectResult_idx_descr_;
extern const TTCN_Typedescriptor_t PrometheusExpectResult_descr_;
extern const TTCN_Typedescriptor_t& Prometheus__Checker__CT_descr_;
extern FLOAT Prometheus__Checker__CT_component_g__tout__http;
extern const INTEGER_template& ts__PrometheusMetric_val_defval;
extern INTEGER_template template_ts__PrometheusMetric_val_defval;
extern const INTEGER& f__prometheus__init_http__port_defval;
extern INTEGER const_f__prometheus__init_http__port_defval;
extern const FLOAT& f__prometheus__snapshot_time__out_defval;
extern FLOAT const_f__prometheus__snapshot_time__out_defval;
extern const BOOLEAN& f__compare__expect_use__snapshot_defval;
extern BOOLEAN const_f__compare__expect_use__snapshot_defval;
extern const PrometheusMetrics& f__compare__expect_snapshot_defval;
extern PrometheusMetrics const_f__compare__expect_snapshot_defval;
extern const BOOLEAN& f__prometheus__metric__expects_use__snapshot_defval;
extern BOOLEAN const_f__prometheus__metric__expects_use__snapshot_defval;
extern const PrometheusMetrics& f__prometheus__metric__expects_snapshot_defval;
extern PrometheusMetrics const_f__prometheus__metric__expects_snapshot_defval;
extern const BOOLEAN& f__prometheus__expect__ext_wait__converge_defval;
extern BOOLEAN const_f__prometheus__expect__ext_wait__converge_defval;
extern const BOOLEAN& f__prometheus__expect__ext_use__snapshot_defval;
extern BOOLEAN const_f__prometheus__expect__ext_use__snapshot_defval;
extern const PrometheusMetrics& f__prometheus__expect__ext_snapshot_defval;
extern PrometheusMetrics const_f__prometheus__expect__ext_snapshot_defval;
extern const FLOAT& f__prometheus__expect__ext_time__out_defval;
extern FLOAT const_f__prometheus__expect__ext_time__out_defval;
extern const BOOLEAN& f__prometheus__expect_wait__converge_defval;
extern BOOLEAN const_f__prometheus__expect_wait__converge_defval;
extern const FLOAT& f__prometheus__expect_time__out_defval;
extern FLOAT const_f__prometheus__expect_time__out_defval;
extern const BOOLEAN& f__prometheus__expect__from__snapshot_wait__converge_defval;
extern BOOLEAN const_f__prometheus__expect__from__snapshot_wait__converge_defval;
extern const PrometheusMetrics& f__prometheus__expect__from__snapshot_snapshot_defval;
extern PrometheusMetrics const_f__prometheus__expect__from__snapshot_snapshot_defval;
extern const FLOAT& f__prometheus__expect__from__snapshot_time__out_defval;
extern FLOAT const_f__prometheus__expect__from__snapshot_time__out_defval;
extern const CHARSTRING cs_3,
cs_6,
cs_4,
cs_5,
cs_7,
cs_8,
cs_2,
cs_0,
cs_1;
extern const unsigned char module_checksum[];
extern TTCN_Module module_object;
extern const RuntimeVersionChecker ver_checker;

} /* end of namespace */

#endif
