/**
 * Autogenerated by Thrift Compiler (0.13.0)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
#ifndef Hawk_H
#define Hawk_H

#include <thrift/TDispatchProcessor.h>
#include <thrift/async/TConcurrentClientSyncInfo.h>
#include <memory>
#include "api_types.h"



#ifdef _MSC_VER
  #pragma warning( push )
  #pragma warning (disable : 4250 ) //inheriting methods via dominance 
#endif

class HawkIf {
 public:
  virtual ~HawkIf() {}
  virtual void createInstance(const std::string& name, const std::string& backend, const int32_t minimumDelayMillis, const int32_t maximumDelayMillis, const std::vector<std::string> & enabledPlugins, const std::string& indexFactory) = 0;
  virtual void listBackends(std::vector<std::string> & _return) = 0;
  virtual void listPlugins(std::vector<std::string> & _return) = 0;
  virtual void listPluginDetails(std::vector<HawkPlugin> & _return) = 0;
  virtual void listInstances(std::vector<HawkInstance> & _return) = 0;
  virtual void removeInstance(const std::string& name) = 0;
  virtual void startInstance(const std::string& name) = 0;
  virtual void stopInstance(const std::string& name) = 0;
  virtual void syncInstance(const std::string& name, const bool blockUntilDone) = 0;
  virtual void registerMetamodels(const std::string& name, const std::vector<File> & metamodel) = 0;
  virtual void unregisterMetamodels(const std::string& name, const std::vector<std::string> & metamodel) = 0;
  virtual void listMetamodels(std::vector<std::string> & _return, const std::string& name) = 0;
  virtual void listTypeNames(std::vector<std::string> & _return, const std::string& hawkInstanceName, const std::string& metamodelURI) = 0;
  virtual void listAttributeNames(std::vector<std::string> & _return, const std::string& hawkInstanceName, const std::string& metamodelURI, const std::string& typeName) = 0;
  virtual void listMetamodelParsers(std::vector<MetamodelParserDetails> & _return, const std::string& name) = 0;
  virtual void listQueryLanguages(std::vector<std::string> & _return, const std::string& name) = 0;
  virtual void query(QueryResult& _return, const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options) = 0;
  virtual void timedQuery(QueryReport& _return, const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options) = 0;
  virtual void resolveProxies(std::vector<ModelElement> & _return, const std::string& name, const std::vector<std::string> & ids, const HawkQueryOptions& options) = 0;
  virtual void asyncQuery(std::string& _return, const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options) = 0;
  virtual void cancelAsyncQuery(const std::string& queryID) = 0;
  virtual void fetchAsyncQueryResults(QueryReport& _return, const std::string& queryID) = 0;
  virtual void addRepository(const std::string& name, const Repository& repo, const Credentials& credentials) = 0;
  virtual bool isFrozen(const std::string& name, const std::string& uri) = 0;
  virtual void setFrozen(const std::string& name, const std::string& uri, const bool isFrozen) = 0;
  virtual void removeRepository(const std::string& name, const std::string& uri) = 0;
  virtual void updateRepositoryCredentials(const std::string& name, const std::string& uri, const Credentials& cred) = 0;
  virtual void listRepositories(std::vector<Repository> & _return, const std::string& name) = 0;
  virtual void listRepositoryTypes(std::vector<std::string> & _return) = 0;
  virtual void listFiles(std::vector<std::string> & _return, const std::string& name, const std::vector<std::string> & repository, const std::vector<std::string> & filePatterns) = 0;
  virtual void configurePolling(const std::string& name, const int32_t base, const int32_t max) = 0;
  virtual void addDerivedAttribute(const std::string& name, const DerivedAttributeSpec& spec) = 0;
  virtual void removeDerivedAttribute(const std::string& name, const DerivedAttributeSpec& spec) = 0;
  virtual void listDerivedAttributes(std::vector<DerivedAttributeSpec> & _return, const std::string& name) = 0;
  virtual void addIndexedAttribute(const std::string& name, const IndexedAttributeSpec& spec) = 0;
  virtual void removeIndexedAttribute(const std::string& name, const IndexedAttributeSpec& spec) = 0;
  virtual void listIndexedAttributes(std::vector<IndexedAttributeSpec> & _return, const std::string& name) = 0;
  virtual void getModel(std::vector<ModelElement> & _return, const std::string& name, const HawkQueryOptions& options) = 0;
  virtual void getRootElements(std::vector<ModelElement> & _return, const std::string& name, const HawkQueryOptions& options) = 0;
  virtual void watchStateChanges(Subscription& _return, const std::string& name) = 0;
  virtual void watchModelChanges(Subscription& _return, const std::string& name, const std::string& repositoryUri, const std::vector<std::string> & filePath, const std::string& clientID, const SubscriptionDurability::type durableEvents) = 0;
};

class HawkIfFactory {
 public:
  typedef HawkIf Handler;

  virtual ~HawkIfFactory() {}

  virtual HawkIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
  virtual void releaseHandler(HawkIf* /* handler */) = 0;
};

class HawkIfSingletonFactory : virtual public HawkIfFactory {
 public:
  HawkIfSingletonFactory(const ::std::shared_ptr<HawkIf>& iface) : iface_(iface) {}
  virtual ~HawkIfSingletonFactory() {}

  virtual HawkIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
    return iface_.get();
  }
  virtual void releaseHandler(HawkIf* /* handler */) {}

 protected:
  ::std::shared_ptr<HawkIf> iface_;
};

class HawkNull : virtual public HawkIf {
 public:
  virtual ~HawkNull() {}
  void createInstance(const std::string& /* name */, const std::string& /* backend */, const int32_t /* minimumDelayMillis */, const int32_t /* maximumDelayMillis */, const std::vector<std::string> & /* enabledPlugins */, const std::string& /* indexFactory */) {
    return;
  }
  void listBackends(std::vector<std::string> & /* _return */) {
    return;
  }
  void listPlugins(std::vector<std::string> & /* _return */) {
    return;
  }
  void listPluginDetails(std::vector<HawkPlugin> & /* _return */) {
    return;
  }
  void listInstances(std::vector<HawkInstance> & /* _return */) {
    return;
  }
  void removeInstance(const std::string& /* name */) {
    return;
  }
  void startInstance(const std::string& /* name */) {
    return;
  }
  void stopInstance(const std::string& /* name */) {
    return;
  }
  void syncInstance(const std::string& /* name */, const bool /* blockUntilDone */) {
    return;
  }
  void registerMetamodels(const std::string& /* name */, const std::vector<File> & /* metamodel */) {
    return;
  }
  void unregisterMetamodels(const std::string& /* name */, const std::vector<std::string> & /* metamodel */) {
    return;
  }
  void listMetamodels(std::vector<std::string> & /* _return */, const std::string& /* name */) {
    return;
  }
  void listTypeNames(std::vector<std::string> & /* _return */, const std::string& /* hawkInstanceName */, const std::string& /* metamodelURI */) {
    return;
  }
  void listAttributeNames(std::vector<std::string> & /* _return */, const std::string& /* hawkInstanceName */, const std::string& /* metamodelURI */, const std::string& /* typeName */) {
    return;
  }
  void listMetamodelParsers(std::vector<MetamodelParserDetails> & /* _return */, const std::string& /* name */) {
    return;
  }
  void listQueryLanguages(std::vector<std::string> & /* _return */, const std::string& /* name */) {
    return;
  }
  void query(QueryResult& /* _return */, const std::string& /* name */, const std::string& /* query */, const std::string& /* language */, const HawkQueryOptions& /* options */) {
    return;
  }
  void timedQuery(QueryReport& /* _return */, const std::string& /* name */, const std::string& /* query */, const std::string& /* language */, const HawkQueryOptions& /* options */) {
    return;
  }
  void resolveProxies(std::vector<ModelElement> & /* _return */, const std::string& /* name */, const std::vector<std::string> & /* ids */, const HawkQueryOptions& /* options */) {
    return;
  }
  void asyncQuery(std::string& /* _return */, const std::string& /* name */, const std::string& /* query */, const std::string& /* language */, const HawkQueryOptions& /* options */) {
    return;
  }
  void cancelAsyncQuery(const std::string& /* queryID */) {
    return;
  }
  void fetchAsyncQueryResults(QueryReport& /* _return */, const std::string& /* queryID */) {
    return;
  }
  void addRepository(const std::string& /* name */, const Repository& /* repo */, const Credentials& /* credentials */) {
    return;
  }
  bool isFrozen(const std::string& /* name */, const std::string& /* uri */) {
    bool _return = false;
    return _return;
  }
  void setFrozen(const std::string& /* name */, const std::string& /* uri */, const bool /* isFrozen */) {
    return;
  }
  void removeRepository(const std::string& /* name */, const std::string& /* uri */) {
    return;
  }
  void updateRepositoryCredentials(const std::string& /* name */, const std::string& /* uri */, const Credentials& /* cred */) {
    return;
  }
  void listRepositories(std::vector<Repository> & /* _return */, const std::string& /* name */) {
    return;
  }
  void listRepositoryTypes(std::vector<std::string> & /* _return */) {
    return;
  }
  void listFiles(std::vector<std::string> & /* _return */, const std::string& /* name */, const std::vector<std::string> & /* repository */, const std::vector<std::string> & /* filePatterns */) {
    return;
  }
  void configurePolling(const std::string& /* name */, const int32_t /* base */, const int32_t /* max */) {
    return;
  }
  void addDerivedAttribute(const std::string& /* name */, const DerivedAttributeSpec& /* spec */) {
    return;
  }
  void removeDerivedAttribute(const std::string& /* name */, const DerivedAttributeSpec& /* spec */) {
    return;
  }
  void listDerivedAttributes(std::vector<DerivedAttributeSpec> & /* _return */, const std::string& /* name */) {
    return;
  }
  void addIndexedAttribute(const std::string& /* name */, const IndexedAttributeSpec& /* spec */) {
    return;
  }
  void removeIndexedAttribute(const std::string& /* name */, const IndexedAttributeSpec& /* spec */) {
    return;
  }
  void listIndexedAttributes(std::vector<IndexedAttributeSpec> & /* _return */, const std::string& /* name */) {
    return;
  }
  void getModel(std::vector<ModelElement> & /* _return */, const std::string& /* name */, const HawkQueryOptions& /* options */) {
    return;
  }
  void getRootElements(std::vector<ModelElement> & /* _return */, const std::string& /* name */, const HawkQueryOptions& /* options */) {
    return;
  }
  void watchStateChanges(Subscription& /* _return */, const std::string& /* name */) {
    return;
  }
  void watchModelChanges(Subscription& /* _return */, const std::string& /* name */, const std::string& /* repositoryUri */, const std::vector<std::string> & /* filePath */, const std::string& /* clientID */, const SubscriptionDurability::type /* durableEvents */) {
    return;
  }
};

typedef struct _Hawk_createInstance_args__isset {
  _Hawk_createInstance_args__isset() : enabledPlugins(false), indexFactory(false) {}
  bool enabledPlugins :1;
  bool indexFactory :1;
} _Hawk_createInstance_args__isset;

class Hawk_createInstance_args {
 public:

  Hawk_createInstance_args(const Hawk_createInstance_args&);
  Hawk_createInstance_args& operator=(const Hawk_createInstance_args&);
  Hawk_createInstance_args() : name(), backend(), minimumDelayMillis(0), maximumDelayMillis(0), indexFactory() {
  }

  virtual ~Hawk_createInstance_args() noexcept;
  std::string name;
  std::string backend;
  int32_t minimumDelayMillis;
  int32_t maximumDelayMillis;
  std::vector<std::string>  enabledPlugins;
  std::string indexFactory;

  _Hawk_createInstance_args__isset __isset;

  void __set_name(const std::string& val);

  void __set_backend(const std::string& val);

  void __set_minimumDelayMillis(const int32_t val);

  void __set_maximumDelayMillis(const int32_t val);

  void __set_enabledPlugins(const std::vector<std::string> & val);

  void __set_indexFactory(const std::string& val);

  bool operator == (const Hawk_createInstance_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(backend == rhs.backend))
      return false;
    if (!(minimumDelayMillis == rhs.minimumDelayMillis))
      return false;
    if (!(maximumDelayMillis == rhs.maximumDelayMillis))
      return false;
    if (!(enabledPlugins == rhs.enabledPlugins))
      return false;
    if (!(indexFactory == rhs.indexFactory))
      return false;
    return true;
  }
  bool operator != (const Hawk_createInstance_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_createInstance_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_createInstance_pargs {
 public:


  virtual ~Hawk_createInstance_pargs() noexcept;
  const std::string* name;
  const std::string* backend;
  const int32_t* minimumDelayMillis;
  const int32_t* maximumDelayMillis;
  const std::vector<std::string> * enabledPlugins;
  const std::string* indexFactory;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_createInstance_result__isset {
  _Hawk_createInstance_result__isset() : err1(false) {}
  bool err1 :1;
} _Hawk_createInstance_result__isset;

class Hawk_createInstance_result {
 public:

  Hawk_createInstance_result(const Hawk_createInstance_result&);
  Hawk_createInstance_result& operator=(const Hawk_createInstance_result&);
  Hawk_createInstance_result() {
  }

  virtual ~Hawk_createInstance_result() noexcept;
  HawkFactoryNotFound err1;

  _Hawk_createInstance_result__isset __isset;

  void __set_err1(const HawkFactoryNotFound& val);

  bool operator == (const Hawk_createInstance_result & rhs) const
  {
    if (!(err1 == rhs.err1))
      return false;
    return true;
  }
  bool operator != (const Hawk_createInstance_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_createInstance_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_createInstance_presult__isset {
  _Hawk_createInstance_presult__isset() : err1(false) {}
  bool err1 :1;
} _Hawk_createInstance_presult__isset;

class Hawk_createInstance_presult {
 public:


  virtual ~Hawk_createInstance_presult() noexcept;
  HawkFactoryNotFound err1;

  _Hawk_createInstance_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_listBackends_args {
 public:

  Hawk_listBackends_args(const Hawk_listBackends_args&);
  Hawk_listBackends_args& operator=(const Hawk_listBackends_args&);
  Hawk_listBackends_args() {
  }

  virtual ~Hawk_listBackends_args() noexcept;

  bool operator == (const Hawk_listBackends_args & /* rhs */) const
  {
    return true;
  }
  bool operator != (const Hawk_listBackends_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listBackends_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_listBackends_pargs {
 public:


  virtual ~Hawk_listBackends_pargs() noexcept;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listBackends_result__isset {
  _Hawk_listBackends_result__isset() : success(false) {}
  bool success :1;
} _Hawk_listBackends_result__isset;

class Hawk_listBackends_result {
 public:

  Hawk_listBackends_result(const Hawk_listBackends_result&);
  Hawk_listBackends_result& operator=(const Hawk_listBackends_result&);
  Hawk_listBackends_result() {
  }

  virtual ~Hawk_listBackends_result() noexcept;
  std::vector<std::string>  success;

  _Hawk_listBackends_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  bool operator == (const Hawk_listBackends_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const Hawk_listBackends_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listBackends_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listBackends_presult__isset {
  _Hawk_listBackends_presult__isset() : success(false) {}
  bool success :1;
} _Hawk_listBackends_presult__isset;

class Hawk_listBackends_presult {
 public:


  virtual ~Hawk_listBackends_presult() noexcept;
  std::vector<std::string> * success;

  _Hawk_listBackends_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_listPlugins_args {
 public:

  Hawk_listPlugins_args(const Hawk_listPlugins_args&);
  Hawk_listPlugins_args& operator=(const Hawk_listPlugins_args&);
  Hawk_listPlugins_args() {
  }

  virtual ~Hawk_listPlugins_args() noexcept;

  bool operator == (const Hawk_listPlugins_args & /* rhs */) const
  {
    return true;
  }
  bool operator != (const Hawk_listPlugins_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listPlugins_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_listPlugins_pargs {
 public:


  virtual ~Hawk_listPlugins_pargs() noexcept;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listPlugins_result__isset {
  _Hawk_listPlugins_result__isset() : success(false) {}
  bool success :1;
} _Hawk_listPlugins_result__isset;

class Hawk_listPlugins_result {
 public:

  Hawk_listPlugins_result(const Hawk_listPlugins_result&);
  Hawk_listPlugins_result& operator=(const Hawk_listPlugins_result&);
  Hawk_listPlugins_result() {
  }

  virtual ~Hawk_listPlugins_result() noexcept;
  std::vector<std::string>  success;

  _Hawk_listPlugins_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  bool operator == (const Hawk_listPlugins_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const Hawk_listPlugins_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listPlugins_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listPlugins_presult__isset {
  _Hawk_listPlugins_presult__isset() : success(false) {}
  bool success :1;
} _Hawk_listPlugins_presult__isset;

class Hawk_listPlugins_presult {
 public:


  virtual ~Hawk_listPlugins_presult() noexcept;
  std::vector<std::string> * success;

  _Hawk_listPlugins_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_listPluginDetails_args {
 public:

  Hawk_listPluginDetails_args(const Hawk_listPluginDetails_args&);
  Hawk_listPluginDetails_args& operator=(const Hawk_listPluginDetails_args&);
  Hawk_listPluginDetails_args() {
  }

  virtual ~Hawk_listPluginDetails_args() noexcept;

  bool operator == (const Hawk_listPluginDetails_args & /* rhs */) const
  {
    return true;
  }
  bool operator != (const Hawk_listPluginDetails_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listPluginDetails_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_listPluginDetails_pargs {
 public:


  virtual ~Hawk_listPluginDetails_pargs() noexcept;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listPluginDetails_result__isset {
  _Hawk_listPluginDetails_result__isset() : success(false) {}
  bool success :1;
} _Hawk_listPluginDetails_result__isset;

class Hawk_listPluginDetails_result {
 public:

  Hawk_listPluginDetails_result(const Hawk_listPluginDetails_result&);
  Hawk_listPluginDetails_result& operator=(const Hawk_listPluginDetails_result&);
  Hawk_listPluginDetails_result() {
  }

  virtual ~Hawk_listPluginDetails_result() noexcept;
  std::vector<HawkPlugin>  success;

  _Hawk_listPluginDetails_result__isset __isset;

  void __set_success(const std::vector<HawkPlugin> & val);

  bool operator == (const Hawk_listPluginDetails_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const Hawk_listPluginDetails_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listPluginDetails_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listPluginDetails_presult__isset {
  _Hawk_listPluginDetails_presult__isset() : success(false) {}
  bool success :1;
} _Hawk_listPluginDetails_presult__isset;

class Hawk_listPluginDetails_presult {
 public:


  virtual ~Hawk_listPluginDetails_presult() noexcept;
  std::vector<HawkPlugin> * success;

  _Hawk_listPluginDetails_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_listInstances_args {
 public:

  Hawk_listInstances_args(const Hawk_listInstances_args&);
  Hawk_listInstances_args& operator=(const Hawk_listInstances_args&);
  Hawk_listInstances_args() {
  }

  virtual ~Hawk_listInstances_args() noexcept;

  bool operator == (const Hawk_listInstances_args & /* rhs */) const
  {
    return true;
  }
  bool operator != (const Hawk_listInstances_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listInstances_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_listInstances_pargs {
 public:


  virtual ~Hawk_listInstances_pargs() noexcept;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listInstances_result__isset {
  _Hawk_listInstances_result__isset() : success(false) {}
  bool success :1;
} _Hawk_listInstances_result__isset;

class Hawk_listInstances_result {
 public:

  Hawk_listInstances_result(const Hawk_listInstances_result&);
  Hawk_listInstances_result& operator=(const Hawk_listInstances_result&);
  Hawk_listInstances_result() {
  }

  virtual ~Hawk_listInstances_result() noexcept;
  std::vector<HawkInstance>  success;

  _Hawk_listInstances_result__isset __isset;

  void __set_success(const std::vector<HawkInstance> & val);

  bool operator == (const Hawk_listInstances_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const Hawk_listInstances_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listInstances_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listInstances_presult__isset {
  _Hawk_listInstances_presult__isset() : success(false) {}
  bool success :1;
} _Hawk_listInstances_presult__isset;

class Hawk_listInstances_presult {
 public:


  virtual ~Hawk_listInstances_presult() noexcept;
  std::vector<HawkInstance> * success;

  _Hawk_listInstances_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_removeInstance_args {
 public:

  Hawk_removeInstance_args(const Hawk_removeInstance_args&);
  Hawk_removeInstance_args& operator=(const Hawk_removeInstance_args&);
  Hawk_removeInstance_args() : name() {
  }

  virtual ~Hawk_removeInstance_args() noexcept;
  std::string name;

  void __set_name(const std::string& val);

  bool operator == (const Hawk_removeInstance_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    return true;
  }
  bool operator != (const Hawk_removeInstance_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_removeInstance_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_removeInstance_pargs {
 public:


  virtual ~Hawk_removeInstance_pargs() noexcept;
  const std::string* name;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_removeInstance_result__isset {
  _Hawk_removeInstance_result__isset() : err1(false) {}
  bool err1 :1;
} _Hawk_removeInstance_result__isset;

class Hawk_removeInstance_result {
 public:

  Hawk_removeInstance_result(const Hawk_removeInstance_result&);
  Hawk_removeInstance_result& operator=(const Hawk_removeInstance_result&);
  Hawk_removeInstance_result() {
  }

  virtual ~Hawk_removeInstance_result() noexcept;
  HawkInstanceNotFound err1;

  _Hawk_removeInstance_result__isset __isset;

  void __set_err1(const HawkInstanceNotFound& val);

  bool operator == (const Hawk_removeInstance_result & rhs) const
  {
    if (!(err1 == rhs.err1))
      return false;
    return true;
  }
  bool operator != (const Hawk_removeInstance_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_removeInstance_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_removeInstance_presult__isset {
  _Hawk_removeInstance_presult__isset() : err1(false) {}
  bool err1 :1;
} _Hawk_removeInstance_presult__isset;

class Hawk_removeInstance_presult {
 public:


  virtual ~Hawk_removeInstance_presult() noexcept;
  HawkInstanceNotFound err1;

  _Hawk_removeInstance_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_startInstance_args {
 public:

  Hawk_startInstance_args(const Hawk_startInstance_args&);
  Hawk_startInstance_args& operator=(const Hawk_startInstance_args&);
  Hawk_startInstance_args() : name() {
  }

  virtual ~Hawk_startInstance_args() noexcept;
  std::string name;

  void __set_name(const std::string& val);

  bool operator == (const Hawk_startInstance_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    return true;
  }
  bool operator != (const Hawk_startInstance_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_startInstance_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_startInstance_pargs {
 public:


  virtual ~Hawk_startInstance_pargs() noexcept;
  const std::string* name;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_startInstance_result__isset {
  _Hawk_startInstance_result__isset() : err1(false) {}
  bool err1 :1;
} _Hawk_startInstance_result__isset;

class Hawk_startInstance_result {
 public:

  Hawk_startInstance_result(const Hawk_startInstance_result&);
  Hawk_startInstance_result& operator=(const Hawk_startInstance_result&);
  Hawk_startInstance_result() {
  }

  virtual ~Hawk_startInstance_result() noexcept;
  HawkInstanceNotFound err1;

  _Hawk_startInstance_result__isset __isset;

  void __set_err1(const HawkInstanceNotFound& val);

  bool operator == (const Hawk_startInstance_result & rhs) const
  {
    if (!(err1 == rhs.err1))
      return false;
    return true;
  }
  bool operator != (const Hawk_startInstance_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_startInstance_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_startInstance_presult__isset {
  _Hawk_startInstance_presult__isset() : err1(false) {}
  bool err1 :1;
} _Hawk_startInstance_presult__isset;

class Hawk_startInstance_presult {
 public:


  virtual ~Hawk_startInstance_presult() noexcept;
  HawkInstanceNotFound err1;

  _Hawk_startInstance_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_stopInstance_args {
 public:

  Hawk_stopInstance_args(const Hawk_stopInstance_args&);
  Hawk_stopInstance_args& operator=(const Hawk_stopInstance_args&);
  Hawk_stopInstance_args() : name() {
  }

  virtual ~Hawk_stopInstance_args() noexcept;
  std::string name;

  void __set_name(const std::string& val);

  bool operator == (const Hawk_stopInstance_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    return true;
  }
  bool operator != (const Hawk_stopInstance_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_stopInstance_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_stopInstance_pargs {
 public:


  virtual ~Hawk_stopInstance_pargs() noexcept;
  const std::string* name;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_stopInstance_result__isset {
  _Hawk_stopInstance_result__isset() : err1(false), err2(false) {}
  bool err1 :1;
  bool err2 :1;
} _Hawk_stopInstance_result__isset;

class Hawk_stopInstance_result {
 public:

  Hawk_stopInstance_result(const Hawk_stopInstance_result&);
  Hawk_stopInstance_result& operator=(const Hawk_stopInstance_result&);
  Hawk_stopInstance_result() {
  }

  virtual ~Hawk_stopInstance_result() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_stopInstance_result__isset __isset;

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_stopInstance_result & rhs) const
  {
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_stopInstance_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_stopInstance_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_stopInstance_presult__isset {
  _Hawk_stopInstance_presult__isset() : err1(false), err2(false) {}
  bool err1 :1;
  bool err2 :1;
} _Hawk_stopInstance_presult__isset;

class Hawk_stopInstance_presult {
 public:


  virtual ~Hawk_stopInstance_presult() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_stopInstance_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _Hawk_syncInstance_args__isset {
  _Hawk_syncInstance_args__isset() : blockUntilDone(true) {}
  bool blockUntilDone :1;
} _Hawk_syncInstance_args__isset;

class Hawk_syncInstance_args {
 public:

  Hawk_syncInstance_args(const Hawk_syncInstance_args&);
  Hawk_syncInstance_args& operator=(const Hawk_syncInstance_args&);
  Hawk_syncInstance_args() : name(), blockUntilDone(false) {
  }

  virtual ~Hawk_syncInstance_args() noexcept;
  std::string name;
  bool blockUntilDone;

  _Hawk_syncInstance_args__isset __isset;

  void __set_name(const std::string& val);

  void __set_blockUntilDone(const bool val);

  bool operator == (const Hawk_syncInstance_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(blockUntilDone == rhs.blockUntilDone))
      return false;
    return true;
  }
  bool operator != (const Hawk_syncInstance_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_syncInstance_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_syncInstance_pargs {
 public:


  virtual ~Hawk_syncInstance_pargs() noexcept;
  const std::string* name;
  const bool* blockUntilDone;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_syncInstance_result__isset {
  _Hawk_syncInstance_result__isset() : err1(false), err2(false) {}
  bool err1 :1;
  bool err2 :1;
} _Hawk_syncInstance_result__isset;

class Hawk_syncInstance_result {
 public:

  Hawk_syncInstance_result(const Hawk_syncInstance_result&);
  Hawk_syncInstance_result& operator=(const Hawk_syncInstance_result&);
  Hawk_syncInstance_result() {
  }

  virtual ~Hawk_syncInstance_result() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_syncInstance_result__isset __isset;

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_syncInstance_result & rhs) const
  {
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_syncInstance_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_syncInstance_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_syncInstance_presult__isset {
  _Hawk_syncInstance_presult__isset() : err1(false), err2(false) {}
  bool err1 :1;
  bool err2 :1;
} _Hawk_syncInstance_presult__isset;

class Hawk_syncInstance_presult {
 public:


  virtual ~Hawk_syncInstance_presult() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_syncInstance_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_registerMetamodels_args {
 public:

  Hawk_registerMetamodels_args(const Hawk_registerMetamodels_args&);
  Hawk_registerMetamodels_args& operator=(const Hawk_registerMetamodels_args&);
  Hawk_registerMetamodels_args() : name() {
  }

  virtual ~Hawk_registerMetamodels_args() noexcept;
  std::string name;
  std::vector<File>  metamodel;

  void __set_name(const std::string& val);

  void __set_metamodel(const std::vector<File> & val);

  bool operator == (const Hawk_registerMetamodels_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(metamodel == rhs.metamodel))
      return false;
    return true;
  }
  bool operator != (const Hawk_registerMetamodels_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_registerMetamodels_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_registerMetamodels_pargs {
 public:


  virtual ~Hawk_registerMetamodels_pargs() noexcept;
  const std::string* name;
  const std::vector<File> * metamodel;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_registerMetamodels_result__isset {
  _Hawk_registerMetamodels_result__isset() : err1(false), err2(false), err3(false) {}
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
} _Hawk_registerMetamodels_result__isset;

class Hawk_registerMetamodels_result {
 public:

  Hawk_registerMetamodels_result(const Hawk_registerMetamodels_result&);
  Hawk_registerMetamodels_result& operator=(const Hawk_registerMetamodels_result&);
  Hawk_registerMetamodels_result() {
  }

  virtual ~Hawk_registerMetamodels_result() noexcept;
  HawkInstanceNotFound err1;
  InvalidMetamodel err2;
  HawkInstanceNotRunning err3;

  _Hawk_registerMetamodels_result__isset __isset;

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const InvalidMetamodel& val);

  void __set_err3(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_registerMetamodels_result & rhs) const
  {
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    if (!(err3 == rhs.err3))
      return false;
    return true;
  }
  bool operator != (const Hawk_registerMetamodels_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_registerMetamodels_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_registerMetamodels_presult__isset {
  _Hawk_registerMetamodels_presult__isset() : err1(false), err2(false), err3(false) {}
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
} _Hawk_registerMetamodels_presult__isset;

class Hawk_registerMetamodels_presult {
 public:


  virtual ~Hawk_registerMetamodels_presult() noexcept;
  HawkInstanceNotFound err1;
  InvalidMetamodel err2;
  HawkInstanceNotRunning err3;

  _Hawk_registerMetamodels_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_unregisterMetamodels_args {
 public:

  Hawk_unregisterMetamodels_args(const Hawk_unregisterMetamodels_args&);
  Hawk_unregisterMetamodels_args& operator=(const Hawk_unregisterMetamodels_args&);
  Hawk_unregisterMetamodels_args() : name() {
  }

  virtual ~Hawk_unregisterMetamodels_args() noexcept;
  std::string name;
  std::vector<std::string>  metamodel;

  void __set_name(const std::string& val);

  void __set_metamodel(const std::vector<std::string> & val);

  bool operator == (const Hawk_unregisterMetamodels_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(metamodel == rhs.metamodel))
      return false;
    return true;
  }
  bool operator != (const Hawk_unregisterMetamodels_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_unregisterMetamodels_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_unregisterMetamodels_pargs {
 public:


  virtual ~Hawk_unregisterMetamodels_pargs() noexcept;
  const std::string* name;
  const std::vector<std::string> * metamodel;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_unregisterMetamodels_result__isset {
  _Hawk_unregisterMetamodels_result__isset() : err1(false), err2(false) {}
  bool err1 :1;
  bool err2 :1;
} _Hawk_unregisterMetamodels_result__isset;

class Hawk_unregisterMetamodels_result {
 public:

  Hawk_unregisterMetamodels_result(const Hawk_unregisterMetamodels_result&);
  Hawk_unregisterMetamodels_result& operator=(const Hawk_unregisterMetamodels_result&);
  Hawk_unregisterMetamodels_result() {
  }

  virtual ~Hawk_unregisterMetamodels_result() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_unregisterMetamodels_result__isset __isset;

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_unregisterMetamodels_result & rhs) const
  {
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_unregisterMetamodels_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_unregisterMetamodels_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_unregisterMetamodels_presult__isset {
  _Hawk_unregisterMetamodels_presult__isset() : err1(false), err2(false) {}
  bool err1 :1;
  bool err2 :1;
} _Hawk_unregisterMetamodels_presult__isset;

class Hawk_unregisterMetamodels_presult {
 public:


  virtual ~Hawk_unregisterMetamodels_presult() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_unregisterMetamodels_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_listMetamodels_args {
 public:

  Hawk_listMetamodels_args(const Hawk_listMetamodels_args&);
  Hawk_listMetamodels_args& operator=(const Hawk_listMetamodels_args&);
  Hawk_listMetamodels_args() : name() {
  }

  virtual ~Hawk_listMetamodels_args() noexcept;
  std::string name;

  void __set_name(const std::string& val);

  bool operator == (const Hawk_listMetamodels_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    return true;
  }
  bool operator != (const Hawk_listMetamodels_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listMetamodels_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_listMetamodels_pargs {
 public:


  virtual ~Hawk_listMetamodels_pargs() noexcept;
  const std::string* name;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listMetamodels_result__isset {
  _Hawk_listMetamodels_result__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_listMetamodels_result__isset;

class Hawk_listMetamodels_result {
 public:

  Hawk_listMetamodels_result(const Hawk_listMetamodels_result&);
  Hawk_listMetamodels_result& operator=(const Hawk_listMetamodels_result&);
  Hawk_listMetamodels_result() {
  }

  virtual ~Hawk_listMetamodels_result() noexcept;
  std::vector<std::string>  success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_listMetamodels_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_listMetamodels_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_listMetamodels_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listMetamodels_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listMetamodels_presult__isset {
  _Hawk_listMetamodels_presult__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_listMetamodels_presult__isset;

class Hawk_listMetamodels_presult {
 public:


  virtual ~Hawk_listMetamodels_presult() noexcept;
  std::vector<std::string> * success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_listMetamodels_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_listTypeNames_args {
 public:

  Hawk_listTypeNames_args(const Hawk_listTypeNames_args&);
  Hawk_listTypeNames_args& operator=(const Hawk_listTypeNames_args&);
  Hawk_listTypeNames_args() : hawkInstanceName(), metamodelURI() {
  }

  virtual ~Hawk_listTypeNames_args() noexcept;
  std::string hawkInstanceName;
  std::string metamodelURI;

  void __set_hawkInstanceName(const std::string& val);

  void __set_metamodelURI(const std::string& val);

  bool operator == (const Hawk_listTypeNames_args & rhs) const
  {
    if (!(hawkInstanceName == rhs.hawkInstanceName))
      return false;
    if (!(metamodelURI == rhs.metamodelURI))
      return false;
    return true;
  }
  bool operator != (const Hawk_listTypeNames_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listTypeNames_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_listTypeNames_pargs {
 public:


  virtual ~Hawk_listTypeNames_pargs() noexcept;
  const std::string* hawkInstanceName;
  const std::string* metamodelURI;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listTypeNames_result__isset {
  _Hawk_listTypeNames_result__isset() : success(false), err1(false), err2(false), err3(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
} _Hawk_listTypeNames_result__isset;

class Hawk_listTypeNames_result {
 public:

  Hawk_listTypeNames_result(const Hawk_listTypeNames_result&);
  Hawk_listTypeNames_result& operator=(const Hawk_listTypeNames_result&);
  Hawk_listTypeNames_result() {
  }

  virtual ~Hawk_listTypeNames_result() noexcept;
  std::vector<std::string>  success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  HawkMetamodelNotFound err3;

  _Hawk_listTypeNames_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  void __set_err3(const HawkMetamodelNotFound& val);

  bool operator == (const Hawk_listTypeNames_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    if (!(err3 == rhs.err3))
      return false;
    return true;
  }
  bool operator != (const Hawk_listTypeNames_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listTypeNames_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listTypeNames_presult__isset {
  _Hawk_listTypeNames_presult__isset() : success(false), err1(false), err2(false), err3(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
} _Hawk_listTypeNames_presult__isset;

class Hawk_listTypeNames_presult {
 public:


  virtual ~Hawk_listTypeNames_presult() noexcept;
  std::vector<std::string> * success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  HawkMetamodelNotFound err3;

  _Hawk_listTypeNames_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_listAttributeNames_args {
 public:

  Hawk_listAttributeNames_args(const Hawk_listAttributeNames_args&);
  Hawk_listAttributeNames_args& operator=(const Hawk_listAttributeNames_args&);
  Hawk_listAttributeNames_args() : hawkInstanceName(), metamodelURI(), typeName() {
  }

  virtual ~Hawk_listAttributeNames_args() noexcept;
  std::string hawkInstanceName;
  std::string metamodelURI;
  std::string typeName;

  void __set_hawkInstanceName(const std::string& val);

  void __set_metamodelURI(const std::string& val);

  void __set_typeName(const std::string& val);

  bool operator == (const Hawk_listAttributeNames_args & rhs) const
  {
    if (!(hawkInstanceName == rhs.hawkInstanceName))
      return false;
    if (!(metamodelURI == rhs.metamodelURI))
      return false;
    if (!(typeName == rhs.typeName))
      return false;
    return true;
  }
  bool operator != (const Hawk_listAttributeNames_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listAttributeNames_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_listAttributeNames_pargs {
 public:


  virtual ~Hawk_listAttributeNames_pargs() noexcept;
  const std::string* hawkInstanceName;
  const std::string* metamodelURI;
  const std::string* typeName;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listAttributeNames_result__isset {
  _Hawk_listAttributeNames_result__isset() : success(false), err1(false), err2(false), err3(false), err4(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
  bool err4 :1;
} _Hawk_listAttributeNames_result__isset;

class Hawk_listAttributeNames_result {
 public:

  Hawk_listAttributeNames_result(const Hawk_listAttributeNames_result&);
  Hawk_listAttributeNames_result& operator=(const Hawk_listAttributeNames_result&);
  Hawk_listAttributeNames_result() {
  }

  virtual ~Hawk_listAttributeNames_result() noexcept;
  std::vector<std::string>  success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  HawkMetamodelNotFound err3;
  HawkTypeNotFound err4;

  _Hawk_listAttributeNames_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  void __set_err3(const HawkMetamodelNotFound& val);

  void __set_err4(const HawkTypeNotFound& val);

  bool operator == (const Hawk_listAttributeNames_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    if (!(err3 == rhs.err3))
      return false;
    if (!(err4 == rhs.err4))
      return false;
    return true;
  }
  bool operator != (const Hawk_listAttributeNames_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listAttributeNames_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listAttributeNames_presult__isset {
  _Hawk_listAttributeNames_presult__isset() : success(false), err1(false), err2(false), err3(false), err4(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
  bool err4 :1;
} _Hawk_listAttributeNames_presult__isset;

class Hawk_listAttributeNames_presult {
 public:


  virtual ~Hawk_listAttributeNames_presult() noexcept;
  std::vector<std::string> * success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  HawkMetamodelNotFound err3;
  HawkTypeNotFound err4;

  _Hawk_listAttributeNames_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_listMetamodelParsers_args {
 public:

  Hawk_listMetamodelParsers_args(const Hawk_listMetamodelParsers_args&);
  Hawk_listMetamodelParsers_args& operator=(const Hawk_listMetamodelParsers_args&);
  Hawk_listMetamodelParsers_args() : name() {
  }

  virtual ~Hawk_listMetamodelParsers_args() noexcept;
  std::string name;

  void __set_name(const std::string& val);

  bool operator == (const Hawk_listMetamodelParsers_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    return true;
  }
  bool operator != (const Hawk_listMetamodelParsers_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listMetamodelParsers_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_listMetamodelParsers_pargs {
 public:


  virtual ~Hawk_listMetamodelParsers_pargs() noexcept;
  const std::string* name;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listMetamodelParsers_result__isset {
  _Hawk_listMetamodelParsers_result__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_listMetamodelParsers_result__isset;

class Hawk_listMetamodelParsers_result {
 public:

  Hawk_listMetamodelParsers_result(const Hawk_listMetamodelParsers_result&);
  Hawk_listMetamodelParsers_result& operator=(const Hawk_listMetamodelParsers_result&);
  Hawk_listMetamodelParsers_result() {
  }

  virtual ~Hawk_listMetamodelParsers_result() noexcept;
  std::vector<MetamodelParserDetails>  success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_listMetamodelParsers_result__isset __isset;

  void __set_success(const std::vector<MetamodelParserDetails> & val);

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_listMetamodelParsers_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_listMetamodelParsers_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listMetamodelParsers_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listMetamodelParsers_presult__isset {
  _Hawk_listMetamodelParsers_presult__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_listMetamodelParsers_presult__isset;

class Hawk_listMetamodelParsers_presult {
 public:


  virtual ~Hawk_listMetamodelParsers_presult() noexcept;
  std::vector<MetamodelParserDetails> * success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_listMetamodelParsers_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_listQueryLanguages_args {
 public:

  Hawk_listQueryLanguages_args(const Hawk_listQueryLanguages_args&);
  Hawk_listQueryLanguages_args& operator=(const Hawk_listQueryLanguages_args&);
  Hawk_listQueryLanguages_args() : name() {
  }

  virtual ~Hawk_listQueryLanguages_args() noexcept;
  std::string name;

  void __set_name(const std::string& val);

  bool operator == (const Hawk_listQueryLanguages_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    return true;
  }
  bool operator != (const Hawk_listQueryLanguages_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listQueryLanguages_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_listQueryLanguages_pargs {
 public:


  virtual ~Hawk_listQueryLanguages_pargs() noexcept;
  const std::string* name;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listQueryLanguages_result__isset {
  _Hawk_listQueryLanguages_result__isset() : success(false) {}
  bool success :1;
} _Hawk_listQueryLanguages_result__isset;

class Hawk_listQueryLanguages_result {
 public:

  Hawk_listQueryLanguages_result(const Hawk_listQueryLanguages_result&);
  Hawk_listQueryLanguages_result& operator=(const Hawk_listQueryLanguages_result&);
  Hawk_listQueryLanguages_result() {
  }

  virtual ~Hawk_listQueryLanguages_result() noexcept;
  std::vector<std::string>  success;

  _Hawk_listQueryLanguages_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  bool operator == (const Hawk_listQueryLanguages_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const Hawk_listQueryLanguages_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listQueryLanguages_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listQueryLanguages_presult__isset {
  _Hawk_listQueryLanguages_presult__isset() : success(false) {}
  bool success :1;
} _Hawk_listQueryLanguages_presult__isset;

class Hawk_listQueryLanguages_presult {
 public:


  virtual ~Hawk_listQueryLanguages_presult() noexcept;
  std::vector<std::string> * success;

  _Hawk_listQueryLanguages_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_query_args {
 public:

  Hawk_query_args(const Hawk_query_args&);
  Hawk_query_args& operator=(const Hawk_query_args&);
  Hawk_query_args() : name(), query(), language() {
  }

  virtual ~Hawk_query_args() noexcept;
  std::string name;
  std::string query;
  std::string language;
  HawkQueryOptions options;

  void __set_name(const std::string& val);

  void __set_query(const std::string& val);

  void __set_language(const std::string& val);

  void __set_options(const HawkQueryOptions& val);

  bool operator == (const Hawk_query_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(query == rhs.query))
      return false;
    if (!(language == rhs.language))
      return false;
    if (!(options == rhs.options))
      return false;
    return true;
  }
  bool operator != (const Hawk_query_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_query_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_query_pargs {
 public:


  virtual ~Hawk_query_pargs() noexcept;
  const std::string* name;
  const std::string* query;
  const std::string* language;
  const HawkQueryOptions* options;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_query_result__isset {
  _Hawk_query_result__isset() : success(false), err1(false), err2(false), err3(false), err4(false), err5(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
  bool err4 :1;
  bool err5 :1;
} _Hawk_query_result__isset;

class Hawk_query_result {
 public:

  Hawk_query_result(const Hawk_query_result&);
  Hawk_query_result& operator=(const Hawk_query_result&);
  Hawk_query_result() {
  }

  virtual ~Hawk_query_result() noexcept;
  QueryResult success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  UnknownQueryLanguage err3;
  InvalidQuery err4;
  FailedQuery err5;

  _Hawk_query_result__isset __isset;

  void __set_success(const QueryResult& val);

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  void __set_err3(const UnknownQueryLanguage& val);

  void __set_err4(const InvalidQuery& val);

  void __set_err5(const FailedQuery& val);

  bool operator == (const Hawk_query_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    if (!(err3 == rhs.err3))
      return false;
    if (!(err4 == rhs.err4))
      return false;
    if (!(err5 == rhs.err5))
      return false;
    return true;
  }
  bool operator != (const Hawk_query_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_query_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_query_presult__isset {
  _Hawk_query_presult__isset() : success(false), err1(false), err2(false), err3(false), err4(false), err5(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
  bool err4 :1;
  bool err5 :1;
} _Hawk_query_presult__isset;

class Hawk_query_presult {
 public:


  virtual ~Hawk_query_presult() noexcept;
  QueryResult* success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  UnknownQueryLanguage err3;
  InvalidQuery err4;
  FailedQuery err5;

  _Hawk_query_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_timedQuery_args {
 public:

  Hawk_timedQuery_args(const Hawk_timedQuery_args&);
  Hawk_timedQuery_args& operator=(const Hawk_timedQuery_args&);
  Hawk_timedQuery_args() : name(), query(), language() {
  }

  virtual ~Hawk_timedQuery_args() noexcept;
  std::string name;
  std::string query;
  std::string language;
  HawkQueryOptions options;

  void __set_name(const std::string& val);

  void __set_query(const std::string& val);

  void __set_language(const std::string& val);

  void __set_options(const HawkQueryOptions& val);

  bool operator == (const Hawk_timedQuery_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(query == rhs.query))
      return false;
    if (!(language == rhs.language))
      return false;
    if (!(options == rhs.options))
      return false;
    return true;
  }
  bool operator != (const Hawk_timedQuery_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_timedQuery_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_timedQuery_pargs {
 public:


  virtual ~Hawk_timedQuery_pargs() noexcept;
  const std::string* name;
  const std::string* query;
  const std::string* language;
  const HawkQueryOptions* options;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_timedQuery_result__isset {
  _Hawk_timedQuery_result__isset() : success(false), err1(false), err2(false), err3(false), err4(false), err5(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
  bool err4 :1;
  bool err5 :1;
} _Hawk_timedQuery_result__isset;

class Hawk_timedQuery_result {
 public:

  Hawk_timedQuery_result(const Hawk_timedQuery_result&);
  Hawk_timedQuery_result& operator=(const Hawk_timedQuery_result&);
  Hawk_timedQuery_result() {
  }

  virtual ~Hawk_timedQuery_result() noexcept;
  QueryReport success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  UnknownQueryLanguage err3;
  InvalidQuery err4;
  FailedQuery err5;

  _Hawk_timedQuery_result__isset __isset;

  void __set_success(const QueryReport& val);

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  void __set_err3(const UnknownQueryLanguage& val);

  void __set_err4(const InvalidQuery& val);

  void __set_err5(const FailedQuery& val);

  bool operator == (const Hawk_timedQuery_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    if (!(err3 == rhs.err3))
      return false;
    if (!(err4 == rhs.err4))
      return false;
    if (!(err5 == rhs.err5))
      return false;
    return true;
  }
  bool operator != (const Hawk_timedQuery_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_timedQuery_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_timedQuery_presult__isset {
  _Hawk_timedQuery_presult__isset() : success(false), err1(false), err2(false), err3(false), err4(false), err5(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
  bool err4 :1;
  bool err5 :1;
} _Hawk_timedQuery_presult__isset;

class Hawk_timedQuery_presult {
 public:


  virtual ~Hawk_timedQuery_presult() noexcept;
  QueryReport* success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  UnknownQueryLanguage err3;
  InvalidQuery err4;
  FailedQuery err5;

  _Hawk_timedQuery_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_resolveProxies_args {
 public:

  Hawk_resolveProxies_args(const Hawk_resolveProxies_args&);
  Hawk_resolveProxies_args& operator=(const Hawk_resolveProxies_args&);
  Hawk_resolveProxies_args() : name() {
  }

  virtual ~Hawk_resolveProxies_args() noexcept;
  std::string name;
  std::vector<std::string>  ids;
  HawkQueryOptions options;

  void __set_name(const std::string& val);

  void __set_ids(const std::vector<std::string> & val);

  void __set_options(const HawkQueryOptions& val);

  bool operator == (const Hawk_resolveProxies_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(ids == rhs.ids))
      return false;
    if (!(options == rhs.options))
      return false;
    return true;
  }
  bool operator != (const Hawk_resolveProxies_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_resolveProxies_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_resolveProxies_pargs {
 public:


  virtual ~Hawk_resolveProxies_pargs() noexcept;
  const std::string* name;
  const std::vector<std::string> * ids;
  const HawkQueryOptions* options;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_resolveProxies_result__isset {
  _Hawk_resolveProxies_result__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_resolveProxies_result__isset;

class Hawk_resolveProxies_result {
 public:

  Hawk_resolveProxies_result(const Hawk_resolveProxies_result&);
  Hawk_resolveProxies_result& operator=(const Hawk_resolveProxies_result&);
  Hawk_resolveProxies_result() {
  }

  virtual ~Hawk_resolveProxies_result() noexcept;
  std::vector<ModelElement>  success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_resolveProxies_result__isset __isset;

  void __set_success(const std::vector<ModelElement> & val);

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_resolveProxies_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_resolveProxies_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_resolveProxies_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_resolveProxies_presult__isset {
  _Hawk_resolveProxies_presult__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_resolveProxies_presult__isset;

class Hawk_resolveProxies_presult {
 public:


  virtual ~Hawk_resolveProxies_presult() noexcept;
  std::vector<ModelElement> * success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_resolveProxies_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_asyncQuery_args {
 public:

  Hawk_asyncQuery_args(const Hawk_asyncQuery_args&);
  Hawk_asyncQuery_args& operator=(const Hawk_asyncQuery_args&);
  Hawk_asyncQuery_args() : name(), query(), language() {
  }

  virtual ~Hawk_asyncQuery_args() noexcept;
  std::string name;
  std::string query;
  std::string language;
  HawkQueryOptions options;

  void __set_name(const std::string& val);

  void __set_query(const std::string& val);

  void __set_language(const std::string& val);

  void __set_options(const HawkQueryOptions& val);

  bool operator == (const Hawk_asyncQuery_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(query == rhs.query))
      return false;
    if (!(language == rhs.language))
      return false;
    if (!(options == rhs.options))
      return false;
    return true;
  }
  bool operator != (const Hawk_asyncQuery_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_asyncQuery_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_asyncQuery_pargs {
 public:


  virtual ~Hawk_asyncQuery_pargs() noexcept;
  const std::string* name;
  const std::string* query;
  const std::string* language;
  const HawkQueryOptions* options;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_asyncQuery_result__isset {
  _Hawk_asyncQuery_result__isset() : success(false), err1(false), err2(false), err3(false), err4(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
  bool err4 :1;
} _Hawk_asyncQuery_result__isset;

class Hawk_asyncQuery_result {
 public:

  Hawk_asyncQuery_result(const Hawk_asyncQuery_result&);
  Hawk_asyncQuery_result& operator=(const Hawk_asyncQuery_result&);
  Hawk_asyncQuery_result() : success() {
  }

  virtual ~Hawk_asyncQuery_result() noexcept;
  std::string success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  UnknownQueryLanguage err3;
  InvalidQuery err4;

  _Hawk_asyncQuery_result__isset __isset;

  void __set_success(const std::string& val);

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  void __set_err3(const UnknownQueryLanguage& val);

  void __set_err4(const InvalidQuery& val);

  bool operator == (const Hawk_asyncQuery_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    if (!(err3 == rhs.err3))
      return false;
    if (!(err4 == rhs.err4))
      return false;
    return true;
  }
  bool operator != (const Hawk_asyncQuery_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_asyncQuery_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_asyncQuery_presult__isset {
  _Hawk_asyncQuery_presult__isset() : success(false), err1(false), err2(false), err3(false), err4(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
  bool err4 :1;
} _Hawk_asyncQuery_presult__isset;

class Hawk_asyncQuery_presult {
 public:


  virtual ~Hawk_asyncQuery_presult() noexcept;
  std::string* success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  UnknownQueryLanguage err3;
  InvalidQuery err4;

  _Hawk_asyncQuery_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_cancelAsyncQuery_args {
 public:

  Hawk_cancelAsyncQuery_args(const Hawk_cancelAsyncQuery_args&);
  Hawk_cancelAsyncQuery_args& operator=(const Hawk_cancelAsyncQuery_args&);
  Hawk_cancelAsyncQuery_args() : queryID() {
  }

  virtual ~Hawk_cancelAsyncQuery_args() noexcept;
  std::string queryID;

  void __set_queryID(const std::string& val);

  bool operator == (const Hawk_cancelAsyncQuery_args & rhs) const
  {
    if (!(queryID == rhs.queryID))
      return false;
    return true;
  }
  bool operator != (const Hawk_cancelAsyncQuery_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_cancelAsyncQuery_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_cancelAsyncQuery_pargs {
 public:


  virtual ~Hawk_cancelAsyncQuery_pargs() noexcept;
  const std::string* queryID;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_cancelAsyncQuery_result__isset {
  _Hawk_cancelAsyncQuery_result__isset() : err1(false) {}
  bool err1 :1;
} _Hawk_cancelAsyncQuery_result__isset;

class Hawk_cancelAsyncQuery_result {
 public:

  Hawk_cancelAsyncQuery_result(const Hawk_cancelAsyncQuery_result&);
  Hawk_cancelAsyncQuery_result& operator=(const Hawk_cancelAsyncQuery_result&);
  Hawk_cancelAsyncQuery_result() {
  }

  virtual ~Hawk_cancelAsyncQuery_result() noexcept;
  InvalidQuery err1;

  _Hawk_cancelAsyncQuery_result__isset __isset;

  void __set_err1(const InvalidQuery& val);

  bool operator == (const Hawk_cancelAsyncQuery_result & rhs) const
  {
    if (!(err1 == rhs.err1))
      return false;
    return true;
  }
  bool operator != (const Hawk_cancelAsyncQuery_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_cancelAsyncQuery_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_cancelAsyncQuery_presult__isset {
  _Hawk_cancelAsyncQuery_presult__isset() : err1(false) {}
  bool err1 :1;
} _Hawk_cancelAsyncQuery_presult__isset;

class Hawk_cancelAsyncQuery_presult {
 public:


  virtual ~Hawk_cancelAsyncQuery_presult() noexcept;
  InvalidQuery err1;

  _Hawk_cancelAsyncQuery_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_fetchAsyncQueryResults_args {
 public:

  Hawk_fetchAsyncQueryResults_args(const Hawk_fetchAsyncQueryResults_args&);
  Hawk_fetchAsyncQueryResults_args& operator=(const Hawk_fetchAsyncQueryResults_args&);
  Hawk_fetchAsyncQueryResults_args() : queryID() {
  }

  virtual ~Hawk_fetchAsyncQueryResults_args() noexcept;
  std::string queryID;

  void __set_queryID(const std::string& val);

  bool operator == (const Hawk_fetchAsyncQueryResults_args & rhs) const
  {
    if (!(queryID == rhs.queryID))
      return false;
    return true;
  }
  bool operator != (const Hawk_fetchAsyncQueryResults_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_fetchAsyncQueryResults_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_fetchAsyncQueryResults_pargs {
 public:


  virtual ~Hawk_fetchAsyncQueryResults_pargs() noexcept;
  const std::string* queryID;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_fetchAsyncQueryResults_result__isset {
  _Hawk_fetchAsyncQueryResults_result__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_fetchAsyncQueryResults_result__isset;

class Hawk_fetchAsyncQueryResults_result {
 public:

  Hawk_fetchAsyncQueryResults_result(const Hawk_fetchAsyncQueryResults_result&);
  Hawk_fetchAsyncQueryResults_result& operator=(const Hawk_fetchAsyncQueryResults_result&);
  Hawk_fetchAsyncQueryResults_result() {
  }

  virtual ~Hawk_fetchAsyncQueryResults_result() noexcept;
  QueryReport success;
  InvalidQuery err1;
  FailedQuery err2;

  _Hawk_fetchAsyncQueryResults_result__isset __isset;

  void __set_success(const QueryReport& val);

  void __set_err1(const InvalidQuery& val);

  void __set_err2(const FailedQuery& val);

  bool operator == (const Hawk_fetchAsyncQueryResults_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_fetchAsyncQueryResults_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_fetchAsyncQueryResults_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_fetchAsyncQueryResults_presult__isset {
  _Hawk_fetchAsyncQueryResults_presult__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_fetchAsyncQueryResults_presult__isset;

class Hawk_fetchAsyncQueryResults_presult {
 public:


  virtual ~Hawk_fetchAsyncQueryResults_presult() noexcept;
  QueryReport* success;
  InvalidQuery err1;
  FailedQuery err2;

  _Hawk_fetchAsyncQueryResults_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _Hawk_addRepository_args__isset {
  _Hawk_addRepository_args__isset() : credentials(false) {}
  bool credentials :1;
} _Hawk_addRepository_args__isset;

class Hawk_addRepository_args {
 public:

  Hawk_addRepository_args(const Hawk_addRepository_args&);
  Hawk_addRepository_args& operator=(const Hawk_addRepository_args&);
  Hawk_addRepository_args() : name() {
  }

  virtual ~Hawk_addRepository_args() noexcept;
  std::string name;
  Repository repo;
  Credentials credentials;

  _Hawk_addRepository_args__isset __isset;

  void __set_name(const std::string& val);

  void __set_repo(const Repository& val);

  void __set_credentials(const Credentials& val);

  bool operator == (const Hawk_addRepository_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(repo == rhs.repo))
      return false;
    if (!(credentials == rhs.credentials))
      return false;
    return true;
  }
  bool operator != (const Hawk_addRepository_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_addRepository_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_addRepository_pargs {
 public:


  virtual ~Hawk_addRepository_pargs() noexcept;
  const std::string* name;
  const Repository* repo;
  const Credentials* credentials;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_addRepository_result__isset {
  _Hawk_addRepository_result__isset() : err1(false), err2(false), err3(false), err4(false) {}
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
  bool err4 :1;
} _Hawk_addRepository_result__isset;

class Hawk_addRepository_result {
 public:

  Hawk_addRepository_result(const Hawk_addRepository_result&);
  Hawk_addRepository_result& operator=(const Hawk_addRepository_result&);
  Hawk_addRepository_result() {
  }

  virtual ~Hawk_addRepository_result() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  UnknownRepositoryType err3;
  VCSAuthenticationFailed err4;

  _Hawk_addRepository_result__isset __isset;

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  void __set_err3(const UnknownRepositoryType& val);

  void __set_err4(const VCSAuthenticationFailed& val);

  bool operator == (const Hawk_addRepository_result & rhs) const
  {
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    if (!(err3 == rhs.err3))
      return false;
    if (!(err4 == rhs.err4))
      return false;
    return true;
  }
  bool operator != (const Hawk_addRepository_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_addRepository_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_addRepository_presult__isset {
  _Hawk_addRepository_presult__isset() : err1(false), err2(false), err3(false), err4(false) {}
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
  bool err4 :1;
} _Hawk_addRepository_presult__isset;

class Hawk_addRepository_presult {
 public:


  virtual ~Hawk_addRepository_presult() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  UnknownRepositoryType err3;
  VCSAuthenticationFailed err4;

  _Hawk_addRepository_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_isFrozen_args {
 public:

  Hawk_isFrozen_args(const Hawk_isFrozen_args&);
  Hawk_isFrozen_args& operator=(const Hawk_isFrozen_args&);
  Hawk_isFrozen_args() : name(), uri() {
  }

  virtual ~Hawk_isFrozen_args() noexcept;
  std::string name;
  std::string uri;

  void __set_name(const std::string& val);

  void __set_uri(const std::string& val);

  bool operator == (const Hawk_isFrozen_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(uri == rhs.uri))
      return false;
    return true;
  }
  bool operator != (const Hawk_isFrozen_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_isFrozen_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_isFrozen_pargs {
 public:


  virtual ~Hawk_isFrozen_pargs() noexcept;
  const std::string* name;
  const std::string* uri;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_isFrozen_result__isset {
  _Hawk_isFrozen_result__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_isFrozen_result__isset;

class Hawk_isFrozen_result {
 public:

  Hawk_isFrozen_result(const Hawk_isFrozen_result&);
  Hawk_isFrozen_result& operator=(const Hawk_isFrozen_result&);
  Hawk_isFrozen_result() : success(0) {
  }

  virtual ~Hawk_isFrozen_result() noexcept;
  bool success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_isFrozen_result__isset __isset;

  void __set_success(const bool val);

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_isFrozen_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_isFrozen_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_isFrozen_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_isFrozen_presult__isset {
  _Hawk_isFrozen_presult__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_isFrozen_presult__isset;

class Hawk_isFrozen_presult {
 public:


  virtual ~Hawk_isFrozen_presult() noexcept;
  bool* success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_isFrozen_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_setFrozen_args {
 public:

  Hawk_setFrozen_args(const Hawk_setFrozen_args&);
  Hawk_setFrozen_args& operator=(const Hawk_setFrozen_args&);
  Hawk_setFrozen_args() : name(), uri(), isFrozen(0) {
  }

  virtual ~Hawk_setFrozen_args() noexcept;
  std::string name;
  std::string uri;
  bool isFrozen;

  void __set_name(const std::string& val);

  void __set_uri(const std::string& val);

  void __set_isFrozen(const bool val);

  bool operator == (const Hawk_setFrozen_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(uri == rhs.uri))
      return false;
    if (!(isFrozen == rhs.isFrozen))
      return false;
    return true;
  }
  bool operator != (const Hawk_setFrozen_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_setFrozen_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_setFrozen_pargs {
 public:


  virtual ~Hawk_setFrozen_pargs() noexcept;
  const std::string* name;
  const std::string* uri;
  const bool* isFrozen;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_setFrozen_result__isset {
  _Hawk_setFrozen_result__isset() : err1(false), err2(false) {}
  bool err1 :1;
  bool err2 :1;
} _Hawk_setFrozen_result__isset;

class Hawk_setFrozen_result {
 public:

  Hawk_setFrozen_result(const Hawk_setFrozen_result&);
  Hawk_setFrozen_result& operator=(const Hawk_setFrozen_result&);
  Hawk_setFrozen_result() {
  }

  virtual ~Hawk_setFrozen_result() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_setFrozen_result__isset __isset;

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_setFrozen_result & rhs) const
  {
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_setFrozen_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_setFrozen_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_setFrozen_presult__isset {
  _Hawk_setFrozen_presult__isset() : err1(false), err2(false) {}
  bool err1 :1;
  bool err2 :1;
} _Hawk_setFrozen_presult__isset;

class Hawk_setFrozen_presult {
 public:


  virtual ~Hawk_setFrozen_presult() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_setFrozen_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_removeRepository_args {
 public:

  Hawk_removeRepository_args(const Hawk_removeRepository_args&);
  Hawk_removeRepository_args& operator=(const Hawk_removeRepository_args&);
  Hawk_removeRepository_args() : name(), uri() {
  }

  virtual ~Hawk_removeRepository_args() noexcept;
  std::string name;
  std::string uri;

  void __set_name(const std::string& val);

  void __set_uri(const std::string& val);

  bool operator == (const Hawk_removeRepository_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(uri == rhs.uri))
      return false;
    return true;
  }
  bool operator != (const Hawk_removeRepository_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_removeRepository_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_removeRepository_pargs {
 public:


  virtual ~Hawk_removeRepository_pargs() noexcept;
  const std::string* name;
  const std::string* uri;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_removeRepository_result__isset {
  _Hawk_removeRepository_result__isset() : err1(false), err2(false) {}
  bool err1 :1;
  bool err2 :1;
} _Hawk_removeRepository_result__isset;

class Hawk_removeRepository_result {
 public:

  Hawk_removeRepository_result(const Hawk_removeRepository_result&);
  Hawk_removeRepository_result& operator=(const Hawk_removeRepository_result&);
  Hawk_removeRepository_result() {
  }

  virtual ~Hawk_removeRepository_result() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_removeRepository_result__isset __isset;

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_removeRepository_result & rhs) const
  {
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_removeRepository_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_removeRepository_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_removeRepository_presult__isset {
  _Hawk_removeRepository_presult__isset() : err1(false), err2(false) {}
  bool err1 :1;
  bool err2 :1;
} _Hawk_removeRepository_presult__isset;

class Hawk_removeRepository_presult {
 public:


  virtual ~Hawk_removeRepository_presult() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_removeRepository_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_updateRepositoryCredentials_args {
 public:

  Hawk_updateRepositoryCredentials_args(const Hawk_updateRepositoryCredentials_args&);
  Hawk_updateRepositoryCredentials_args& operator=(const Hawk_updateRepositoryCredentials_args&);
  Hawk_updateRepositoryCredentials_args() : name(), uri() {
  }

  virtual ~Hawk_updateRepositoryCredentials_args() noexcept;
  std::string name;
  std::string uri;
  Credentials cred;

  void __set_name(const std::string& val);

  void __set_uri(const std::string& val);

  void __set_cred(const Credentials& val);

  bool operator == (const Hawk_updateRepositoryCredentials_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(uri == rhs.uri))
      return false;
    if (!(cred == rhs.cred))
      return false;
    return true;
  }
  bool operator != (const Hawk_updateRepositoryCredentials_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_updateRepositoryCredentials_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_updateRepositoryCredentials_pargs {
 public:


  virtual ~Hawk_updateRepositoryCredentials_pargs() noexcept;
  const std::string* name;
  const std::string* uri;
  const Credentials* cred;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_updateRepositoryCredentials_result__isset {
  _Hawk_updateRepositoryCredentials_result__isset() : err1(false), err2(false) {}
  bool err1 :1;
  bool err2 :1;
} _Hawk_updateRepositoryCredentials_result__isset;

class Hawk_updateRepositoryCredentials_result {
 public:

  Hawk_updateRepositoryCredentials_result(const Hawk_updateRepositoryCredentials_result&);
  Hawk_updateRepositoryCredentials_result& operator=(const Hawk_updateRepositoryCredentials_result&);
  Hawk_updateRepositoryCredentials_result() {
  }

  virtual ~Hawk_updateRepositoryCredentials_result() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_updateRepositoryCredentials_result__isset __isset;

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_updateRepositoryCredentials_result & rhs) const
  {
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_updateRepositoryCredentials_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_updateRepositoryCredentials_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_updateRepositoryCredentials_presult__isset {
  _Hawk_updateRepositoryCredentials_presult__isset() : err1(false), err2(false) {}
  bool err1 :1;
  bool err2 :1;
} _Hawk_updateRepositoryCredentials_presult__isset;

class Hawk_updateRepositoryCredentials_presult {
 public:


  virtual ~Hawk_updateRepositoryCredentials_presult() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_updateRepositoryCredentials_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_listRepositories_args {
 public:

  Hawk_listRepositories_args(const Hawk_listRepositories_args&);
  Hawk_listRepositories_args& operator=(const Hawk_listRepositories_args&);
  Hawk_listRepositories_args() : name() {
  }

  virtual ~Hawk_listRepositories_args() noexcept;
  std::string name;

  void __set_name(const std::string& val);

  bool operator == (const Hawk_listRepositories_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    return true;
  }
  bool operator != (const Hawk_listRepositories_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listRepositories_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_listRepositories_pargs {
 public:


  virtual ~Hawk_listRepositories_pargs() noexcept;
  const std::string* name;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listRepositories_result__isset {
  _Hawk_listRepositories_result__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_listRepositories_result__isset;

class Hawk_listRepositories_result {
 public:

  Hawk_listRepositories_result(const Hawk_listRepositories_result&);
  Hawk_listRepositories_result& operator=(const Hawk_listRepositories_result&);
  Hawk_listRepositories_result() {
  }

  virtual ~Hawk_listRepositories_result() noexcept;
  std::vector<Repository>  success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_listRepositories_result__isset __isset;

  void __set_success(const std::vector<Repository> & val);

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_listRepositories_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_listRepositories_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listRepositories_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listRepositories_presult__isset {
  _Hawk_listRepositories_presult__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_listRepositories_presult__isset;

class Hawk_listRepositories_presult {
 public:


  virtual ~Hawk_listRepositories_presult() noexcept;
  std::vector<Repository> * success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_listRepositories_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_listRepositoryTypes_args {
 public:

  Hawk_listRepositoryTypes_args(const Hawk_listRepositoryTypes_args&);
  Hawk_listRepositoryTypes_args& operator=(const Hawk_listRepositoryTypes_args&);
  Hawk_listRepositoryTypes_args() {
  }

  virtual ~Hawk_listRepositoryTypes_args() noexcept;

  bool operator == (const Hawk_listRepositoryTypes_args & /* rhs */) const
  {
    return true;
  }
  bool operator != (const Hawk_listRepositoryTypes_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listRepositoryTypes_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_listRepositoryTypes_pargs {
 public:


  virtual ~Hawk_listRepositoryTypes_pargs() noexcept;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listRepositoryTypes_result__isset {
  _Hawk_listRepositoryTypes_result__isset() : success(false) {}
  bool success :1;
} _Hawk_listRepositoryTypes_result__isset;

class Hawk_listRepositoryTypes_result {
 public:

  Hawk_listRepositoryTypes_result(const Hawk_listRepositoryTypes_result&);
  Hawk_listRepositoryTypes_result& operator=(const Hawk_listRepositoryTypes_result&);
  Hawk_listRepositoryTypes_result() {
  }

  virtual ~Hawk_listRepositoryTypes_result() noexcept;
  std::vector<std::string>  success;

  _Hawk_listRepositoryTypes_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  bool operator == (const Hawk_listRepositoryTypes_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const Hawk_listRepositoryTypes_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listRepositoryTypes_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listRepositoryTypes_presult__isset {
  _Hawk_listRepositoryTypes_presult__isset() : success(false) {}
  bool success :1;
} _Hawk_listRepositoryTypes_presult__isset;

class Hawk_listRepositoryTypes_presult {
 public:


  virtual ~Hawk_listRepositoryTypes_presult() noexcept;
  std::vector<std::string> * success;

  _Hawk_listRepositoryTypes_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_listFiles_args {
 public:

  Hawk_listFiles_args(const Hawk_listFiles_args&);
  Hawk_listFiles_args& operator=(const Hawk_listFiles_args&);
  Hawk_listFiles_args() : name() {
  }

  virtual ~Hawk_listFiles_args() noexcept;
  std::string name;
  std::vector<std::string>  repository;
  std::vector<std::string>  filePatterns;

  void __set_name(const std::string& val);

  void __set_repository(const std::vector<std::string> & val);

  void __set_filePatterns(const std::vector<std::string> & val);

  bool operator == (const Hawk_listFiles_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(repository == rhs.repository))
      return false;
    if (!(filePatterns == rhs.filePatterns))
      return false;
    return true;
  }
  bool operator != (const Hawk_listFiles_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listFiles_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_listFiles_pargs {
 public:


  virtual ~Hawk_listFiles_pargs() noexcept;
  const std::string* name;
  const std::vector<std::string> * repository;
  const std::vector<std::string> * filePatterns;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listFiles_result__isset {
  _Hawk_listFiles_result__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_listFiles_result__isset;

class Hawk_listFiles_result {
 public:

  Hawk_listFiles_result(const Hawk_listFiles_result&);
  Hawk_listFiles_result& operator=(const Hawk_listFiles_result&);
  Hawk_listFiles_result() {
  }

  virtual ~Hawk_listFiles_result() noexcept;
  std::vector<std::string>  success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_listFiles_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_listFiles_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_listFiles_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listFiles_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listFiles_presult__isset {
  _Hawk_listFiles_presult__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_listFiles_presult__isset;

class Hawk_listFiles_presult {
 public:


  virtual ~Hawk_listFiles_presult() noexcept;
  std::vector<std::string> * success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_listFiles_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_configurePolling_args {
 public:

  Hawk_configurePolling_args(const Hawk_configurePolling_args&);
  Hawk_configurePolling_args& operator=(const Hawk_configurePolling_args&);
  Hawk_configurePolling_args() : name(), base(0), max(0) {
  }

  virtual ~Hawk_configurePolling_args() noexcept;
  std::string name;
  int32_t base;
  int32_t max;

  void __set_name(const std::string& val);

  void __set_base(const int32_t val);

  void __set_max(const int32_t val);

  bool operator == (const Hawk_configurePolling_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(base == rhs.base))
      return false;
    if (!(max == rhs.max))
      return false;
    return true;
  }
  bool operator != (const Hawk_configurePolling_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_configurePolling_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_configurePolling_pargs {
 public:


  virtual ~Hawk_configurePolling_pargs() noexcept;
  const std::string* name;
  const int32_t* base;
  const int32_t* max;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_configurePolling_result__isset {
  _Hawk_configurePolling_result__isset() : err1(false), err2(false), err3(false) {}
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
} _Hawk_configurePolling_result__isset;

class Hawk_configurePolling_result {
 public:

  Hawk_configurePolling_result(const Hawk_configurePolling_result&);
  Hawk_configurePolling_result& operator=(const Hawk_configurePolling_result&);
  Hawk_configurePolling_result() {
  }

  virtual ~Hawk_configurePolling_result() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  InvalidPollingConfiguration err3;

  _Hawk_configurePolling_result__isset __isset;

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  void __set_err3(const InvalidPollingConfiguration& val);

  bool operator == (const Hawk_configurePolling_result & rhs) const
  {
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    if (!(err3 == rhs.err3))
      return false;
    return true;
  }
  bool operator != (const Hawk_configurePolling_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_configurePolling_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_configurePolling_presult__isset {
  _Hawk_configurePolling_presult__isset() : err1(false), err2(false), err3(false) {}
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
} _Hawk_configurePolling_presult__isset;

class Hawk_configurePolling_presult {
 public:


  virtual ~Hawk_configurePolling_presult() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  InvalidPollingConfiguration err3;

  _Hawk_configurePolling_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_addDerivedAttribute_args {
 public:

  Hawk_addDerivedAttribute_args(const Hawk_addDerivedAttribute_args&);
  Hawk_addDerivedAttribute_args& operator=(const Hawk_addDerivedAttribute_args&);
  Hawk_addDerivedAttribute_args() : name() {
  }

  virtual ~Hawk_addDerivedAttribute_args() noexcept;
  std::string name;
  DerivedAttributeSpec spec;

  void __set_name(const std::string& val);

  void __set_spec(const DerivedAttributeSpec& val);

  bool operator == (const Hawk_addDerivedAttribute_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(spec == rhs.spec))
      return false;
    return true;
  }
  bool operator != (const Hawk_addDerivedAttribute_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_addDerivedAttribute_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_addDerivedAttribute_pargs {
 public:


  virtual ~Hawk_addDerivedAttribute_pargs() noexcept;
  const std::string* name;
  const DerivedAttributeSpec* spec;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_addDerivedAttribute_result__isset {
  _Hawk_addDerivedAttribute_result__isset() : err1(false), err2(false), err3(false) {}
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
} _Hawk_addDerivedAttribute_result__isset;

class Hawk_addDerivedAttribute_result {
 public:

  Hawk_addDerivedAttribute_result(const Hawk_addDerivedAttribute_result&);
  Hawk_addDerivedAttribute_result& operator=(const Hawk_addDerivedAttribute_result&);
  Hawk_addDerivedAttribute_result() {
  }

  virtual ~Hawk_addDerivedAttribute_result() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  InvalidDerivedAttributeSpec err3;

  _Hawk_addDerivedAttribute_result__isset __isset;

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  void __set_err3(const InvalidDerivedAttributeSpec& val);

  bool operator == (const Hawk_addDerivedAttribute_result & rhs) const
  {
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    if (!(err3 == rhs.err3))
      return false;
    return true;
  }
  bool operator != (const Hawk_addDerivedAttribute_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_addDerivedAttribute_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_addDerivedAttribute_presult__isset {
  _Hawk_addDerivedAttribute_presult__isset() : err1(false), err2(false), err3(false) {}
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
} _Hawk_addDerivedAttribute_presult__isset;

class Hawk_addDerivedAttribute_presult {
 public:


  virtual ~Hawk_addDerivedAttribute_presult() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  InvalidDerivedAttributeSpec err3;

  _Hawk_addDerivedAttribute_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_removeDerivedAttribute_args {
 public:

  Hawk_removeDerivedAttribute_args(const Hawk_removeDerivedAttribute_args&);
  Hawk_removeDerivedAttribute_args& operator=(const Hawk_removeDerivedAttribute_args&);
  Hawk_removeDerivedAttribute_args() : name() {
  }

  virtual ~Hawk_removeDerivedAttribute_args() noexcept;
  std::string name;
  DerivedAttributeSpec spec;

  void __set_name(const std::string& val);

  void __set_spec(const DerivedAttributeSpec& val);

  bool operator == (const Hawk_removeDerivedAttribute_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(spec == rhs.spec))
      return false;
    return true;
  }
  bool operator != (const Hawk_removeDerivedAttribute_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_removeDerivedAttribute_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_removeDerivedAttribute_pargs {
 public:


  virtual ~Hawk_removeDerivedAttribute_pargs() noexcept;
  const std::string* name;
  const DerivedAttributeSpec* spec;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_removeDerivedAttribute_result__isset {
  _Hawk_removeDerivedAttribute_result__isset() : err1(false), err2(false) {}
  bool err1 :1;
  bool err2 :1;
} _Hawk_removeDerivedAttribute_result__isset;

class Hawk_removeDerivedAttribute_result {
 public:

  Hawk_removeDerivedAttribute_result(const Hawk_removeDerivedAttribute_result&);
  Hawk_removeDerivedAttribute_result& operator=(const Hawk_removeDerivedAttribute_result&);
  Hawk_removeDerivedAttribute_result() {
  }

  virtual ~Hawk_removeDerivedAttribute_result() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_removeDerivedAttribute_result__isset __isset;

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_removeDerivedAttribute_result & rhs) const
  {
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_removeDerivedAttribute_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_removeDerivedAttribute_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_removeDerivedAttribute_presult__isset {
  _Hawk_removeDerivedAttribute_presult__isset() : err1(false), err2(false) {}
  bool err1 :1;
  bool err2 :1;
} _Hawk_removeDerivedAttribute_presult__isset;

class Hawk_removeDerivedAttribute_presult {
 public:


  virtual ~Hawk_removeDerivedAttribute_presult() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_removeDerivedAttribute_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_listDerivedAttributes_args {
 public:

  Hawk_listDerivedAttributes_args(const Hawk_listDerivedAttributes_args&);
  Hawk_listDerivedAttributes_args& operator=(const Hawk_listDerivedAttributes_args&);
  Hawk_listDerivedAttributes_args() : name() {
  }

  virtual ~Hawk_listDerivedAttributes_args() noexcept;
  std::string name;

  void __set_name(const std::string& val);

  bool operator == (const Hawk_listDerivedAttributes_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    return true;
  }
  bool operator != (const Hawk_listDerivedAttributes_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listDerivedAttributes_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_listDerivedAttributes_pargs {
 public:


  virtual ~Hawk_listDerivedAttributes_pargs() noexcept;
  const std::string* name;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listDerivedAttributes_result__isset {
  _Hawk_listDerivedAttributes_result__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_listDerivedAttributes_result__isset;

class Hawk_listDerivedAttributes_result {
 public:

  Hawk_listDerivedAttributes_result(const Hawk_listDerivedAttributes_result&);
  Hawk_listDerivedAttributes_result& operator=(const Hawk_listDerivedAttributes_result&);
  Hawk_listDerivedAttributes_result() {
  }

  virtual ~Hawk_listDerivedAttributes_result() noexcept;
  std::vector<DerivedAttributeSpec>  success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_listDerivedAttributes_result__isset __isset;

  void __set_success(const std::vector<DerivedAttributeSpec> & val);

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_listDerivedAttributes_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_listDerivedAttributes_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listDerivedAttributes_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listDerivedAttributes_presult__isset {
  _Hawk_listDerivedAttributes_presult__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_listDerivedAttributes_presult__isset;

class Hawk_listDerivedAttributes_presult {
 public:


  virtual ~Hawk_listDerivedAttributes_presult() noexcept;
  std::vector<DerivedAttributeSpec> * success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_listDerivedAttributes_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_addIndexedAttribute_args {
 public:

  Hawk_addIndexedAttribute_args(const Hawk_addIndexedAttribute_args&);
  Hawk_addIndexedAttribute_args& operator=(const Hawk_addIndexedAttribute_args&);
  Hawk_addIndexedAttribute_args() : name() {
  }

  virtual ~Hawk_addIndexedAttribute_args() noexcept;
  std::string name;
  IndexedAttributeSpec spec;

  void __set_name(const std::string& val);

  void __set_spec(const IndexedAttributeSpec& val);

  bool operator == (const Hawk_addIndexedAttribute_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(spec == rhs.spec))
      return false;
    return true;
  }
  bool operator != (const Hawk_addIndexedAttribute_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_addIndexedAttribute_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_addIndexedAttribute_pargs {
 public:


  virtual ~Hawk_addIndexedAttribute_pargs() noexcept;
  const std::string* name;
  const IndexedAttributeSpec* spec;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_addIndexedAttribute_result__isset {
  _Hawk_addIndexedAttribute_result__isset() : err1(false), err2(false), err3(false) {}
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
} _Hawk_addIndexedAttribute_result__isset;

class Hawk_addIndexedAttribute_result {
 public:

  Hawk_addIndexedAttribute_result(const Hawk_addIndexedAttribute_result&);
  Hawk_addIndexedAttribute_result& operator=(const Hawk_addIndexedAttribute_result&);
  Hawk_addIndexedAttribute_result() {
  }

  virtual ~Hawk_addIndexedAttribute_result() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  InvalidIndexedAttributeSpec err3;

  _Hawk_addIndexedAttribute_result__isset __isset;

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  void __set_err3(const InvalidIndexedAttributeSpec& val);

  bool operator == (const Hawk_addIndexedAttribute_result & rhs) const
  {
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    if (!(err3 == rhs.err3))
      return false;
    return true;
  }
  bool operator != (const Hawk_addIndexedAttribute_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_addIndexedAttribute_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_addIndexedAttribute_presult__isset {
  _Hawk_addIndexedAttribute_presult__isset() : err1(false), err2(false), err3(false) {}
  bool err1 :1;
  bool err2 :1;
  bool err3 :1;
} _Hawk_addIndexedAttribute_presult__isset;

class Hawk_addIndexedAttribute_presult {
 public:


  virtual ~Hawk_addIndexedAttribute_presult() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;
  InvalidIndexedAttributeSpec err3;

  _Hawk_addIndexedAttribute_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_removeIndexedAttribute_args {
 public:

  Hawk_removeIndexedAttribute_args(const Hawk_removeIndexedAttribute_args&);
  Hawk_removeIndexedAttribute_args& operator=(const Hawk_removeIndexedAttribute_args&);
  Hawk_removeIndexedAttribute_args() : name() {
  }

  virtual ~Hawk_removeIndexedAttribute_args() noexcept;
  std::string name;
  IndexedAttributeSpec spec;

  void __set_name(const std::string& val);

  void __set_spec(const IndexedAttributeSpec& val);

  bool operator == (const Hawk_removeIndexedAttribute_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(spec == rhs.spec))
      return false;
    return true;
  }
  bool operator != (const Hawk_removeIndexedAttribute_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_removeIndexedAttribute_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_removeIndexedAttribute_pargs {
 public:


  virtual ~Hawk_removeIndexedAttribute_pargs() noexcept;
  const std::string* name;
  const IndexedAttributeSpec* spec;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_removeIndexedAttribute_result__isset {
  _Hawk_removeIndexedAttribute_result__isset() : err1(false), err2(false) {}
  bool err1 :1;
  bool err2 :1;
} _Hawk_removeIndexedAttribute_result__isset;

class Hawk_removeIndexedAttribute_result {
 public:

  Hawk_removeIndexedAttribute_result(const Hawk_removeIndexedAttribute_result&);
  Hawk_removeIndexedAttribute_result& operator=(const Hawk_removeIndexedAttribute_result&);
  Hawk_removeIndexedAttribute_result() {
  }

  virtual ~Hawk_removeIndexedAttribute_result() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_removeIndexedAttribute_result__isset __isset;

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_removeIndexedAttribute_result & rhs) const
  {
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_removeIndexedAttribute_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_removeIndexedAttribute_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_removeIndexedAttribute_presult__isset {
  _Hawk_removeIndexedAttribute_presult__isset() : err1(false), err2(false) {}
  bool err1 :1;
  bool err2 :1;
} _Hawk_removeIndexedAttribute_presult__isset;

class Hawk_removeIndexedAttribute_presult {
 public:


  virtual ~Hawk_removeIndexedAttribute_presult() noexcept;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_removeIndexedAttribute_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_listIndexedAttributes_args {
 public:

  Hawk_listIndexedAttributes_args(const Hawk_listIndexedAttributes_args&);
  Hawk_listIndexedAttributes_args& operator=(const Hawk_listIndexedAttributes_args&);
  Hawk_listIndexedAttributes_args() : name() {
  }

  virtual ~Hawk_listIndexedAttributes_args() noexcept;
  std::string name;

  void __set_name(const std::string& val);

  bool operator == (const Hawk_listIndexedAttributes_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    return true;
  }
  bool operator != (const Hawk_listIndexedAttributes_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listIndexedAttributes_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_listIndexedAttributes_pargs {
 public:


  virtual ~Hawk_listIndexedAttributes_pargs() noexcept;
  const std::string* name;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listIndexedAttributes_result__isset {
  _Hawk_listIndexedAttributes_result__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_listIndexedAttributes_result__isset;

class Hawk_listIndexedAttributes_result {
 public:

  Hawk_listIndexedAttributes_result(const Hawk_listIndexedAttributes_result&);
  Hawk_listIndexedAttributes_result& operator=(const Hawk_listIndexedAttributes_result&);
  Hawk_listIndexedAttributes_result() {
  }

  virtual ~Hawk_listIndexedAttributes_result() noexcept;
  std::vector<IndexedAttributeSpec>  success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_listIndexedAttributes_result__isset __isset;

  void __set_success(const std::vector<IndexedAttributeSpec> & val);

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_listIndexedAttributes_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_listIndexedAttributes_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_listIndexedAttributes_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_listIndexedAttributes_presult__isset {
  _Hawk_listIndexedAttributes_presult__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_listIndexedAttributes_presult__isset;

class Hawk_listIndexedAttributes_presult {
 public:


  virtual ~Hawk_listIndexedAttributes_presult() noexcept;
  std::vector<IndexedAttributeSpec> * success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_listIndexedAttributes_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_getModel_args {
 public:

  Hawk_getModel_args(const Hawk_getModel_args&);
  Hawk_getModel_args& operator=(const Hawk_getModel_args&);
  Hawk_getModel_args() : name() {
  }

  virtual ~Hawk_getModel_args() noexcept;
  std::string name;
  HawkQueryOptions options;

  void __set_name(const std::string& val);

  void __set_options(const HawkQueryOptions& val);

  bool operator == (const Hawk_getModel_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(options == rhs.options))
      return false;
    return true;
  }
  bool operator != (const Hawk_getModel_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_getModel_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_getModel_pargs {
 public:


  virtual ~Hawk_getModel_pargs() noexcept;
  const std::string* name;
  const HawkQueryOptions* options;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_getModel_result__isset {
  _Hawk_getModel_result__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_getModel_result__isset;

class Hawk_getModel_result {
 public:

  Hawk_getModel_result(const Hawk_getModel_result&);
  Hawk_getModel_result& operator=(const Hawk_getModel_result&);
  Hawk_getModel_result() {
  }

  virtual ~Hawk_getModel_result() noexcept;
  std::vector<ModelElement>  success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_getModel_result__isset __isset;

  void __set_success(const std::vector<ModelElement> & val);

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_getModel_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_getModel_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_getModel_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_getModel_presult__isset {
  _Hawk_getModel_presult__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_getModel_presult__isset;

class Hawk_getModel_presult {
 public:


  virtual ~Hawk_getModel_presult() noexcept;
  std::vector<ModelElement> * success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_getModel_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_getRootElements_args {
 public:

  Hawk_getRootElements_args(const Hawk_getRootElements_args&);
  Hawk_getRootElements_args& operator=(const Hawk_getRootElements_args&);
  Hawk_getRootElements_args() : name() {
  }

  virtual ~Hawk_getRootElements_args() noexcept;
  std::string name;
  HawkQueryOptions options;

  void __set_name(const std::string& val);

  void __set_options(const HawkQueryOptions& val);

  bool operator == (const Hawk_getRootElements_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(options == rhs.options))
      return false;
    return true;
  }
  bool operator != (const Hawk_getRootElements_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_getRootElements_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_getRootElements_pargs {
 public:


  virtual ~Hawk_getRootElements_pargs() noexcept;
  const std::string* name;
  const HawkQueryOptions* options;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_getRootElements_result__isset {
  _Hawk_getRootElements_result__isset() : success(false) {}
  bool success :1;
} _Hawk_getRootElements_result__isset;

class Hawk_getRootElements_result {
 public:

  Hawk_getRootElements_result(const Hawk_getRootElements_result&);
  Hawk_getRootElements_result& operator=(const Hawk_getRootElements_result&);
  Hawk_getRootElements_result() {
  }

  virtual ~Hawk_getRootElements_result() noexcept;
  std::vector<ModelElement>  success;

  _Hawk_getRootElements_result__isset __isset;

  void __set_success(const std::vector<ModelElement> & val);

  bool operator == (const Hawk_getRootElements_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const Hawk_getRootElements_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_getRootElements_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_getRootElements_presult__isset {
  _Hawk_getRootElements_presult__isset() : success(false) {}
  bool success :1;
} _Hawk_getRootElements_presult__isset;

class Hawk_getRootElements_presult {
 public:


  virtual ~Hawk_getRootElements_presult() noexcept;
  std::vector<ModelElement> * success;

  _Hawk_getRootElements_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_watchStateChanges_args {
 public:

  Hawk_watchStateChanges_args(const Hawk_watchStateChanges_args&);
  Hawk_watchStateChanges_args& operator=(const Hawk_watchStateChanges_args&);
  Hawk_watchStateChanges_args() : name() {
  }

  virtual ~Hawk_watchStateChanges_args() noexcept;
  std::string name;

  void __set_name(const std::string& val);

  bool operator == (const Hawk_watchStateChanges_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    return true;
  }
  bool operator != (const Hawk_watchStateChanges_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_watchStateChanges_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_watchStateChanges_pargs {
 public:


  virtual ~Hawk_watchStateChanges_pargs() noexcept;
  const std::string* name;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_watchStateChanges_result__isset {
  _Hawk_watchStateChanges_result__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_watchStateChanges_result__isset;

class Hawk_watchStateChanges_result {
 public:

  Hawk_watchStateChanges_result(const Hawk_watchStateChanges_result&);
  Hawk_watchStateChanges_result& operator=(const Hawk_watchStateChanges_result&);
  Hawk_watchStateChanges_result() {
  }

  virtual ~Hawk_watchStateChanges_result() noexcept;
  Subscription success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_watchStateChanges_result__isset __isset;

  void __set_success(const Subscription& val);

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_watchStateChanges_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_watchStateChanges_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_watchStateChanges_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_watchStateChanges_presult__isset {
  _Hawk_watchStateChanges_presult__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_watchStateChanges_presult__isset;

class Hawk_watchStateChanges_presult {
 public:


  virtual ~Hawk_watchStateChanges_presult() noexcept;
  Subscription* success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_watchStateChanges_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class Hawk_watchModelChanges_args {
 public:

  Hawk_watchModelChanges_args(const Hawk_watchModelChanges_args&);
  Hawk_watchModelChanges_args& operator=(const Hawk_watchModelChanges_args&);
  Hawk_watchModelChanges_args() : name(), repositoryUri(), clientID(), durableEvents((SubscriptionDurability::type)0) {
  }

  virtual ~Hawk_watchModelChanges_args() noexcept;
  std::string name;
  std::string repositoryUri;
  std::vector<std::string>  filePath;
  std::string clientID;
  SubscriptionDurability::type durableEvents;

  void __set_name(const std::string& val);

  void __set_repositoryUri(const std::string& val);

  void __set_filePath(const std::vector<std::string> & val);

  void __set_clientID(const std::string& val);

  void __set_durableEvents(const SubscriptionDurability::type val);

  bool operator == (const Hawk_watchModelChanges_args & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(repositoryUri == rhs.repositoryUri))
      return false;
    if (!(filePath == rhs.filePath))
      return false;
    if (!(clientID == rhs.clientID))
      return false;
    if (!(durableEvents == rhs.durableEvents))
      return false;
    return true;
  }
  bool operator != (const Hawk_watchModelChanges_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_watchModelChanges_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class Hawk_watchModelChanges_pargs {
 public:


  virtual ~Hawk_watchModelChanges_pargs() noexcept;
  const std::string* name;
  const std::string* repositoryUri;
  const std::vector<std::string> * filePath;
  const std::string* clientID;
  const SubscriptionDurability::type* durableEvents;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_watchModelChanges_result__isset {
  _Hawk_watchModelChanges_result__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_watchModelChanges_result__isset;

class Hawk_watchModelChanges_result {
 public:

  Hawk_watchModelChanges_result(const Hawk_watchModelChanges_result&);
  Hawk_watchModelChanges_result& operator=(const Hawk_watchModelChanges_result&);
  Hawk_watchModelChanges_result() {
  }

  virtual ~Hawk_watchModelChanges_result() noexcept;
  Subscription success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_watchModelChanges_result__isset __isset;

  void __set_success(const Subscription& val);

  void __set_err1(const HawkInstanceNotFound& val);

  void __set_err2(const HawkInstanceNotRunning& val);

  bool operator == (const Hawk_watchModelChanges_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(err1 == rhs.err1))
      return false;
    if (!(err2 == rhs.err2))
      return false;
    return true;
  }
  bool operator != (const Hawk_watchModelChanges_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Hawk_watchModelChanges_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _Hawk_watchModelChanges_presult__isset {
  _Hawk_watchModelChanges_presult__isset() : success(false), err1(false), err2(false) {}
  bool success :1;
  bool err1 :1;
  bool err2 :1;
} _Hawk_watchModelChanges_presult__isset;

class Hawk_watchModelChanges_presult {
 public:


  virtual ~Hawk_watchModelChanges_presult() noexcept;
  Subscription* success;
  HawkInstanceNotFound err1;
  HawkInstanceNotRunning err2;

  _Hawk_watchModelChanges_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

class HawkClient : virtual public HawkIf {
 public:
  HawkClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
    setProtocol(prot);
  }
  HawkClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
    setProtocol(iprot,oprot);
  }
 private:
  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
  setProtocol(prot,prot);
  }
  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
    piprot_=iprot;
    poprot_=oprot;
    iprot_ = iprot.get();
    oprot_ = oprot.get();
  }
 public:
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
    return piprot_;
  }
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
    return poprot_;
  }
  void createInstance(const std::string& name, const std::string& backend, const int32_t minimumDelayMillis, const int32_t maximumDelayMillis, const std::vector<std::string> & enabledPlugins, const std::string& indexFactory);
  void send_createInstance(const std::string& name, const std::string& backend, const int32_t minimumDelayMillis, const int32_t maximumDelayMillis, const std::vector<std::string> & enabledPlugins, const std::string& indexFactory);
  void recv_createInstance();
  void listBackends(std::vector<std::string> & _return);
  void send_listBackends();
  void recv_listBackends(std::vector<std::string> & _return);
  void listPlugins(std::vector<std::string> & _return);
  void send_listPlugins();
  void recv_listPlugins(std::vector<std::string> & _return);
  void listPluginDetails(std::vector<HawkPlugin> & _return);
  void send_listPluginDetails();
  void recv_listPluginDetails(std::vector<HawkPlugin> & _return);
  void listInstances(std::vector<HawkInstance> & _return);
  void send_listInstances();
  void recv_listInstances(std::vector<HawkInstance> & _return);
  void removeInstance(const std::string& name);
  void send_removeInstance(const std::string& name);
  void recv_removeInstance();
  void startInstance(const std::string& name);
  void send_startInstance(const std::string& name);
  void recv_startInstance();
  void stopInstance(const std::string& name);
  void send_stopInstance(const std::string& name);
  void recv_stopInstance();
  void syncInstance(const std::string& name, const bool blockUntilDone);
  void send_syncInstance(const std::string& name, const bool blockUntilDone);
  void recv_syncInstance();
  void registerMetamodels(const std::string& name, const std::vector<File> & metamodel);
  void send_registerMetamodels(const std::string& name, const std::vector<File> & metamodel);
  void recv_registerMetamodels();
  void unregisterMetamodels(const std::string& name, const std::vector<std::string> & metamodel);
  void send_unregisterMetamodels(const std::string& name, const std::vector<std::string> & metamodel);
  void recv_unregisterMetamodels();
  void listMetamodels(std::vector<std::string> & _return, const std::string& name);
  void send_listMetamodels(const std::string& name);
  void recv_listMetamodels(std::vector<std::string> & _return);
  void listTypeNames(std::vector<std::string> & _return, const std::string& hawkInstanceName, const std::string& metamodelURI);
  void send_listTypeNames(const std::string& hawkInstanceName, const std::string& metamodelURI);
  void recv_listTypeNames(std::vector<std::string> & _return);
  void listAttributeNames(std::vector<std::string> & _return, const std::string& hawkInstanceName, const std::string& metamodelURI, const std::string& typeName);
  void send_listAttributeNames(const std::string& hawkInstanceName, const std::string& metamodelURI, const std::string& typeName);
  void recv_listAttributeNames(std::vector<std::string> & _return);
  void listMetamodelParsers(std::vector<MetamodelParserDetails> & _return, const std::string& name);
  void send_listMetamodelParsers(const std::string& name);
  void recv_listMetamodelParsers(std::vector<MetamodelParserDetails> & _return);
  void listQueryLanguages(std::vector<std::string> & _return, const std::string& name);
  void send_listQueryLanguages(const std::string& name);
  void recv_listQueryLanguages(std::vector<std::string> & _return);
  void query(QueryResult& _return, const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options);
  void send_query(const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options);
  void recv_query(QueryResult& _return);
  void timedQuery(QueryReport& _return, const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options);
  void send_timedQuery(const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options);
  void recv_timedQuery(QueryReport& _return);
  void resolveProxies(std::vector<ModelElement> & _return, const std::string& name, const std::vector<std::string> & ids, const HawkQueryOptions& options);
  void send_resolveProxies(const std::string& name, const std::vector<std::string> & ids, const HawkQueryOptions& options);
  void recv_resolveProxies(std::vector<ModelElement> & _return);
  void asyncQuery(std::string& _return, const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options);
  void send_asyncQuery(const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options);
  void recv_asyncQuery(std::string& _return);
  void cancelAsyncQuery(const std::string& queryID);
  void send_cancelAsyncQuery(const std::string& queryID);
  void recv_cancelAsyncQuery();
  void fetchAsyncQueryResults(QueryReport& _return, const std::string& queryID);
  void send_fetchAsyncQueryResults(const std::string& queryID);
  void recv_fetchAsyncQueryResults(QueryReport& _return);
  void addRepository(const std::string& name, const Repository& repo, const Credentials& credentials);
  void send_addRepository(const std::string& name, const Repository& repo, const Credentials& credentials);
  void recv_addRepository();
  bool isFrozen(const std::string& name, const std::string& uri);
  void send_isFrozen(const std::string& name, const std::string& uri);
  bool recv_isFrozen();
  void setFrozen(const std::string& name, const std::string& uri, const bool isFrozen);
  void send_setFrozen(const std::string& name, const std::string& uri, const bool isFrozen);
  void recv_setFrozen();
  void removeRepository(const std::string& name, const std::string& uri);
  void send_removeRepository(const std::string& name, const std::string& uri);
  void recv_removeRepository();
  void updateRepositoryCredentials(const std::string& name, const std::string& uri, const Credentials& cred);
  void send_updateRepositoryCredentials(const std::string& name, const std::string& uri, const Credentials& cred);
  void recv_updateRepositoryCredentials();
  void listRepositories(std::vector<Repository> & _return, const std::string& name);
  void send_listRepositories(const std::string& name);
  void recv_listRepositories(std::vector<Repository> & _return);
  void listRepositoryTypes(std::vector<std::string> & _return);
  void send_listRepositoryTypes();
  void recv_listRepositoryTypes(std::vector<std::string> & _return);
  void listFiles(std::vector<std::string> & _return, const std::string& name, const std::vector<std::string> & repository, const std::vector<std::string> & filePatterns);
  void send_listFiles(const std::string& name, const std::vector<std::string> & repository, const std::vector<std::string> & filePatterns);
  void recv_listFiles(std::vector<std::string> & _return);
  void configurePolling(const std::string& name, const int32_t base, const int32_t max);
  void send_configurePolling(const std::string& name, const int32_t base, const int32_t max);
  void recv_configurePolling();
  void addDerivedAttribute(const std::string& name, const DerivedAttributeSpec& spec);
  void send_addDerivedAttribute(const std::string& name, const DerivedAttributeSpec& spec);
  void recv_addDerivedAttribute();
  void removeDerivedAttribute(const std::string& name, const DerivedAttributeSpec& spec);
  void send_removeDerivedAttribute(const std::string& name, const DerivedAttributeSpec& spec);
  void recv_removeDerivedAttribute();
  void listDerivedAttributes(std::vector<DerivedAttributeSpec> & _return, const std::string& name);
  void send_listDerivedAttributes(const std::string& name);
  void recv_listDerivedAttributes(std::vector<DerivedAttributeSpec> & _return);
  void addIndexedAttribute(const std::string& name, const IndexedAttributeSpec& spec);
  void send_addIndexedAttribute(const std::string& name, const IndexedAttributeSpec& spec);
  void recv_addIndexedAttribute();
  void removeIndexedAttribute(const std::string& name, const IndexedAttributeSpec& spec);
  void send_removeIndexedAttribute(const std::string& name, const IndexedAttributeSpec& spec);
  void recv_removeIndexedAttribute();
  void listIndexedAttributes(std::vector<IndexedAttributeSpec> & _return, const std::string& name);
  void send_listIndexedAttributes(const std::string& name);
  void recv_listIndexedAttributes(std::vector<IndexedAttributeSpec> & _return);
  void getModel(std::vector<ModelElement> & _return, const std::string& name, const HawkQueryOptions& options);
  void send_getModel(const std::string& name, const HawkQueryOptions& options);
  void recv_getModel(std::vector<ModelElement> & _return);
  void getRootElements(std::vector<ModelElement> & _return, const std::string& name, const HawkQueryOptions& options);
  void send_getRootElements(const std::string& name, const HawkQueryOptions& options);
  void recv_getRootElements(std::vector<ModelElement> & _return);
  void watchStateChanges(Subscription& _return, const std::string& name);
  void send_watchStateChanges(const std::string& name);
  void recv_watchStateChanges(Subscription& _return);
  void watchModelChanges(Subscription& _return, const std::string& name, const std::string& repositoryUri, const std::vector<std::string> & filePath, const std::string& clientID, const SubscriptionDurability::type durableEvents);
  void send_watchModelChanges(const std::string& name, const std::string& repositoryUri, const std::vector<std::string> & filePath, const std::string& clientID, const SubscriptionDurability::type durableEvents);
  void recv_watchModelChanges(Subscription& _return);
 protected:
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
  ::apache::thrift::protocol::TProtocol* iprot_;
  ::apache::thrift::protocol::TProtocol* oprot_;
};

class HawkProcessor : public ::apache::thrift::TDispatchProcessor {
 protected:
  ::std::shared_ptr<HawkIf> iface_;
  virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
 private:
  typedef  void (HawkProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
  typedef std::map<std::string, ProcessFunction> ProcessMap;
  ProcessMap processMap_;
  void process_createInstance(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_listBackends(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_listPlugins(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_listPluginDetails(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_listInstances(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_removeInstance(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_startInstance(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_stopInstance(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_syncInstance(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_registerMetamodels(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_unregisterMetamodels(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_listMetamodels(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_listTypeNames(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_listAttributeNames(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_listMetamodelParsers(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_listQueryLanguages(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_query(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_timedQuery(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_resolveProxies(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_asyncQuery(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_cancelAsyncQuery(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_fetchAsyncQueryResults(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_addRepository(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_isFrozen(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_setFrozen(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_removeRepository(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_updateRepositoryCredentials(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_listRepositories(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_listRepositoryTypes(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_listFiles(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_configurePolling(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_addDerivedAttribute(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_removeDerivedAttribute(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_listDerivedAttributes(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_addIndexedAttribute(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_removeIndexedAttribute(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_listIndexedAttributes(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_getModel(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_getRootElements(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_watchStateChanges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_watchModelChanges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
 public:
  HawkProcessor(::std::shared_ptr<HawkIf> iface) :
    iface_(iface) {
    processMap_["createInstance"] = &HawkProcessor::process_createInstance;
    processMap_["listBackends"] = &HawkProcessor::process_listBackends;
    processMap_["listPlugins"] = &HawkProcessor::process_listPlugins;
    processMap_["listPluginDetails"] = &HawkProcessor::process_listPluginDetails;
    processMap_["listInstances"] = &HawkProcessor::process_listInstances;
    processMap_["removeInstance"] = &HawkProcessor::process_removeInstance;
    processMap_["startInstance"] = &HawkProcessor::process_startInstance;
    processMap_["stopInstance"] = &HawkProcessor::process_stopInstance;
    processMap_["syncInstance"] = &HawkProcessor::process_syncInstance;
    processMap_["registerMetamodels"] = &HawkProcessor::process_registerMetamodels;
    processMap_["unregisterMetamodels"] = &HawkProcessor::process_unregisterMetamodels;
    processMap_["listMetamodels"] = &HawkProcessor::process_listMetamodels;
    processMap_["listTypeNames"] = &HawkProcessor::process_listTypeNames;
    processMap_["listAttributeNames"] = &HawkProcessor::process_listAttributeNames;
    processMap_["listMetamodelParsers"] = &HawkProcessor::process_listMetamodelParsers;
    processMap_["listQueryLanguages"] = &HawkProcessor::process_listQueryLanguages;
    processMap_["query"] = &HawkProcessor::process_query;
    processMap_["timedQuery"] = &HawkProcessor::process_timedQuery;
    processMap_["resolveProxies"] = &HawkProcessor::process_resolveProxies;
    processMap_["asyncQuery"] = &HawkProcessor::process_asyncQuery;
    processMap_["cancelAsyncQuery"] = &HawkProcessor::process_cancelAsyncQuery;
    processMap_["fetchAsyncQueryResults"] = &HawkProcessor::process_fetchAsyncQueryResults;
    processMap_["addRepository"] = &HawkProcessor::process_addRepository;
    processMap_["isFrozen"] = &HawkProcessor::process_isFrozen;
    processMap_["setFrozen"] = &HawkProcessor::process_setFrozen;
    processMap_["removeRepository"] = &HawkProcessor::process_removeRepository;
    processMap_["updateRepositoryCredentials"] = &HawkProcessor::process_updateRepositoryCredentials;
    processMap_["listRepositories"] = &HawkProcessor::process_listRepositories;
    processMap_["listRepositoryTypes"] = &HawkProcessor::process_listRepositoryTypes;
    processMap_["listFiles"] = &HawkProcessor::process_listFiles;
    processMap_["configurePolling"] = &HawkProcessor::process_configurePolling;
    processMap_["addDerivedAttribute"] = &HawkProcessor::process_addDerivedAttribute;
    processMap_["removeDerivedAttribute"] = &HawkProcessor::process_removeDerivedAttribute;
    processMap_["listDerivedAttributes"] = &HawkProcessor::process_listDerivedAttributes;
    processMap_["addIndexedAttribute"] = &HawkProcessor::process_addIndexedAttribute;
    processMap_["removeIndexedAttribute"] = &HawkProcessor::process_removeIndexedAttribute;
    processMap_["listIndexedAttributes"] = &HawkProcessor::process_listIndexedAttributes;
    processMap_["getModel"] = &HawkProcessor::process_getModel;
    processMap_["getRootElements"] = &HawkProcessor::process_getRootElements;
    processMap_["watchStateChanges"] = &HawkProcessor::process_watchStateChanges;
    processMap_["watchModelChanges"] = &HawkProcessor::process_watchModelChanges;
  }

  virtual ~HawkProcessor() {}
};

class HawkProcessorFactory : public ::apache::thrift::TProcessorFactory {
 public:
  HawkProcessorFactory(const ::std::shared_ptr< HawkIfFactory >& handlerFactory) :
      handlerFactory_(handlerFactory) {}

  ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);

 protected:
  ::std::shared_ptr< HawkIfFactory > handlerFactory_;
};

class HawkMultiface : virtual public HawkIf {
 public:
  HawkMultiface(std::vector<std::shared_ptr<HawkIf> >& ifaces) : ifaces_(ifaces) {
  }
  virtual ~HawkMultiface() {}
 protected:
  std::vector<std::shared_ptr<HawkIf> > ifaces_;
  HawkMultiface() {}
  void add(::std::shared_ptr<HawkIf> iface) {
    ifaces_.push_back(iface);
  }
 public:
  void createInstance(const std::string& name, const std::string& backend, const int32_t minimumDelayMillis, const int32_t maximumDelayMillis, const std::vector<std::string> & enabledPlugins, const std::string& indexFactory) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->createInstance(name, backend, minimumDelayMillis, maximumDelayMillis, enabledPlugins, indexFactory);
    }
    ifaces_[i]->createInstance(name, backend, minimumDelayMillis, maximumDelayMillis, enabledPlugins, indexFactory);
  }

  void listBackends(std::vector<std::string> & _return) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->listBackends(_return);
    }
    ifaces_[i]->listBackends(_return);
    return;
  }

  void listPlugins(std::vector<std::string> & _return) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->listPlugins(_return);
    }
    ifaces_[i]->listPlugins(_return);
    return;
  }

  void listPluginDetails(std::vector<HawkPlugin> & _return) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->listPluginDetails(_return);
    }
    ifaces_[i]->listPluginDetails(_return);
    return;
  }

  void listInstances(std::vector<HawkInstance> & _return) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->listInstances(_return);
    }
    ifaces_[i]->listInstances(_return);
    return;
  }

  void removeInstance(const std::string& name) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->removeInstance(name);
    }
    ifaces_[i]->removeInstance(name);
  }

  void startInstance(const std::string& name) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->startInstance(name);
    }
    ifaces_[i]->startInstance(name);
  }

  void stopInstance(const std::string& name) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->stopInstance(name);
    }
    ifaces_[i]->stopInstance(name);
  }

  void syncInstance(const std::string& name, const bool blockUntilDone) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->syncInstance(name, blockUntilDone);
    }
    ifaces_[i]->syncInstance(name, blockUntilDone);
  }

  void registerMetamodels(const std::string& name, const std::vector<File> & metamodel) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->registerMetamodels(name, metamodel);
    }
    ifaces_[i]->registerMetamodels(name, metamodel);
  }

  void unregisterMetamodels(const std::string& name, const std::vector<std::string> & metamodel) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->unregisterMetamodels(name, metamodel);
    }
    ifaces_[i]->unregisterMetamodels(name, metamodel);
  }

  void listMetamodels(std::vector<std::string> & _return, const std::string& name) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->listMetamodels(_return, name);
    }
    ifaces_[i]->listMetamodels(_return, name);
    return;
  }

  void listTypeNames(std::vector<std::string> & _return, const std::string& hawkInstanceName, const std::string& metamodelURI) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->listTypeNames(_return, hawkInstanceName, metamodelURI);
    }
    ifaces_[i]->listTypeNames(_return, hawkInstanceName, metamodelURI);
    return;
  }

  void listAttributeNames(std::vector<std::string> & _return, const std::string& hawkInstanceName, const std::string& metamodelURI, const std::string& typeName) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->listAttributeNames(_return, hawkInstanceName, metamodelURI, typeName);
    }
    ifaces_[i]->listAttributeNames(_return, hawkInstanceName, metamodelURI, typeName);
    return;
  }

  void listMetamodelParsers(std::vector<MetamodelParserDetails> & _return, const std::string& name) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->listMetamodelParsers(_return, name);
    }
    ifaces_[i]->listMetamodelParsers(_return, name);
    return;
  }

  void listQueryLanguages(std::vector<std::string> & _return, const std::string& name) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->listQueryLanguages(_return, name);
    }
    ifaces_[i]->listQueryLanguages(_return, name);
    return;
  }

  void query(QueryResult& _return, const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->query(_return, name, query, language, options);
    }
    ifaces_[i]->query(_return, name, query, language, options);
    return;
  }

  void timedQuery(QueryReport& _return, const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->timedQuery(_return, name, query, language, options);
    }
    ifaces_[i]->timedQuery(_return, name, query, language, options);
    return;
  }

  void resolveProxies(std::vector<ModelElement> & _return, const std::string& name, const std::vector<std::string> & ids, const HawkQueryOptions& options) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->resolveProxies(_return, name, ids, options);
    }
    ifaces_[i]->resolveProxies(_return, name, ids, options);
    return;
  }

  void asyncQuery(std::string& _return, const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->asyncQuery(_return, name, query, language, options);
    }
    ifaces_[i]->asyncQuery(_return, name, query, language, options);
    return;
  }

  void cancelAsyncQuery(const std::string& queryID) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->cancelAsyncQuery(queryID);
    }
    ifaces_[i]->cancelAsyncQuery(queryID);
  }

  void fetchAsyncQueryResults(QueryReport& _return, const std::string& queryID) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->fetchAsyncQueryResults(_return, queryID);
    }
    ifaces_[i]->fetchAsyncQueryResults(_return, queryID);
    return;
  }

  void addRepository(const std::string& name, const Repository& repo, const Credentials& credentials) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->addRepository(name, repo, credentials);
    }
    ifaces_[i]->addRepository(name, repo, credentials);
  }

  bool isFrozen(const std::string& name, const std::string& uri) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->isFrozen(name, uri);
    }
    return ifaces_[i]->isFrozen(name, uri);
  }

  void setFrozen(const std::string& name, const std::string& uri, const bool isFrozen) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->setFrozen(name, uri, isFrozen);
    }
    ifaces_[i]->setFrozen(name, uri, isFrozen);
  }

  void removeRepository(const std::string& name, const std::string& uri) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->removeRepository(name, uri);
    }
    ifaces_[i]->removeRepository(name, uri);
  }

  void updateRepositoryCredentials(const std::string& name, const std::string& uri, const Credentials& cred) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->updateRepositoryCredentials(name, uri, cred);
    }
    ifaces_[i]->updateRepositoryCredentials(name, uri, cred);
  }

  void listRepositories(std::vector<Repository> & _return, const std::string& name) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->listRepositories(_return, name);
    }
    ifaces_[i]->listRepositories(_return, name);
    return;
  }

  void listRepositoryTypes(std::vector<std::string> & _return) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->listRepositoryTypes(_return);
    }
    ifaces_[i]->listRepositoryTypes(_return);
    return;
  }

  void listFiles(std::vector<std::string> & _return, const std::string& name, const std::vector<std::string> & repository, const std::vector<std::string> & filePatterns) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->listFiles(_return, name, repository, filePatterns);
    }
    ifaces_[i]->listFiles(_return, name, repository, filePatterns);
    return;
  }

  void configurePolling(const std::string& name, const int32_t base, const int32_t max) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->configurePolling(name, base, max);
    }
    ifaces_[i]->configurePolling(name, base, max);
  }

  void addDerivedAttribute(const std::string& name, const DerivedAttributeSpec& spec) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->addDerivedAttribute(name, spec);
    }
    ifaces_[i]->addDerivedAttribute(name, spec);
  }

  void removeDerivedAttribute(const std::string& name, const DerivedAttributeSpec& spec) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->removeDerivedAttribute(name, spec);
    }
    ifaces_[i]->removeDerivedAttribute(name, spec);
  }

  void listDerivedAttributes(std::vector<DerivedAttributeSpec> & _return, const std::string& name) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->listDerivedAttributes(_return, name);
    }
    ifaces_[i]->listDerivedAttributes(_return, name);
    return;
  }

  void addIndexedAttribute(const std::string& name, const IndexedAttributeSpec& spec) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->addIndexedAttribute(name, spec);
    }
    ifaces_[i]->addIndexedAttribute(name, spec);
  }

  void removeIndexedAttribute(const std::string& name, const IndexedAttributeSpec& spec) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->removeIndexedAttribute(name, spec);
    }
    ifaces_[i]->removeIndexedAttribute(name, spec);
  }

  void listIndexedAttributes(std::vector<IndexedAttributeSpec> & _return, const std::string& name) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->listIndexedAttributes(_return, name);
    }
    ifaces_[i]->listIndexedAttributes(_return, name);
    return;
  }

  void getModel(std::vector<ModelElement> & _return, const std::string& name, const HawkQueryOptions& options) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->getModel(_return, name, options);
    }
    ifaces_[i]->getModel(_return, name, options);
    return;
  }

  void getRootElements(std::vector<ModelElement> & _return, const std::string& name, const HawkQueryOptions& options) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->getRootElements(_return, name, options);
    }
    ifaces_[i]->getRootElements(_return, name, options);
    return;
  }

  void watchStateChanges(Subscription& _return, const std::string& name) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->watchStateChanges(_return, name);
    }
    ifaces_[i]->watchStateChanges(_return, name);
    return;
  }

  void watchModelChanges(Subscription& _return, const std::string& name, const std::string& repositoryUri, const std::vector<std::string> & filePath, const std::string& clientID, const SubscriptionDurability::type durableEvents) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->watchModelChanges(_return, name, repositoryUri, filePath, clientID, durableEvents);
    }
    ifaces_[i]->watchModelChanges(_return, name, repositoryUri, filePath, clientID, durableEvents);
    return;
  }

};

// The 'concurrent' client is a thread safe client that correctly handles
// out of order responses.  It is slower than the regular client, so should
// only be used when you need to share a connection among multiple threads
class HawkConcurrentClient : virtual public HawkIf {
 public:
  HawkConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) : sync_(sync)
{
    setProtocol(prot);
  }
  HawkConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) : sync_(sync)
{
    setProtocol(iprot,oprot);
  }
 private:
  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
  setProtocol(prot,prot);
  }
  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
    piprot_=iprot;
    poprot_=oprot;
    iprot_ = iprot.get();
    oprot_ = oprot.get();
  }
 public:
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
    return piprot_;
  }
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
    return poprot_;
  }
  void createInstance(const std::string& name, const std::string& backend, const int32_t minimumDelayMillis, const int32_t maximumDelayMillis, const std::vector<std::string> & enabledPlugins, const std::string& indexFactory);
  int32_t send_createInstance(const std::string& name, const std::string& backend, const int32_t minimumDelayMillis, const int32_t maximumDelayMillis, const std::vector<std::string> & enabledPlugins, const std::string& indexFactory);
  void recv_createInstance(const int32_t seqid);
  void listBackends(std::vector<std::string> & _return);
  int32_t send_listBackends();
  void recv_listBackends(std::vector<std::string> & _return, const int32_t seqid);
  void listPlugins(std::vector<std::string> & _return);
  int32_t send_listPlugins();
  void recv_listPlugins(std::vector<std::string> & _return, const int32_t seqid);
  void listPluginDetails(std::vector<HawkPlugin> & _return);
  int32_t send_listPluginDetails();
  void recv_listPluginDetails(std::vector<HawkPlugin> & _return, const int32_t seqid);
  void listInstances(std::vector<HawkInstance> & _return);
  int32_t send_listInstances();
  void recv_listInstances(std::vector<HawkInstance> & _return, const int32_t seqid);
  void removeInstance(const std::string& name);
  int32_t send_removeInstance(const std::string& name);
  void recv_removeInstance(const int32_t seqid);
  void startInstance(const std::string& name);
  int32_t send_startInstance(const std::string& name);
  void recv_startInstance(const int32_t seqid);
  void stopInstance(const std::string& name);
  int32_t send_stopInstance(const std::string& name);
  void recv_stopInstance(const int32_t seqid);
  void syncInstance(const std::string& name, const bool blockUntilDone);
  int32_t send_syncInstance(const std::string& name, const bool blockUntilDone);
  void recv_syncInstance(const int32_t seqid);
  void registerMetamodels(const std::string& name, const std::vector<File> & metamodel);
  int32_t send_registerMetamodels(const std::string& name, const std::vector<File> & metamodel);
  void recv_registerMetamodels(const int32_t seqid);
  void unregisterMetamodels(const std::string& name, const std::vector<std::string> & metamodel);
  int32_t send_unregisterMetamodels(const std::string& name, const std::vector<std::string> & metamodel);
  void recv_unregisterMetamodels(const int32_t seqid);
  void listMetamodels(std::vector<std::string> & _return, const std::string& name);
  int32_t send_listMetamodels(const std::string& name);
  void recv_listMetamodels(std::vector<std::string> & _return, const int32_t seqid);
  void listTypeNames(std::vector<std::string> & _return, const std::string& hawkInstanceName, const std::string& metamodelURI);
  int32_t send_listTypeNames(const std::string& hawkInstanceName, const std::string& metamodelURI);
  void recv_listTypeNames(std::vector<std::string> & _return, const int32_t seqid);
  void listAttributeNames(std::vector<std::string> & _return, const std::string& hawkInstanceName, const std::string& metamodelURI, const std::string& typeName);
  int32_t send_listAttributeNames(const std::string& hawkInstanceName, const std::string& metamodelURI, const std::string& typeName);
  void recv_listAttributeNames(std::vector<std::string> & _return, const int32_t seqid);
  void listMetamodelParsers(std::vector<MetamodelParserDetails> & _return, const std::string& name);
  int32_t send_listMetamodelParsers(const std::string& name);
  void recv_listMetamodelParsers(std::vector<MetamodelParserDetails> & _return, const int32_t seqid);
  void listQueryLanguages(std::vector<std::string> & _return, const std::string& name);
  int32_t send_listQueryLanguages(const std::string& name);
  void recv_listQueryLanguages(std::vector<std::string> & _return, const int32_t seqid);
  void query(QueryResult& _return, const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options);
  int32_t send_query(const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options);
  void recv_query(QueryResult& _return, const int32_t seqid);
  void timedQuery(QueryReport& _return, const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options);
  int32_t send_timedQuery(const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options);
  void recv_timedQuery(QueryReport& _return, const int32_t seqid);
  void resolveProxies(std::vector<ModelElement> & _return, const std::string& name, const std::vector<std::string> & ids, const HawkQueryOptions& options);
  int32_t send_resolveProxies(const std::string& name, const std::vector<std::string> & ids, const HawkQueryOptions& options);
  void recv_resolveProxies(std::vector<ModelElement> & _return, const int32_t seqid);
  void asyncQuery(std::string& _return, const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options);
  int32_t send_asyncQuery(const std::string& name, const std::string& query, const std::string& language, const HawkQueryOptions& options);
  void recv_asyncQuery(std::string& _return, const int32_t seqid);
  void cancelAsyncQuery(const std::string& queryID);
  int32_t send_cancelAsyncQuery(const std::string& queryID);
  void recv_cancelAsyncQuery(const int32_t seqid);
  void fetchAsyncQueryResults(QueryReport& _return, const std::string& queryID);
  int32_t send_fetchAsyncQueryResults(const std::string& queryID);
  void recv_fetchAsyncQueryResults(QueryReport& _return, const int32_t seqid);
  void addRepository(const std::string& name, const Repository& repo, const Credentials& credentials);
  int32_t send_addRepository(const std::string& name, const Repository& repo, const Credentials& credentials);
  void recv_addRepository(const int32_t seqid);
  bool isFrozen(const std::string& name, const std::string& uri);
  int32_t send_isFrozen(const std::string& name, const std::string& uri);
  bool recv_isFrozen(const int32_t seqid);
  void setFrozen(const std::string& name, const std::string& uri, const bool isFrozen);
  int32_t send_setFrozen(const std::string& name, const std::string& uri, const bool isFrozen);
  void recv_setFrozen(const int32_t seqid);
  void removeRepository(const std::string& name, const std::string& uri);
  int32_t send_removeRepository(const std::string& name, const std::string& uri);
  void recv_removeRepository(const int32_t seqid);
  void updateRepositoryCredentials(const std::string& name, const std::string& uri, const Credentials& cred);
  int32_t send_updateRepositoryCredentials(const std::string& name, const std::string& uri, const Credentials& cred);
  void recv_updateRepositoryCredentials(const int32_t seqid);
  void listRepositories(std::vector<Repository> & _return, const std::string& name);
  int32_t send_listRepositories(const std::string& name);
  void recv_listRepositories(std::vector<Repository> & _return, const int32_t seqid);
  void listRepositoryTypes(std::vector<std::string> & _return);
  int32_t send_listRepositoryTypes();
  void recv_listRepositoryTypes(std::vector<std::string> & _return, const int32_t seqid);
  void listFiles(std::vector<std::string> & _return, const std::string& name, const std::vector<std::string> & repository, const std::vector<std::string> & filePatterns);
  int32_t send_listFiles(const std::string& name, const std::vector<std::string> & repository, const std::vector<std::string> & filePatterns);
  void recv_listFiles(std::vector<std::string> & _return, const int32_t seqid);
  void configurePolling(const std::string& name, const int32_t base, const int32_t max);
  int32_t send_configurePolling(const std::string& name, const int32_t base, const int32_t max);
  void recv_configurePolling(const int32_t seqid);
  void addDerivedAttribute(const std::string& name, const DerivedAttributeSpec& spec);
  int32_t send_addDerivedAttribute(const std::string& name, const DerivedAttributeSpec& spec);
  void recv_addDerivedAttribute(const int32_t seqid);
  void removeDerivedAttribute(const std::string& name, const DerivedAttributeSpec& spec);
  int32_t send_removeDerivedAttribute(const std::string& name, const DerivedAttributeSpec& spec);
  void recv_removeDerivedAttribute(const int32_t seqid);
  void listDerivedAttributes(std::vector<DerivedAttributeSpec> & _return, const std::string& name);
  int32_t send_listDerivedAttributes(const std::string& name);
  void recv_listDerivedAttributes(std::vector<DerivedAttributeSpec> & _return, const int32_t seqid);
  void addIndexedAttribute(const std::string& name, const IndexedAttributeSpec& spec);
  int32_t send_addIndexedAttribute(const std::string& name, const IndexedAttributeSpec& spec);
  void recv_addIndexedAttribute(const int32_t seqid);
  void removeIndexedAttribute(const std::string& name, const IndexedAttributeSpec& spec);
  int32_t send_removeIndexedAttribute(const std::string& name, const IndexedAttributeSpec& spec);
  void recv_removeIndexedAttribute(const int32_t seqid);
  void listIndexedAttributes(std::vector<IndexedAttributeSpec> & _return, const std::string& name);
  int32_t send_listIndexedAttributes(const std::string& name);
  void recv_listIndexedAttributes(std::vector<IndexedAttributeSpec> & _return, const int32_t seqid);
  void getModel(std::vector<ModelElement> & _return, const std::string& name, const HawkQueryOptions& options);
  int32_t send_getModel(const std::string& name, const HawkQueryOptions& options);
  void recv_getModel(std::vector<ModelElement> & _return, const int32_t seqid);
  void getRootElements(std::vector<ModelElement> & _return, const std::string& name, const HawkQueryOptions& options);
  int32_t send_getRootElements(const std::string& name, const HawkQueryOptions& options);
  void recv_getRootElements(std::vector<ModelElement> & _return, const int32_t seqid);
  void watchStateChanges(Subscription& _return, const std::string& name);
  int32_t send_watchStateChanges(const std::string& name);
  void recv_watchStateChanges(Subscription& _return, const int32_t seqid);
  void watchModelChanges(Subscription& _return, const std::string& name, const std::string& repositoryUri, const std::vector<std::string> & filePath, const std::string& clientID, const SubscriptionDurability::type durableEvents);
  int32_t send_watchModelChanges(const std::string& name, const std::string& repositoryUri, const std::vector<std::string> & filePath, const std::string& clientID, const SubscriptionDurability::type durableEvents);
  void recv_watchModelChanges(Subscription& _return, const int32_t seqid);
 protected:
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
  ::apache::thrift::protocol::TProtocol* iprot_;
  ::apache::thrift::protocol::TProtocol* oprot_;
  std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync_;
};

#ifdef _MSC_VER
  #pragma warning( pop )
#endif



#endif
