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

#include <iosfwd>

#include <thrift/Thrift.h>
#include <thrift/TApplicationException.h>
#include <thrift/TBase.h>
#include <thrift/protocol/TProtocol.h>
#include <thrift/transport/TTransport.h>

#include <functional>
#include <memory>

namespace osquery { namespace extensions {

struct ExtensionCode {
  enum type {
    EXT_SUCCESS = 0,
    EXT_FAILED = 1,
    EXT_FATAL = 2
  };
};

extern const std::map<int, const char*> _ExtensionCode_VALUES_TO_NAMES;

std::ostream& operator<<(std::ostream& out, const ExtensionCode::type& val);

std::string to_string(const ExtensionCode::type& val);

typedef std::map<std::string, std::string>  ExtensionPluginRequest;

typedef std::vector<std::map<std::string, std::string> >  ExtensionPluginResponse;

typedef std::map<std::string, class InternalOptionInfo>  InternalOptionList;

typedef int64_t ExtensionRouteUUID;

typedef std::map<std::string, ExtensionPluginResponse>  ExtensionRouteTable;

typedef std::map<std::string, ExtensionRouteTable>  ExtensionRegistry;

typedef std::map<ExtensionRouteUUID, class InternalExtensionInfo>  InternalExtensionList;

class InternalOptionInfo;

class InternalExtensionInfo;

class ExtensionStatus;

class ExtensionResponse;

class ExtensionException;

typedef struct _InternalOptionInfo__isset {
  _InternalOptionInfo__isset() : value(false), default_value(false), type(false) {}
  bool value :1;
  bool default_value :1;
  bool type :1;
} _InternalOptionInfo__isset;

class InternalOptionInfo : public virtual ::apache::thrift::TBase {
 public:

  InternalOptionInfo(const InternalOptionInfo&);
  InternalOptionInfo(InternalOptionInfo&&);
  InternalOptionInfo& operator=(const InternalOptionInfo&);
  InternalOptionInfo& operator=(InternalOptionInfo&&);
  InternalOptionInfo() : value(), default_value(), type() {
  }

  virtual ~InternalOptionInfo() noexcept;
  std::string value;
  std::string default_value;
  std::string type;

  _InternalOptionInfo__isset __isset;

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

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

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

  bool operator == (const InternalOptionInfo & rhs) const
  {
    if (!(value == rhs.value))
      return false;
    if (!(default_value == rhs.default_value))
      return false;
    if (!(type == rhs.type))
      return false;
    return true;
  }
  bool operator != (const InternalOptionInfo &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const InternalOptionInfo & ) const;

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

  virtual void printTo(std::ostream& out) const;
};

void swap(InternalOptionInfo &a, InternalOptionInfo &b);

std::ostream& operator<<(std::ostream& out, const InternalOptionInfo& obj);

typedef struct _InternalExtensionInfo__isset {
  _InternalExtensionInfo__isset() : name(false), version(false), sdk_version(false), min_sdk_version(false) {}
  bool name :1;
  bool version :1;
  bool sdk_version :1;
  bool min_sdk_version :1;
} _InternalExtensionInfo__isset;

class InternalExtensionInfo : public virtual ::apache::thrift::TBase {
 public:

  InternalExtensionInfo(const InternalExtensionInfo&);
  InternalExtensionInfo(InternalExtensionInfo&&);
  InternalExtensionInfo& operator=(const InternalExtensionInfo&);
  InternalExtensionInfo& operator=(InternalExtensionInfo&&);
  InternalExtensionInfo() : name(), version(), sdk_version(), min_sdk_version() {
  }

  virtual ~InternalExtensionInfo() noexcept;
  std::string name;
  std::string version;
  std::string sdk_version;
  std::string min_sdk_version;

  _InternalExtensionInfo__isset __isset;

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

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

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

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

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

  bool operator < (const InternalExtensionInfo & ) const;

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

  virtual void printTo(std::ostream& out) const;
};

void swap(InternalExtensionInfo &a, InternalExtensionInfo &b);

std::ostream& operator<<(std::ostream& out, const InternalExtensionInfo& obj);

typedef struct _ExtensionStatus__isset {
  _ExtensionStatus__isset() : code(false), message(false), uuid(false) {}
  bool code :1;
  bool message :1;
  bool uuid :1;
} _ExtensionStatus__isset;

class ExtensionStatus : public virtual ::apache::thrift::TBase {
 public:

  ExtensionStatus(const ExtensionStatus&);
  ExtensionStatus(ExtensionStatus&&);
  ExtensionStatus& operator=(const ExtensionStatus&);
  ExtensionStatus& operator=(ExtensionStatus&&);
  ExtensionStatus() : code(0), message(), uuid(0) {
  }

  virtual ~ExtensionStatus() noexcept;
  int32_t code;
  std::string message;
  ExtensionRouteUUID uuid;

  _ExtensionStatus__isset __isset;

  void __set_code(const int32_t val);

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

  void __set_uuid(const ExtensionRouteUUID val);

  bool operator == (const ExtensionStatus & rhs) const
  {
    if (!(code == rhs.code))
      return false;
    if (!(message == rhs.message))
      return false;
    if (!(uuid == rhs.uuid))
      return false;
    return true;
  }
  bool operator != (const ExtensionStatus &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ExtensionStatus & ) const;

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

  virtual void printTo(std::ostream& out) const;
};

void swap(ExtensionStatus &a, ExtensionStatus &b);

std::ostream& operator<<(std::ostream& out, const ExtensionStatus& obj);

typedef struct _ExtensionResponse__isset {
  _ExtensionResponse__isset() : status(false), response(false) {}
  bool status :1;
  bool response :1;
} _ExtensionResponse__isset;

class ExtensionResponse : public virtual ::apache::thrift::TBase {
 public:

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

  virtual ~ExtensionResponse() noexcept;
  ExtensionStatus status;
  ExtensionPluginResponse response;

  _ExtensionResponse__isset __isset;

  void __set_status(const ExtensionStatus& val);

  void __set_response(const ExtensionPluginResponse& val);

  bool operator == (const ExtensionResponse & rhs) const
  {
    if (!(status == rhs.status))
      return false;
    if (!(response == rhs.response))
      return false;
    return true;
  }
  bool operator != (const ExtensionResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ExtensionResponse & ) const;

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

  virtual void printTo(std::ostream& out) const;
};

void swap(ExtensionResponse &a, ExtensionResponse &b);

std::ostream& operator<<(std::ostream& out, const ExtensionResponse& obj);

typedef struct _ExtensionException__isset {
  _ExtensionException__isset() : code(false), message(false), uuid(false) {}
  bool code :1;
  bool message :1;
  bool uuid :1;
} _ExtensionException__isset;

class ExtensionException : public ::apache::thrift::TException {
 public:

  ExtensionException(const ExtensionException&);
  ExtensionException(ExtensionException&&);
  ExtensionException& operator=(const ExtensionException&);
  ExtensionException& operator=(ExtensionException&&);
  ExtensionException() : code(0), message(), uuid(0) {
  }

  virtual ~ExtensionException() noexcept;
  int32_t code;
  std::string message;
  ExtensionRouteUUID uuid;

  _ExtensionException__isset __isset;

  void __set_code(const int32_t val);

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

  void __set_uuid(const ExtensionRouteUUID val);

  bool operator == (const ExtensionException & rhs) const
  {
    if (!(code == rhs.code))
      return false;
    if (!(message == rhs.message))
      return false;
    if (!(uuid == rhs.uuid))
      return false;
    return true;
  }
  bool operator != (const ExtensionException &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ExtensionException & ) const;

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

  virtual void printTo(std::ostream& out) const;
  mutable std::string thriftTExceptionMessageHolder_;
  const char* what() const noexcept;
};

void swap(ExtensionException &a, ExtensionException &b);

std::ostream& operator<<(std::ostream& out, const ExtensionException& obj);

}} // namespace

#endif
