// automatically generated by the FlatBuffers compiler, do not modify


#ifndef FLATBUFFERS_GENERATED_CHREPOWERTEST_CHRE_POWER_TEST_H_
#define FLATBUFFERS_GENERATED_CHREPOWERTEST_CHRE_POWER_TEST_H_

#include "flatbuffers/flatbuffers.h"

namespace chre {
namespace power_test {

struct TimerMessage;
struct TimerMessageBuilder;
struct TimerMessageT;

struct WifiScanMessage;
struct WifiScanMessageBuilder;
struct WifiScanMessageT;

struct GnssLocationMessage;
struct GnssLocationMessageBuilder;
struct GnssLocationMessageT;

struct CellQueryMessage;
struct CellQueryMessageBuilder;
struct CellQueryMessageT;

struct AudioRequestMessage;
struct AudioRequestMessageBuilder;
struct AudioRequestMessageT;

struct SensorRequestMessage;
struct SensorRequestMessageBuilder;
struct SensorRequestMessageT;

struct BreakItMessage;
struct BreakItMessageBuilder;
struct BreakItMessageT;

struct NanoappResponseMessage;
struct NanoappResponseMessageBuilder;
struct NanoappResponseMessageT;

struct GnssMeasurementMessage;
struct GnssMeasurementMessageBuilder;
struct GnssMeasurementMessageT;

struct WifiNanSubMessage;
struct WifiNanSubMessageBuilder;
struct WifiNanSubMessageT;

struct WifiNanSubCancelMessage;
struct WifiNanSubCancelMessageBuilder;
struct WifiNanSubCancelMessageT;

struct WifiNanSubResponseMessage;
struct WifiNanSubResponseMessageBuilder;
struct WifiNanSubResponseMessageT;

/// Indicates which of the following messages is being sent to / from the
/// nanoapp. Use uint as the base type to match the message type in
/// chreMessageFromHostData.
enum class MessageType : uint32_t {
  UNSPECIFIED = 0,
  /// Should be used with TimerMessage
  TIMER_TEST = 1,
  /// Should be used with WifiScanMessage
  WIFI_SCAN_TEST = 2,
  /// Should be used with GnssLocationMessage
  GNSS_LOCATION_TEST = 3,
  /// Should be used with CellQueryMessage
  CELL_QUERY_TEST = 4,
  /// Should be used with AudioRequestMessage
  AUDIO_REQUEST_TEST = 5,
  /// Should be used with SensorRequestMessage
  SENSOR_REQUEST_TEST = 6,
  /// Should be used with BreakItMessage
  BREAK_IT_TEST = 7,
  /// Should be used with NanoappResponseMessage
  NANOAPP_RESPONSE = 8,
  /// Should be used with GnssMeasurementMessage
  GNSS_MEASUREMENT_TEST = 9,
  /// Should be used with WifiNanSubMessage
  WIFI_NAN_SUB = 10,
  /// Should be used with WifiNanSubCancelMessage
  WIFI_NAN_SUB_CANCEL = 11,
  /// Should be used with WifiNanSubResponseMessage
  WIFI_NAN_SUB_RESP = 12,
  MIN = UNSPECIFIED,
  MAX = WIFI_NAN_SUB_RESP
};

inline const MessageType (&EnumValuesMessageType())[13] {
  static const MessageType values[] = {
    MessageType::UNSPECIFIED,
    MessageType::TIMER_TEST,
    MessageType::WIFI_SCAN_TEST,
    MessageType::GNSS_LOCATION_TEST,
    MessageType::CELL_QUERY_TEST,
    MessageType::AUDIO_REQUEST_TEST,
    MessageType::SENSOR_REQUEST_TEST,
    MessageType::BREAK_IT_TEST,
    MessageType::NANOAPP_RESPONSE,
    MessageType::GNSS_MEASUREMENT_TEST,
    MessageType::WIFI_NAN_SUB,
    MessageType::WIFI_NAN_SUB_CANCEL,
    MessageType::WIFI_NAN_SUB_RESP
  };
  return values;
}

inline const char * const *EnumNamesMessageType() {
  static const char * const names[14] = {
    "UNSPECIFIED",
    "TIMER_TEST",
    "WIFI_SCAN_TEST",
    "GNSS_LOCATION_TEST",
    "CELL_QUERY_TEST",
    "AUDIO_REQUEST_TEST",
    "SENSOR_REQUEST_TEST",
    "BREAK_IT_TEST",
    "NANOAPP_RESPONSE",
    "GNSS_MEASUREMENT_TEST",
    "WIFI_NAN_SUB",
    "WIFI_NAN_SUB_CANCEL",
    "WIFI_NAN_SUB_RESP",
    nullptr
  };
  return names;
}

inline const char *EnumNameMessageType(MessageType e) {
  if (flatbuffers::IsOutRange(e, MessageType::UNSPECIFIED, MessageType::WIFI_NAN_SUB_RESP)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesMessageType()[index];
}

/// All the various WiFi scan types that can be interacted with inside the
/// nanoapp. The values used here map directly to values from the CHRE API.
enum class WifiScanType : uint8_t {
  ACTIVE = 0,
  ACTIVE_PLUS_PASSIVE_DFS = 1,
  PASSIVE = 2,
  NO_PREFERENCE = 3,
  MIN = ACTIVE,
  MAX = NO_PREFERENCE
};

inline const WifiScanType (&EnumValuesWifiScanType())[4] {
  static const WifiScanType values[] = {
    WifiScanType::ACTIVE,
    WifiScanType::ACTIVE_PLUS_PASSIVE_DFS,
    WifiScanType::PASSIVE,
    WifiScanType::NO_PREFERENCE
  };
  return values;
}

inline const char * const *EnumNamesWifiScanType() {
  static const char * const names[5] = {
    "ACTIVE",
    "ACTIVE_PLUS_PASSIVE_DFS",
    "PASSIVE",
    "NO_PREFERENCE",
    nullptr
  };
  return names;
}

inline const char *EnumNameWifiScanType(WifiScanType e) {
  if (flatbuffers::IsOutRange(e, WifiScanType::ACTIVE, WifiScanType::NO_PREFERENCE)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesWifiScanType()[index];
}

/// All the various WiFi radio chain preferences that can be interacted with
/// inside the nanoapp. The values used here map directly to values from the
/// CHRE API.
enum class WifiRadioChain : uint8_t {
  DEFAULT = 0,
  LOW_LATENCY = 1,
  LOW_POWER = 2,
  HIGH_ACCURACY = 3,
  MIN = DEFAULT,
  MAX = HIGH_ACCURACY
};

inline const WifiRadioChain (&EnumValuesWifiRadioChain())[4] {
  static const WifiRadioChain values[] = {
    WifiRadioChain::DEFAULT,
    WifiRadioChain::LOW_LATENCY,
    WifiRadioChain::LOW_POWER,
    WifiRadioChain::HIGH_ACCURACY
  };
  return values;
}

inline const char * const *EnumNamesWifiRadioChain() {
  static const char * const names[5] = {
    "DEFAULT",
    "LOW_LATENCY",
    "LOW_POWER",
    "HIGH_ACCURACY",
    nullptr
  };
  return names;
}

inline const char *EnumNameWifiRadioChain(WifiRadioChain e) {
  if (flatbuffers::IsOutRange(e, WifiRadioChain::DEFAULT, WifiRadioChain::HIGH_ACCURACY)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesWifiRadioChain()[index];
}

/// All the various WiFi channel sets that can be interacted with inside the
/// nanoapp. The values used here map directly to values from the CHRE API.
enum class WifiChannelSet : uint8_t {
  NON_DFS = 0,
  ALL = 1,
  MIN = NON_DFS,
  MAX = ALL
};

inline const WifiChannelSet (&EnumValuesWifiChannelSet())[2] {
  static const WifiChannelSet values[] = {
    WifiChannelSet::NON_DFS,
    WifiChannelSet::ALL
  };
  return values;
}

inline const char * const *EnumNamesWifiChannelSet() {
  static const char * const names[3] = {
    "NON_DFS",
    "ALL",
    nullptr
  };
  return names;
}

inline const char *EnumNameWifiChannelSet(WifiChannelSet e) {
  if (flatbuffers::IsOutRange(e, WifiChannelSet::NON_DFS, WifiChannelSet::ALL)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesWifiChannelSet()[index];
}

/// All the various sensors that can be interacted with inside the nanoapp.
/// The values used here map directly to values from the CHRE API
enum class SensorType : uint8_t {
  UNKNOWN = 0,
  ACCELEROMETER = 1,
  INSTANT_MOTION_DETECT = 2,
  STATIONARY_DETECT = 3,
  GYROSCOPE = 6,
  UNCALIBRATED_GYROSCOPE = 7,
  GEOMAGNETIC_FIELD = 8,
  UNCALIBRATED_GEOMAGNETIC_FIELD = 9,
  PRESSURE = 10,
  LIGHT = 12,
  PROXIMITY = 13,
  STEP_DETECT = 23,
  STEP_COUNTER = 24,
  UNCALIBRATED_ACCELEROMETER = 55,
  ACCELEROMETER_TEMPERATURE = 56,
  GYROSCOPE_TEMPERATURE = 57,
  GEOMAGNETIC_FIELD_TEMPERATURE = 58,
  MIN = UNKNOWN,
  MAX = GEOMAGNETIC_FIELD_TEMPERATURE
};

inline const SensorType (&EnumValuesSensorType())[17] {
  static const SensorType values[] = {
    SensorType::UNKNOWN,
    SensorType::ACCELEROMETER,
    SensorType::INSTANT_MOTION_DETECT,
    SensorType::STATIONARY_DETECT,
    SensorType::GYROSCOPE,
    SensorType::UNCALIBRATED_GYROSCOPE,
    SensorType::GEOMAGNETIC_FIELD,
    SensorType::UNCALIBRATED_GEOMAGNETIC_FIELD,
    SensorType::PRESSURE,
    SensorType::LIGHT,
    SensorType::PROXIMITY,
    SensorType::STEP_DETECT,
    SensorType::STEP_COUNTER,
    SensorType::UNCALIBRATED_ACCELEROMETER,
    SensorType::ACCELEROMETER_TEMPERATURE,
    SensorType::GYROSCOPE_TEMPERATURE,
    SensorType::GEOMAGNETIC_FIELD_TEMPERATURE
  };
  return values;
}

inline const char * const *EnumNamesSensorType() {
  static const char * const names[60] = {
    "UNKNOWN",
    "ACCELEROMETER",
    "INSTANT_MOTION_DETECT",
    "STATIONARY_DETECT",
    "",
    "",
    "GYROSCOPE",
    "UNCALIBRATED_GYROSCOPE",
    "GEOMAGNETIC_FIELD",
    "UNCALIBRATED_GEOMAGNETIC_FIELD",
    "PRESSURE",
    "",
    "LIGHT",
    "PROXIMITY",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "STEP_DETECT",
    "STEP_COUNTER",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "UNCALIBRATED_ACCELEROMETER",
    "ACCELEROMETER_TEMPERATURE",
    "GYROSCOPE_TEMPERATURE",
    "GEOMAGNETIC_FIELD_TEMPERATURE",
    nullptr
  };
  return names;
}

inline const char *EnumNameSensorType(SensorType e) {
  if (flatbuffers::IsOutRange(e, SensorType::UNKNOWN, SensorType::GEOMAGNETIC_FIELD_TEMPERATURE)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesSensorType()[index];
}

struct TimerMessageT : public flatbuffers::NativeTable {
  typedef TimerMessage TableType;
  bool enable;
  uint64_t wakeup_interval_ns;
  TimerMessageT()
      : enable(false),
        wakeup_interval_ns(0) {
  }
};

/// Represents a message to ask the nanoapp to create a timer that wakes up at
/// the given interval
struct TimerMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef TimerMessageT NativeTableType;
  typedef TimerMessageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ENABLE = 4,
    VT_WAKEUP_INTERVAL_NS = 6
  };
  bool enable() const {
    return GetField<uint8_t>(VT_ENABLE, 0) != 0;
  }
  bool mutate_enable(bool _enable) {
    return SetField<uint8_t>(VT_ENABLE, static_cast<uint8_t>(_enable), 0);
  }
  uint64_t wakeup_interval_ns() const {
    return GetField<uint64_t>(VT_WAKEUP_INTERVAL_NS, 0);
  }
  bool mutate_wakeup_interval_ns(uint64_t _wakeup_interval_ns) {
    return SetField<uint64_t>(VT_WAKEUP_INTERVAL_NS, _wakeup_interval_ns, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ENABLE) &&
           VerifyField<uint64_t>(verifier, VT_WAKEUP_INTERVAL_NS) &&
           verifier.EndTable();
  }
  TimerMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(TimerMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<TimerMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TimerMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct TimerMessageBuilder {
  typedef TimerMessage Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_enable(bool enable) {
    fbb_.AddElement<uint8_t>(TimerMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
  }
  void add_wakeup_interval_ns(uint64_t wakeup_interval_ns) {
    fbb_.AddElement<uint64_t>(TimerMessage::VT_WAKEUP_INTERVAL_NS, wakeup_interval_ns, 0);
  }
  explicit TimerMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  TimerMessageBuilder &operator=(const TimerMessageBuilder &);
  flatbuffers::Offset<TimerMessage> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<TimerMessage>(end);
    return o;
  }
};

inline flatbuffers::Offset<TimerMessage> CreateTimerMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool enable = false,
    uint64_t wakeup_interval_ns = 0) {
  TimerMessageBuilder builder_(_fbb);
  builder_.add_wakeup_interval_ns(wakeup_interval_ns);
  builder_.add_enable(enable);
  return builder_.Finish();
}

flatbuffers::Offset<TimerMessage> CreateTimerMessage(flatbuffers::FlatBufferBuilder &_fbb, const TimerMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct WifiScanMessageT : public flatbuffers::NativeTable {
  typedef WifiScanMessage TableType;
  bool enable;
  uint64_t scan_interval_ns;
  chre::power_test::WifiScanType scan_type;
  chre::power_test::WifiRadioChain radio_chain;
  chre::power_test::WifiChannelSet channel_set;
  WifiScanMessageT()
      : enable(false),
        scan_interval_ns(0),
        scan_type(chre::power_test::WifiScanType::ACTIVE),
        radio_chain(chre::power_test::WifiRadioChain::DEFAULT),
        channel_set(chre::power_test::WifiChannelSet::NON_DFS) {
  }
};

/// Represents a message to ask the nanoapp to start or stop WiFi scanning and
/// the scan interval to use if scanning is being started
struct WifiScanMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef WifiScanMessageT NativeTableType;
  typedef WifiScanMessageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ENABLE = 4,
    VT_SCAN_INTERVAL_NS = 6,
    VT_SCAN_TYPE = 8,
    VT_RADIO_CHAIN = 10,
    VT_CHANNEL_SET = 12
  };
  bool enable() const {
    return GetField<uint8_t>(VT_ENABLE, 0) != 0;
  }
  bool mutate_enable(bool _enable) {
    return SetField<uint8_t>(VT_ENABLE, static_cast<uint8_t>(_enable), 0);
  }
  uint64_t scan_interval_ns() const {
    return GetField<uint64_t>(VT_SCAN_INTERVAL_NS, 0);
  }
  bool mutate_scan_interval_ns(uint64_t _scan_interval_ns) {
    return SetField<uint64_t>(VT_SCAN_INTERVAL_NS, _scan_interval_ns, 0);
  }
  chre::power_test::WifiScanType scan_type() const {
    return static_cast<chre::power_test::WifiScanType>(GetField<uint8_t>(VT_SCAN_TYPE, 0));
  }
  bool mutate_scan_type(chre::power_test::WifiScanType _scan_type) {
    return SetField<uint8_t>(VT_SCAN_TYPE, static_cast<uint8_t>(_scan_type), 0);
  }
  chre::power_test::WifiRadioChain radio_chain() const {
    return static_cast<chre::power_test::WifiRadioChain>(GetField<uint8_t>(VT_RADIO_CHAIN, 0));
  }
  bool mutate_radio_chain(chre::power_test::WifiRadioChain _radio_chain) {
    return SetField<uint8_t>(VT_RADIO_CHAIN, static_cast<uint8_t>(_radio_chain), 0);
  }
  chre::power_test::WifiChannelSet channel_set() const {
    return static_cast<chre::power_test::WifiChannelSet>(GetField<uint8_t>(VT_CHANNEL_SET, 0));
  }
  bool mutate_channel_set(chre::power_test::WifiChannelSet _channel_set) {
    return SetField<uint8_t>(VT_CHANNEL_SET, static_cast<uint8_t>(_channel_set), 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ENABLE) &&
           VerifyField<uint64_t>(verifier, VT_SCAN_INTERVAL_NS) &&
           VerifyField<uint8_t>(verifier, VT_SCAN_TYPE) &&
           VerifyField<uint8_t>(verifier, VT_RADIO_CHAIN) &&
           VerifyField<uint8_t>(verifier, VT_CHANNEL_SET) &&
           verifier.EndTable();
  }
  WifiScanMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(WifiScanMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<WifiScanMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WifiScanMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct WifiScanMessageBuilder {
  typedef WifiScanMessage Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_enable(bool enable) {
    fbb_.AddElement<uint8_t>(WifiScanMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
  }
  void add_scan_interval_ns(uint64_t scan_interval_ns) {
    fbb_.AddElement<uint64_t>(WifiScanMessage::VT_SCAN_INTERVAL_NS, scan_interval_ns, 0);
  }
  void add_scan_type(chre::power_test::WifiScanType scan_type) {
    fbb_.AddElement<uint8_t>(WifiScanMessage::VT_SCAN_TYPE, static_cast<uint8_t>(scan_type), 0);
  }
  void add_radio_chain(chre::power_test::WifiRadioChain radio_chain) {
    fbb_.AddElement<uint8_t>(WifiScanMessage::VT_RADIO_CHAIN, static_cast<uint8_t>(radio_chain), 0);
  }
  void add_channel_set(chre::power_test::WifiChannelSet channel_set) {
    fbb_.AddElement<uint8_t>(WifiScanMessage::VT_CHANNEL_SET, static_cast<uint8_t>(channel_set), 0);
  }
  explicit WifiScanMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  WifiScanMessageBuilder &operator=(const WifiScanMessageBuilder &);
  flatbuffers::Offset<WifiScanMessage> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<WifiScanMessage>(end);
    return o;
  }
};

inline flatbuffers::Offset<WifiScanMessage> CreateWifiScanMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool enable = false,
    uint64_t scan_interval_ns = 0,
    chre::power_test::WifiScanType scan_type = chre::power_test::WifiScanType::ACTIVE,
    chre::power_test::WifiRadioChain radio_chain = chre::power_test::WifiRadioChain::DEFAULT,
    chre::power_test::WifiChannelSet channel_set = chre::power_test::WifiChannelSet::NON_DFS) {
  WifiScanMessageBuilder builder_(_fbb);
  builder_.add_scan_interval_ns(scan_interval_ns);
  builder_.add_channel_set(channel_set);
  builder_.add_radio_chain(radio_chain);
  builder_.add_scan_type(scan_type);
  builder_.add_enable(enable);
  return builder_.Finish();
}

flatbuffers::Offset<WifiScanMessage> CreateWifiScanMessage(flatbuffers::FlatBufferBuilder &_fbb, const WifiScanMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct GnssLocationMessageT : public flatbuffers::NativeTable {
  typedef GnssLocationMessage TableType;
  bool enable;
  uint32_t scan_interval_millis;
  uint32_t min_time_to_next_fix_millis;
  GnssLocationMessageT()
      : enable(false),
        scan_interval_millis(0),
        min_time_to_next_fix_millis(0) {
  }
};

/// Represents a message to ask the nanoapp to start or stop Gnss location
/// sampling at the requested interval
struct GnssLocationMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef GnssLocationMessageT NativeTableType;
  typedef GnssLocationMessageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ENABLE = 4,
    VT_SCAN_INTERVAL_MILLIS = 6,
    VT_MIN_TIME_TO_NEXT_FIX_MILLIS = 8
  };
  bool enable() const {
    return GetField<uint8_t>(VT_ENABLE, 0) != 0;
  }
  bool mutate_enable(bool _enable) {
    return SetField<uint8_t>(VT_ENABLE, static_cast<uint8_t>(_enable), 0);
  }
  uint32_t scan_interval_millis() const {
    return GetField<uint32_t>(VT_SCAN_INTERVAL_MILLIS, 0);
  }
  bool mutate_scan_interval_millis(uint32_t _scan_interval_millis) {
    return SetField<uint32_t>(VT_SCAN_INTERVAL_MILLIS, _scan_interval_millis, 0);
  }
  uint32_t min_time_to_next_fix_millis() const {
    return GetField<uint32_t>(VT_MIN_TIME_TO_NEXT_FIX_MILLIS, 0);
  }
  bool mutate_min_time_to_next_fix_millis(uint32_t _min_time_to_next_fix_millis) {
    return SetField<uint32_t>(VT_MIN_TIME_TO_NEXT_FIX_MILLIS, _min_time_to_next_fix_millis, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ENABLE) &&
           VerifyField<uint32_t>(verifier, VT_SCAN_INTERVAL_MILLIS) &&
           VerifyField<uint32_t>(verifier, VT_MIN_TIME_TO_NEXT_FIX_MILLIS) &&
           verifier.EndTable();
  }
  GnssLocationMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(GnssLocationMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<GnssLocationMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GnssLocationMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct GnssLocationMessageBuilder {
  typedef GnssLocationMessage Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_enable(bool enable) {
    fbb_.AddElement<uint8_t>(GnssLocationMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
  }
  void add_scan_interval_millis(uint32_t scan_interval_millis) {
    fbb_.AddElement<uint32_t>(GnssLocationMessage::VT_SCAN_INTERVAL_MILLIS, scan_interval_millis, 0);
  }
  void add_min_time_to_next_fix_millis(uint32_t min_time_to_next_fix_millis) {
    fbb_.AddElement<uint32_t>(GnssLocationMessage::VT_MIN_TIME_TO_NEXT_FIX_MILLIS, min_time_to_next_fix_millis, 0);
  }
  explicit GnssLocationMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  GnssLocationMessageBuilder &operator=(const GnssLocationMessageBuilder &);
  flatbuffers::Offset<GnssLocationMessage> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<GnssLocationMessage>(end);
    return o;
  }
};

inline flatbuffers::Offset<GnssLocationMessage> CreateGnssLocationMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool enable = false,
    uint32_t scan_interval_millis = 0,
    uint32_t min_time_to_next_fix_millis = 0) {
  GnssLocationMessageBuilder builder_(_fbb);
  builder_.add_min_time_to_next_fix_millis(min_time_to_next_fix_millis);
  builder_.add_scan_interval_millis(scan_interval_millis);
  builder_.add_enable(enable);
  return builder_.Finish();
}

flatbuffers::Offset<GnssLocationMessage> CreateGnssLocationMessage(flatbuffers::FlatBufferBuilder &_fbb, const GnssLocationMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct CellQueryMessageT : public flatbuffers::NativeTable {
  typedef CellQueryMessage TableType;
  bool enable;
  uint64_t query_interval_ns;
  CellQueryMessageT()
      : enable(false),
        query_interval_ns(0) {
  }
};

/// Represents a message to ask the nanoapp to start or stop querying the cell
/// modem for the latest cell scan results on the given interval
struct CellQueryMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef CellQueryMessageT NativeTableType;
  typedef CellQueryMessageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ENABLE = 4,
    VT_QUERY_INTERVAL_NS = 6
  };
  bool enable() const {
    return GetField<uint8_t>(VT_ENABLE, 0) != 0;
  }
  bool mutate_enable(bool _enable) {
    return SetField<uint8_t>(VT_ENABLE, static_cast<uint8_t>(_enable), 0);
  }
  uint64_t query_interval_ns() const {
    return GetField<uint64_t>(VT_QUERY_INTERVAL_NS, 0);
  }
  bool mutate_query_interval_ns(uint64_t _query_interval_ns) {
    return SetField<uint64_t>(VT_QUERY_INTERVAL_NS, _query_interval_ns, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ENABLE) &&
           VerifyField<uint64_t>(verifier, VT_QUERY_INTERVAL_NS) &&
           verifier.EndTable();
  }
  CellQueryMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(CellQueryMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<CellQueryMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CellQueryMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct CellQueryMessageBuilder {
  typedef CellQueryMessage Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_enable(bool enable) {
    fbb_.AddElement<uint8_t>(CellQueryMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
  }
  void add_query_interval_ns(uint64_t query_interval_ns) {
    fbb_.AddElement<uint64_t>(CellQueryMessage::VT_QUERY_INTERVAL_NS, query_interval_ns, 0);
  }
  explicit CellQueryMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  CellQueryMessageBuilder &operator=(const CellQueryMessageBuilder &);
  flatbuffers::Offset<CellQueryMessage> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<CellQueryMessage>(end);
    return o;
  }
};

inline flatbuffers::Offset<CellQueryMessage> CreateCellQueryMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool enable = false,
    uint64_t query_interval_ns = 0) {
  CellQueryMessageBuilder builder_(_fbb);
  builder_.add_query_interval_ns(query_interval_ns);
  builder_.add_enable(enable);
  return builder_.Finish();
}

flatbuffers::Offset<CellQueryMessage> CreateCellQueryMessage(flatbuffers::FlatBufferBuilder &_fbb, const CellQueryMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct AudioRequestMessageT : public flatbuffers::NativeTable {
  typedef AudioRequestMessage TableType;
  bool enable;
  uint64_t buffer_duration_ns;
  AudioRequestMessageT()
      : enable(false),
        buffer_duration_ns(0) {
  }
};

/// Represents a message to ask the nanoapp to start / stop requesting Audio
/// data buffered at given interval. Note: If there is more than one audio
/// source, the nanoapp will only request audio from the first source.
struct AudioRequestMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef AudioRequestMessageT NativeTableType;
  typedef AudioRequestMessageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ENABLE = 4,
    VT_BUFFER_DURATION_NS = 6
  };
  bool enable() const {
    return GetField<uint8_t>(VT_ENABLE, 0) != 0;
  }
  bool mutate_enable(bool _enable) {
    return SetField<uint8_t>(VT_ENABLE, static_cast<uint8_t>(_enable), 0);
  }
  /// The buffer duration is also used as the interval for how often
  /// the buffer should be delivered to the nanoapp.
  uint64_t buffer_duration_ns() const {
    return GetField<uint64_t>(VT_BUFFER_DURATION_NS, 0);
  }
  bool mutate_buffer_duration_ns(uint64_t _buffer_duration_ns) {
    return SetField<uint64_t>(VT_BUFFER_DURATION_NS, _buffer_duration_ns, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ENABLE) &&
           VerifyField<uint64_t>(verifier, VT_BUFFER_DURATION_NS) &&
           verifier.EndTable();
  }
  AudioRequestMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(AudioRequestMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<AudioRequestMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AudioRequestMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct AudioRequestMessageBuilder {
  typedef AudioRequestMessage Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_enable(bool enable) {
    fbb_.AddElement<uint8_t>(AudioRequestMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
  }
  void add_buffer_duration_ns(uint64_t buffer_duration_ns) {
    fbb_.AddElement<uint64_t>(AudioRequestMessage::VT_BUFFER_DURATION_NS, buffer_duration_ns, 0);
  }
  explicit AudioRequestMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  AudioRequestMessageBuilder &operator=(const AudioRequestMessageBuilder &);
  flatbuffers::Offset<AudioRequestMessage> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<AudioRequestMessage>(end);
    return o;
  }
};

inline flatbuffers::Offset<AudioRequestMessage> CreateAudioRequestMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool enable = false,
    uint64_t buffer_duration_ns = 0) {
  AudioRequestMessageBuilder builder_(_fbb);
  builder_.add_buffer_duration_ns(buffer_duration_ns);
  builder_.add_enable(enable);
  return builder_.Finish();
}

flatbuffers::Offset<AudioRequestMessage> CreateAudioRequestMessage(flatbuffers::FlatBufferBuilder &_fbb, const AudioRequestMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct SensorRequestMessageT : public flatbuffers::NativeTable {
  typedef SensorRequestMessage TableType;
  bool enable;
  chre::power_test::SensorType sensor;
  uint64_t sampling_interval_ns;
  uint64_t latency_ns;
  SensorRequestMessageT()
      : enable(false),
        sensor(chre::power_test::SensorType::UNKNOWN),
        sampling_interval_ns(0),
        latency_ns(0) {
  }
};

/// Represents a message to ask the nanoapp to start / stop sampling / batching
/// a given sensor
struct SensorRequestMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SensorRequestMessageT NativeTableType;
  typedef SensorRequestMessageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ENABLE = 4,
    VT_SENSOR = 6,
    VT_SAMPLING_INTERVAL_NS = 8,
    VT_LATENCY_NS = 10
  };
  bool enable() const {
    return GetField<uint8_t>(VT_ENABLE, 0) != 0;
  }
  bool mutate_enable(bool _enable) {
    return SetField<uint8_t>(VT_ENABLE, static_cast<uint8_t>(_enable), 0);
  }
  chre::power_test::SensorType sensor() const {
    return static_cast<chre::power_test::SensorType>(GetField<uint8_t>(VT_SENSOR, 0));
  }
  bool mutate_sensor(chre::power_test::SensorType _sensor) {
    return SetField<uint8_t>(VT_SENSOR, static_cast<uint8_t>(_sensor), 0);
  }
  uint64_t sampling_interval_ns() const {
    return GetField<uint64_t>(VT_SAMPLING_INTERVAL_NS, 0);
  }
  bool mutate_sampling_interval_ns(uint64_t _sampling_interval_ns) {
    return SetField<uint64_t>(VT_SAMPLING_INTERVAL_NS, _sampling_interval_ns, 0);
  }
  uint64_t latency_ns() const {
    return GetField<uint64_t>(VT_LATENCY_NS, 0);
  }
  bool mutate_latency_ns(uint64_t _latency_ns) {
    return SetField<uint64_t>(VT_LATENCY_NS, _latency_ns, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ENABLE) &&
           VerifyField<uint8_t>(verifier, VT_SENSOR) &&
           VerifyField<uint64_t>(verifier, VT_SAMPLING_INTERVAL_NS) &&
           VerifyField<uint64_t>(verifier, VT_LATENCY_NS) &&
           verifier.EndTable();
  }
  SensorRequestMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(SensorRequestMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<SensorRequestMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SensorRequestMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct SensorRequestMessageBuilder {
  typedef SensorRequestMessage Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_enable(bool enable) {
    fbb_.AddElement<uint8_t>(SensorRequestMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
  }
  void add_sensor(chre::power_test::SensorType sensor) {
    fbb_.AddElement<uint8_t>(SensorRequestMessage::VT_SENSOR, static_cast<uint8_t>(sensor), 0);
  }
  void add_sampling_interval_ns(uint64_t sampling_interval_ns) {
    fbb_.AddElement<uint64_t>(SensorRequestMessage::VT_SAMPLING_INTERVAL_NS, sampling_interval_ns, 0);
  }
  void add_latency_ns(uint64_t latency_ns) {
    fbb_.AddElement<uint64_t>(SensorRequestMessage::VT_LATENCY_NS, latency_ns, 0);
  }
  explicit SensorRequestMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  SensorRequestMessageBuilder &operator=(const SensorRequestMessageBuilder &);
  flatbuffers::Offset<SensorRequestMessage> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SensorRequestMessage>(end);
    return o;
  }
};

inline flatbuffers::Offset<SensorRequestMessage> CreateSensorRequestMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool enable = false,
    chre::power_test::SensorType sensor = chre::power_test::SensorType::UNKNOWN,
    uint64_t sampling_interval_ns = 0,
    uint64_t latency_ns = 0) {
  SensorRequestMessageBuilder builder_(_fbb);
  builder_.add_latency_ns(latency_ns);
  builder_.add_sampling_interval_ns(sampling_interval_ns);
  builder_.add_sensor(sensor);
  builder_.add_enable(enable);
  return builder_.Finish();
}

flatbuffers::Offset<SensorRequestMessage> CreateSensorRequestMessage(flatbuffers::FlatBufferBuilder &_fbb, const SensorRequestMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct BreakItMessageT : public flatbuffers::NativeTable {
  typedef BreakItMessage TableType;
  bool enable;
  BreakItMessageT()
      : enable(false) {
  }
};

/// Represents a message to enable / disable break-it mode inside the nanoapp.
/// Break-it mode enables WiFi / GNSS / Cell to be queried every second and
/// enables all sensors at their fastest sampling rate.
struct BreakItMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef BreakItMessageT NativeTableType;
  typedef BreakItMessageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ENABLE = 4
  };
  bool enable() const {
    return GetField<uint8_t>(VT_ENABLE, 0) != 0;
  }
  bool mutate_enable(bool _enable) {
    return SetField<uint8_t>(VT_ENABLE, static_cast<uint8_t>(_enable), 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ENABLE) &&
           verifier.EndTable();
  }
  BreakItMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(BreakItMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<BreakItMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BreakItMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct BreakItMessageBuilder {
  typedef BreakItMessage Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_enable(bool enable) {
    fbb_.AddElement<uint8_t>(BreakItMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
  }
  explicit BreakItMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  BreakItMessageBuilder &operator=(const BreakItMessageBuilder &);
  flatbuffers::Offset<BreakItMessage> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<BreakItMessage>(end);
    return o;
  }
};

inline flatbuffers::Offset<BreakItMessage> CreateBreakItMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool enable = false) {
  BreakItMessageBuilder builder_(_fbb);
  builder_.add_enable(enable);
  return builder_.Finish();
}

flatbuffers::Offset<BreakItMessage> CreateBreakItMessage(flatbuffers::FlatBufferBuilder &_fbb, const BreakItMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct NanoappResponseMessageT : public flatbuffers::NativeTable {
  typedef NanoappResponseMessage TableType;
  bool success;
  NanoappResponseMessageT()
      : success(false) {
  }
};

/// Indicates whether the nanoapp successfully performed the requested action.
/// Any failures will be printed to the logs.
struct NanoappResponseMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef NanoappResponseMessageT NativeTableType;
  typedef NanoappResponseMessageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SUCCESS = 4
  };
  bool success() const {
    return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
  }
  bool mutate_success(bool _success) {
    return SetField<uint8_t>(VT_SUCCESS, static_cast<uint8_t>(_success), 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
           verifier.EndTable();
  }
  NanoappResponseMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(NanoappResponseMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<NanoappResponseMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappResponseMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct NanoappResponseMessageBuilder {
  typedef NanoappResponseMessage Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_success(bool success) {
    fbb_.AddElement<uint8_t>(NanoappResponseMessage::VT_SUCCESS, static_cast<uint8_t>(success), 0);
  }
  explicit NanoappResponseMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  NanoappResponseMessageBuilder &operator=(const NanoappResponseMessageBuilder &);
  flatbuffers::Offset<NanoappResponseMessage> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<NanoappResponseMessage>(end);
    return o;
  }
};

inline flatbuffers::Offset<NanoappResponseMessage> CreateNanoappResponseMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool success = false) {
  NanoappResponseMessageBuilder builder_(_fbb);
  builder_.add_success(success);
  return builder_.Finish();
}

flatbuffers::Offset<NanoappResponseMessage> CreateNanoappResponseMessage(flatbuffers::FlatBufferBuilder &_fbb, const NanoappResponseMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct GnssMeasurementMessageT : public flatbuffers::NativeTable {
  typedef GnssMeasurementMessage TableType;
  bool enable;
  uint32_t min_interval_millis;
  GnssMeasurementMessageT()
      : enable(false),
        min_interval_millis(0) {
  }
};

/// Represents a message to ask the nanoapp to start or stop Gnss measurement
/// sampling at the requested interval
struct GnssMeasurementMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef GnssMeasurementMessageT NativeTableType;
  typedef GnssMeasurementMessageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ENABLE = 4,
    VT_MIN_INTERVAL_MILLIS = 6
  };
  bool enable() const {
    return GetField<uint8_t>(VT_ENABLE, 0) != 0;
  }
  bool mutate_enable(bool _enable) {
    return SetField<uint8_t>(VT_ENABLE, static_cast<uint8_t>(_enable), 0);
  }
  uint32_t min_interval_millis() const {
    return GetField<uint32_t>(VT_MIN_INTERVAL_MILLIS, 0);
  }
  bool mutate_min_interval_millis(uint32_t _min_interval_millis) {
    return SetField<uint32_t>(VT_MIN_INTERVAL_MILLIS, _min_interval_millis, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ENABLE) &&
           VerifyField<uint32_t>(verifier, VT_MIN_INTERVAL_MILLIS) &&
           verifier.EndTable();
  }
  GnssMeasurementMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(GnssMeasurementMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<GnssMeasurementMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GnssMeasurementMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct GnssMeasurementMessageBuilder {
  typedef GnssMeasurementMessage Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_enable(bool enable) {
    fbb_.AddElement<uint8_t>(GnssMeasurementMessage::VT_ENABLE, static_cast<uint8_t>(enable), 0);
  }
  void add_min_interval_millis(uint32_t min_interval_millis) {
    fbb_.AddElement<uint32_t>(GnssMeasurementMessage::VT_MIN_INTERVAL_MILLIS, min_interval_millis, 0);
  }
  explicit GnssMeasurementMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  GnssMeasurementMessageBuilder &operator=(const GnssMeasurementMessageBuilder &);
  flatbuffers::Offset<GnssMeasurementMessage> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<GnssMeasurementMessage>(end);
    return o;
  }
};

inline flatbuffers::Offset<GnssMeasurementMessage> CreateGnssMeasurementMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool enable = false,
    uint32_t min_interval_millis = 0) {
  GnssMeasurementMessageBuilder builder_(_fbb);
  builder_.add_min_interval_millis(min_interval_millis);
  builder_.add_enable(enable);
  return builder_.Finish();
}

flatbuffers::Offset<GnssMeasurementMessage> CreateGnssMeasurementMessage(flatbuffers::FlatBufferBuilder &_fbb, const GnssMeasurementMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct WifiNanSubMessageT : public flatbuffers::NativeTable {
  typedef WifiNanSubMessage TableType;
  uint8_t sub_type;
  std::vector<uint8_t> service_name;
  std::vector<uint8_t> service_specific_info;
  std::vector<uint8_t> match_filter;
  WifiNanSubMessageT()
      : sub_type(0) {
  }
};

/// Represents a message to ask the nanoapp to start a NAN subscription session.
/// See chreWifiNanSubscribeConfig for how to fill in this message.
struct WifiNanSubMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef WifiNanSubMessageT NativeTableType;
  typedef WifiNanSubMessageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SUB_TYPE = 4,
    VT_SERVICE_NAME = 6,
    VT_SERVICE_SPECIFIC_INFO = 8,
    VT_MATCH_FILTER = 10
  };
  uint8_t sub_type() const {
    return GetField<uint8_t>(VT_SUB_TYPE, 0);
  }
  bool mutate_sub_type(uint8_t _sub_type) {
    return SetField<uint8_t>(VT_SUB_TYPE, _sub_type, 0);
  }
  const flatbuffers::Vector<uint8_t> *service_name() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_SERVICE_NAME);
  }
  flatbuffers::Vector<uint8_t> *mutable_service_name() {
    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_SERVICE_NAME);
  }
  const flatbuffers::Vector<uint8_t> *service_specific_info() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_SERVICE_SPECIFIC_INFO);
  }
  flatbuffers::Vector<uint8_t> *mutable_service_specific_info() {
    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_SERVICE_SPECIFIC_INFO);
  }
  const flatbuffers::Vector<uint8_t> *match_filter() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MATCH_FILTER);
  }
  flatbuffers::Vector<uint8_t> *mutable_match_filter() {
    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_MATCH_FILTER);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_SUB_TYPE) &&
           VerifyOffset(verifier, VT_SERVICE_NAME) &&
           verifier.VerifyVector(service_name()) &&
           VerifyOffset(verifier, VT_SERVICE_SPECIFIC_INFO) &&
           verifier.VerifyVector(service_specific_info()) &&
           VerifyOffset(verifier, VT_MATCH_FILTER) &&
           verifier.VerifyVector(match_filter()) &&
           verifier.EndTable();
  }
  WifiNanSubMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(WifiNanSubMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<WifiNanSubMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WifiNanSubMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct WifiNanSubMessageBuilder {
  typedef WifiNanSubMessage Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_sub_type(uint8_t sub_type) {
    fbb_.AddElement<uint8_t>(WifiNanSubMessage::VT_SUB_TYPE, sub_type, 0);
  }
  void add_service_name(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> service_name) {
    fbb_.AddOffset(WifiNanSubMessage::VT_SERVICE_NAME, service_name);
  }
  void add_service_specific_info(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> service_specific_info) {
    fbb_.AddOffset(WifiNanSubMessage::VT_SERVICE_SPECIFIC_INFO, service_specific_info);
  }
  void add_match_filter(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> match_filter) {
    fbb_.AddOffset(WifiNanSubMessage::VT_MATCH_FILTER, match_filter);
  }
  explicit WifiNanSubMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  WifiNanSubMessageBuilder &operator=(const WifiNanSubMessageBuilder &);
  flatbuffers::Offset<WifiNanSubMessage> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<WifiNanSubMessage>(end);
    return o;
  }
};

inline flatbuffers::Offset<WifiNanSubMessage> CreateWifiNanSubMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t sub_type = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> service_name = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> service_specific_info = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> match_filter = 0) {
  WifiNanSubMessageBuilder builder_(_fbb);
  builder_.add_match_filter(match_filter);
  builder_.add_service_specific_info(service_specific_info);
  builder_.add_service_name(service_name);
  builder_.add_sub_type(sub_type);
  return builder_.Finish();
}

inline flatbuffers::Offset<WifiNanSubMessage> CreateWifiNanSubMessageDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t sub_type = 0,
    const std::vector<uint8_t> *service_name = nullptr,
    const std::vector<uint8_t> *service_specific_info = nullptr,
    const std::vector<uint8_t> *match_filter = nullptr) {
  auto service_name__ = service_name ? _fbb.CreateVector<uint8_t>(*service_name) : 0;
  auto service_specific_info__ = service_specific_info ? _fbb.CreateVector<uint8_t>(*service_specific_info) : 0;
  auto match_filter__ = match_filter ? _fbb.CreateVector<uint8_t>(*match_filter) : 0;
  return chre::power_test::CreateWifiNanSubMessage(
      _fbb,
      sub_type,
      service_name__,
      service_specific_info__,
      match_filter__);
}

flatbuffers::Offset<WifiNanSubMessage> CreateWifiNanSubMessage(flatbuffers::FlatBufferBuilder &_fbb, const WifiNanSubMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct WifiNanSubCancelMessageT : public flatbuffers::NativeTable {
  typedef WifiNanSubCancelMessage TableType;
  uint32_t subscription_id;
  WifiNanSubCancelMessageT()
      : subscription_id(0) {
  }
};

/// Represents a messages to ask the nanoapp to cancel an ongoing subscription
struct WifiNanSubCancelMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef WifiNanSubCancelMessageT NativeTableType;
  typedef WifiNanSubCancelMessageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SUBSCRIPTION_ID = 4
  };
  uint32_t subscription_id() const {
    return GetField<uint32_t>(VT_SUBSCRIPTION_ID, 0);
  }
  bool mutate_subscription_id(uint32_t _subscription_id) {
    return SetField<uint32_t>(VT_SUBSCRIPTION_ID, _subscription_id, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_SUBSCRIPTION_ID) &&
           verifier.EndTable();
  }
  WifiNanSubCancelMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(WifiNanSubCancelMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<WifiNanSubCancelMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WifiNanSubCancelMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct WifiNanSubCancelMessageBuilder {
  typedef WifiNanSubCancelMessage Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_subscription_id(uint32_t subscription_id) {
    fbb_.AddElement<uint32_t>(WifiNanSubCancelMessage::VT_SUBSCRIPTION_ID, subscription_id, 0);
  }
  explicit WifiNanSubCancelMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  WifiNanSubCancelMessageBuilder &operator=(const WifiNanSubCancelMessageBuilder &);
  flatbuffers::Offset<WifiNanSubCancelMessage> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<WifiNanSubCancelMessage>(end);
    return o;
  }
};

inline flatbuffers::Offset<WifiNanSubCancelMessage> CreateWifiNanSubCancelMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t subscription_id = 0) {
  WifiNanSubCancelMessageBuilder builder_(_fbb);
  builder_.add_subscription_id(subscription_id);
  return builder_.Finish();
}

flatbuffers::Offset<WifiNanSubCancelMessage> CreateWifiNanSubCancelMessage(flatbuffers::FlatBufferBuilder &_fbb, const WifiNanSubCancelMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct WifiNanSubResponseMessageT : public flatbuffers::NativeTable {
  typedef WifiNanSubResponseMessage TableType;
  bool success;
  uint32_t subscription_id;
  WifiNanSubResponseMessageT()
      : success(false),
        subscription_id(0) {
  }
};

/// Represents a message from the nanoapp indicating whether a subscription
/// request succeeded
struct WifiNanSubResponseMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef WifiNanSubResponseMessageT NativeTableType;
  typedef WifiNanSubResponseMessageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SUCCESS = 4,
    VT_SUBSCRIPTION_ID = 6
  };
  bool success() const {
    return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
  }
  bool mutate_success(bool _success) {
    return SetField<uint8_t>(VT_SUCCESS, static_cast<uint8_t>(_success), 0);
  }
  uint32_t subscription_id() const {
    return GetField<uint32_t>(VT_SUBSCRIPTION_ID, 0);
  }
  bool mutate_subscription_id(uint32_t _subscription_id) {
    return SetField<uint32_t>(VT_SUBSCRIPTION_ID, _subscription_id, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
           VerifyField<uint32_t>(verifier, VT_SUBSCRIPTION_ID) &&
           verifier.EndTable();
  }
  WifiNanSubResponseMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(WifiNanSubResponseMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<WifiNanSubResponseMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WifiNanSubResponseMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct WifiNanSubResponseMessageBuilder {
  typedef WifiNanSubResponseMessage Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_success(bool success) {
    fbb_.AddElement<uint8_t>(WifiNanSubResponseMessage::VT_SUCCESS, static_cast<uint8_t>(success), 0);
  }
  void add_subscription_id(uint32_t subscription_id) {
    fbb_.AddElement<uint32_t>(WifiNanSubResponseMessage::VT_SUBSCRIPTION_ID, subscription_id, 0);
  }
  explicit WifiNanSubResponseMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  WifiNanSubResponseMessageBuilder &operator=(const WifiNanSubResponseMessageBuilder &);
  flatbuffers::Offset<WifiNanSubResponseMessage> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<WifiNanSubResponseMessage>(end);
    return o;
  }
};

inline flatbuffers::Offset<WifiNanSubResponseMessage> CreateWifiNanSubResponseMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool success = false,
    uint32_t subscription_id = 0) {
  WifiNanSubResponseMessageBuilder builder_(_fbb);
  builder_.add_subscription_id(subscription_id);
  builder_.add_success(success);
  return builder_.Finish();
}

flatbuffers::Offset<WifiNanSubResponseMessage> CreateWifiNanSubResponseMessage(flatbuffers::FlatBufferBuilder &_fbb, const WifiNanSubResponseMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

inline TimerMessageT *TimerMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  std::unique_ptr<chre::power_test::TimerMessageT> _o = std::unique_ptr<chre::power_test::TimerMessageT>(new TimerMessageT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void TimerMessage::UnPackTo(TimerMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = enable(); _o->enable = _e; }
  { auto _e = wakeup_interval_ns(); _o->wakeup_interval_ns = _e; }
}

inline flatbuffers::Offset<TimerMessage> TimerMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TimerMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateTimerMessage(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<TimerMessage> CreateTimerMessage(flatbuffers::FlatBufferBuilder &_fbb, const TimerMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TimerMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _enable = _o->enable;
  auto _wakeup_interval_ns = _o->wakeup_interval_ns;
  return chre::power_test::CreateTimerMessage(
      _fbb,
      _enable,
      _wakeup_interval_ns);
}

inline WifiScanMessageT *WifiScanMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  std::unique_ptr<chre::power_test::WifiScanMessageT> _o = std::unique_ptr<chre::power_test::WifiScanMessageT>(new WifiScanMessageT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void WifiScanMessage::UnPackTo(WifiScanMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = enable(); _o->enable = _e; }
  { auto _e = scan_interval_ns(); _o->scan_interval_ns = _e; }
  { auto _e = scan_type(); _o->scan_type = _e; }
  { auto _e = radio_chain(); _o->radio_chain = _e; }
  { auto _e = channel_set(); _o->channel_set = _e; }
}

inline flatbuffers::Offset<WifiScanMessage> WifiScanMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WifiScanMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateWifiScanMessage(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<WifiScanMessage> CreateWifiScanMessage(flatbuffers::FlatBufferBuilder &_fbb, const WifiScanMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WifiScanMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _enable = _o->enable;
  auto _scan_interval_ns = _o->scan_interval_ns;
  auto _scan_type = _o->scan_type;
  auto _radio_chain = _o->radio_chain;
  auto _channel_set = _o->channel_set;
  return chre::power_test::CreateWifiScanMessage(
      _fbb,
      _enable,
      _scan_interval_ns,
      _scan_type,
      _radio_chain,
      _channel_set);
}

inline GnssLocationMessageT *GnssLocationMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  std::unique_ptr<chre::power_test::GnssLocationMessageT> _o = std::unique_ptr<chre::power_test::GnssLocationMessageT>(new GnssLocationMessageT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void GnssLocationMessage::UnPackTo(GnssLocationMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = enable(); _o->enable = _e; }
  { auto _e = scan_interval_millis(); _o->scan_interval_millis = _e; }
  { auto _e = min_time_to_next_fix_millis(); _o->min_time_to_next_fix_millis = _e; }
}

inline flatbuffers::Offset<GnssLocationMessage> GnssLocationMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GnssLocationMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateGnssLocationMessage(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<GnssLocationMessage> CreateGnssLocationMessage(flatbuffers::FlatBufferBuilder &_fbb, const GnssLocationMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GnssLocationMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _enable = _o->enable;
  auto _scan_interval_millis = _o->scan_interval_millis;
  auto _min_time_to_next_fix_millis = _o->min_time_to_next_fix_millis;
  return chre::power_test::CreateGnssLocationMessage(
      _fbb,
      _enable,
      _scan_interval_millis,
      _min_time_to_next_fix_millis);
}

inline CellQueryMessageT *CellQueryMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  std::unique_ptr<chre::power_test::CellQueryMessageT> _o = std::unique_ptr<chre::power_test::CellQueryMessageT>(new CellQueryMessageT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void CellQueryMessage::UnPackTo(CellQueryMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = enable(); _o->enable = _e; }
  { auto _e = query_interval_ns(); _o->query_interval_ns = _e; }
}

inline flatbuffers::Offset<CellQueryMessage> CellQueryMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CellQueryMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateCellQueryMessage(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<CellQueryMessage> CreateCellQueryMessage(flatbuffers::FlatBufferBuilder &_fbb, const CellQueryMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CellQueryMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _enable = _o->enable;
  auto _query_interval_ns = _o->query_interval_ns;
  return chre::power_test::CreateCellQueryMessage(
      _fbb,
      _enable,
      _query_interval_ns);
}

inline AudioRequestMessageT *AudioRequestMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  std::unique_ptr<chre::power_test::AudioRequestMessageT> _o = std::unique_ptr<chre::power_test::AudioRequestMessageT>(new AudioRequestMessageT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void AudioRequestMessage::UnPackTo(AudioRequestMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = enable(); _o->enable = _e; }
  { auto _e = buffer_duration_ns(); _o->buffer_duration_ns = _e; }
}

inline flatbuffers::Offset<AudioRequestMessage> AudioRequestMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AudioRequestMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateAudioRequestMessage(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<AudioRequestMessage> CreateAudioRequestMessage(flatbuffers::FlatBufferBuilder &_fbb, const AudioRequestMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AudioRequestMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _enable = _o->enable;
  auto _buffer_duration_ns = _o->buffer_duration_ns;
  return chre::power_test::CreateAudioRequestMessage(
      _fbb,
      _enable,
      _buffer_duration_ns);
}

inline SensorRequestMessageT *SensorRequestMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  std::unique_ptr<chre::power_test::SensorRequestMessageT> _o = std::unique_ptr<chre::power_test::SensorRequestMessageT>(new SensorRequestMessageT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void SensorRequestMessage::UnPackTo(SensorRequestMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = enable(); _o->enable = _e; }
  { auto _e = sensor(); _o->sensor = _e; }
  { auto _e = sampling_interval_ns(); _o->sampling_interval_ns = _e; }
  { auto _e = latency_ns(); _o->latency_ns = _e; }
}

inline flatbuffers::Offset<SensorRequestMessage> SensorRequestMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SensorRequestMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateSensorRequestMessage(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<SensorRequestMessage> CreateSensorRequestMessage(flatbuffers::FlatBufferBuilder &_fbb, const SensorRequestMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SensorRequestMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _enable = _o->enable;
  auto _sensor = _o->sensor;
  auto _sampling_interval_ns = _o->sampling_interval_ns;
  auto _latency_ns = _o->latency_ns;
  return chre::power_test::CreateSensorRequestMessage(
      _fbb,
      _enable,
      _sensor,
      _sampling_interval_ns,
      _latency_ns);
}

inline BreakItMessageT *BreakItMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  std::unique_ptr<chre::power_test::BreakItMessageT> _o = std::unique_ptr<chre::power_test::BreakItMessageT>(new BreakItMessageT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void BreakItMessage::UnPackTo(BreakItMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = enable(); _o->enable = _e; }
}

inline flatbuffers::Offset<BreakItMessage> BreakItMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BreakItMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateBreakItMessage(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<BreakItMessage> CreateBreakItMessage(flatbuffers::FlatBufferBuilder &_fbb, const BreakItMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BreakItMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _enable = _o->enable;
  return chre::power_test::CreateBreakItMessage(
      _fbb,
      _enable);
}

inline NanoappResponseMessageT *NanoappResponseMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  std::unique_ptr<chre::power_test::NanoappResponseMessageT> _o = std::unique_ptr<chre::power_test::NanoappResponseMessageT>(new NanoappResponseMessageT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void NanoappResponseMessage::UnPackTo(NanoappResponseMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = success(); _o->success = _e; }
}

inline flatbuffers::Offset<NanoappResponseMessage> NanoappResponseMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappResponseMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateNanoappResponseMessage(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<NanoappResponseMessage> CreateNanoappResponseMessage(flatbuffers::FlatBufferBuilder &_fbb, const NanoappResponseMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NanoappResponseMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _success = _o->success;
  return chre::power_test::CreateNanoappResponseMessage(
      _fbb,
      _success);
}

inline GnssMeasurementMessageT *GnssMeasurementMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  std::unique_ptr<chre::power_test::GnssMeasurementMessageT> _o = std::unique_ptr<chre::power_test::GnssMeasurementMessageT>(new GnssMeasurementMessageT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void GnssMeasurementMessage::UnPackTo(GnssMeasurementMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = enable(); _o->enable = _e; }
  { auto _e = min_interval_millis(); _o->min_interval_millis = _e; }
}

inline flatbuffers::Offset<GnssMeasurementMessage> GnssMeasurementMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GnssMeasurementMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateGnssMeasurementMessage(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<GnssMeasurementMessage> CreateGnssMeasurementMessage(flatbuffers::FlatBufferBuilder &_fbb, const GnssMeasurementMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GnssMeasurementMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _enable = _o->enable;
  auto _min_interval_millis = _o->min_interval_millis;
  return chre::power_test::CreateGnssMeasurementMessage(
      _fbb,
      _enable,
      _min_interval_millis);
}

inline WifiNanSubMessageT *WifiNanSubMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  std::unique_ptr<chre::power_test::WifiNanSubMessageT> _o = std::unique_ptr<chre::power_test::WifiNanSubMessageT>(new WifiNanSubMessageT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void WifiNanSubMessage::UnPackTo(WifiNanSubMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = sub_type(); _o->sub_type = _e; }
  { auto _e = service_name(); if (_e) { _o->service_name.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->service_name[_i] = _e->Get(_i); } } }
  { auto _e = service_specific_info(); if (_e) { _o->service_specific_info.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->service_specific_info[_i] = _e->Get(_i); } } }
  { auto _e = match_filter(); if (_e) { _o->match_filter.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->match_filter[_i] = _e->Get(_i); } } }
}

inline flatbuffers::Offset<WifiNanSubMessage> WifiNanSubMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WifiNanSubMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateWifiNanSubMessage(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<WifiNanSubMessage> CreateWifiNanSubMessage(flatbuffers::FlatBufferBuilder &_fbb, const WifiNanSubMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WifiNanSubMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _sub_type = _o->sub_type;
  auto _service_name = _o->service_name.size() ? _fbb.CreateVector(_o->service_name) : 0;
  auto _service_specific_info = _o->service_specific_info.size() ? _fbb.CreateVector(_o->service_specific_info) : 0;
  auto _match_filter = _o->match_filter.size() ? _fbb.CreateVector(_o->match_filter) : 0;
  return chre::power_test::CreateWifiNanSubMessage(
      _fbb,
      _sub_type,
      _service_name,
      _service_specific_info,
      _match_filter);
}

inline WifiNanSubCancelMessageT *WifiNanSubCancelMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  std::unique_ptr<chre::power_test::WifiNanSubCancelMessageT> _o = std::unique_ptr<chre::power_test::WifiNanSubCancelMessageT>(new WifiNanSubCancelMessageT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void WifiNanSubCancelMessage::UnPackTo(WifiNanSubCancelMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = subscription_id(); _o->subscription_id = _e; }
}

inline flatbuffers::Offset<WifiNanSubCancelMessage> WifiNanSubCancelMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WifiNanSubCancelMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateWifiNanSubCancelMessage(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<WifiNanSubCancelMessage> CreateWifiNanSubCancelMessage(flatbuffers::FlatBufferBuilder &_fbb, const WifiNanSubCancelMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WifiNanSubCancelMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _subscription_id = _o->subscription_id;
  return chre::power_test::CreateWifiNanSubCancelMessage(
      _fbb,
      _subscription_id);
}

inline WifiNanSubResponseMessageT *WifiNanSubResponseMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  std::unique_ptr<chre::power_test::WifiNanSubResponseMessageT> _o = std::unique_ptr<chre::power_test::WifiNanSubResponseMessageT>(new WifiNanSubResponseMessageT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void WifiNanSubResponseMessage::UnPackTo(WifiNanSubResponseMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = success(); _o->success = _e; }
  { auto _e = subscription_id(); _o->subscription_id = _e; }
}

inline flatbuffers::Offset<WifiNanSubResponseMessage> WifiNanSubResponseMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WifiNanSubResponseMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateWifiNanSubResponseMessage(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<WifiNanSubResponseMessage> CreateWifiNanSubResponseMessage(flatbuffers::FlatBufferBuilder &_fbb, const WifiNanSubResponseMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WifiNanSubResponseMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _success = _o->success;
  auto _subscription_id = _o->subscription_id;
  return chre::power_test::CreateWifiNanSubResponseMessage(
      _fbb,
      _success,
      _subscription_id);
}

}  // namespace power_test
}  // namespace chre

#endif  // FLATBUFFERS_GENERATED_CHREPOWERTEST_CHRE_POWER_TEST_H_