xref: /system/chre/host/common/include/chre_host/generated/host_messages_generated.h

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


#ifndef FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_
#define FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_

#include "flatbuffers/flatbuffers.h"

namespace chre {
namespace fbs {

struct NanoappMessage;
struct NanoappMessageBuilder;
struct NanoappMessageT;

struct HubInfoRequest;
struct HubInfoRequestBuilder;
struct HubInfoRequestT;

struct HubInfoResponse;
struct HubInfoResponseBuilder;
struct HubInfoResponseT;

struct NanoappListRequest;
struct NanoappListRequestBuilder;
struct NanoappListRequestT;

struct NanoappRpcService;
struct NanoappRpcServiceBuilder;
struct NanoappRpcServiceT;

struct NanoappListEntry;
struct NanoappListEntryBuilder;
struct NanoappListEntryT;

struct NanoappListResponse;
struct NanoappListResponseBuilder;
struct NanoappListResponseT;

struct LoadNanoappRequest;
struct LoadNanoappRequestBuilder;
struct LoadNanoappRequestT;

struct LoadNanoappResponse;
struct LoadNanoappResponseBuilder;
struct LoadNanoappResponseT;

struct UnloadNanoappRequest;
struct UnloadNanoappRequestBuilder;
struct UnloadNanoappRequestT;

struct UnloadNanoappResponse;
struct UnloadNanoappResponseBuilder;
struct UnloadNanoappResponseT;

struct LogMessage;
struct LogMessageBuilder;
struct LogMessageT;

struct TimeSyncMessage;
struct TimeSyncMessageBuilder;
struct TimeSyncMessageT;

struct DebugDumpRequest;
struct DebugDumpRequestBuilder;
struct DebugDumpRequestT;

struct DebugDumpData;
struct DebugDumpDataBuilder;
struct DebugDumpDataT;

struct DebugDumpResponse;
struct DebugDumpResponseBuilder;
struct DebugDumpResponseT;

struct TimeSyncRequest;
struct TimeSyncRequestBuilder;
struct TimeSyncRequestT;

struct LowPowerMicAccessRequest;
struct LowPowerMicAccessRequestBuilder;
struct LowPowerMicAccessRequestT;

struct LowPowerMicAccessRelease;
struct LowPowerMicAccessReleaseBuilder;
struct LowPowerMicAccessReleaseT;

struct SettingChangeMessage;
struct SettingChangeMessageBuilder;
struct SettingChangeMessageT;

struct LogMessageV2;
struct LogMessageV2Builder;
struct LogMessageV2T;

struct SelfTestRequest;
struct SelfTestRequestBuilder;
struct SelfTestRequestT;

struct SelfTestResponse;
struct SelfTestResponseBuilder;
struct SelfTestResponseT;

struct HostEndpointConnected;
struct HostEndpointConnectedBuilder;
struct HostEndpointConnectedT;

struct HostEndpointDisconnected;
struct HostEndpointDisconnectedBuilder;
struct HostEndpointDisconnectedT;

struct MetricLog;
struct MetricLogBuilder;
struct MetricLogT;

struct BatchedMetricLog;
struct BatchedMetricLogBuilder;
struct BatchedMetricLogT;

struct NanConfigurationRequest;
struct NanConfigurationRequestBuilder;
struct NanConfigurationRequestT;

struct NanConfigurationUpdate;
struct NanConfigurationUpdateBuilder;
struct NanConfigurationUpdateT;

struct DebugConfiguration;
struct DebugConfigurationBuilder;
struct DebugConfigurationT;

struct HostAddress;

struct MessageContainer;
struct MessageContainerBuilder;
struct MessageContainerT;

/// An enum describing the setting type.
enum class Setting : int8_t {
  LOCATION = 0,
  WIFI_AVAILABLE = 1,
  AIRPLANE_MODE = 2,
  MICROPHONE = 3,
  BLE_AVAILABLE = 4,
  MIN = LOCATION,
  MAX = BLE_AVAILABLE
};

inline const Setting (&EnumValuesSetting())[5] {
  static const Setting values[] = {
    Setting::LOCATION,
    Setting::WIFI_AVAILABLE,
    Setting::AIRPLANE_MODE,
    Setting::MICROPHONE,
    Setting::BLE_AVAILABLE
  };
  return values;
}

inline const char * const *EnumNamesSetting() {
  static const char * const names[6] = {
    "LOCATION",
    "WIFI_AVAILABLE",
    "AIRPLANE_MODE",
    "MICROPHONE",
    "BLE_AVAILABLE",
    nullptr
  };
  return names;
}

inline const char *EnumNameSetting(Setting e) {
  if (flatbuffers::IsOutRange(e, Setting::LOCATION, Setting::BLE_AVAILABLE)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesSetting()[index];
}

/// An enum describing the state of a setting.
enum class SettingState : int8_t {
  DISABLED = 0,
  ENABLED = 1,
  MIN = DISABLED,
  MAX = ENABLED
};

inline const SettingState (&EnumValuesSettingState())[2] {
  static const SettingState values[] = {
    SettingState::DISABLED,
    SettingState::ENABLED
  };
  return values;
}

inline const char * const *EnumNamesSettingState() {
  static const char * const names[3] = {
    "DISABLED",
    "ENABLED",
    nullptr
  };
  return names;
}

inline const char *EnumNameSettingState(SettingState e) {
  if (flatbuffers::IsOutRange(e, SettingState::DISABLED, SettingState::ENABLED)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesSettingState()[index];
}

enum class LogLevel : int8_t {
  ERROR = 1,
  WARNING = 2,
  INFO = 3,
  DEBUG = 4,
  VERBOSE = 5,
  MIN = ERROR,
  MAX = VERBOSE
};

inline const LogLevel (&EnumValuesLogLevel())[5] {
  static const LogLevel values[] = {
    LogLevel::ERROR,
    LogLevel::WARNING,
    LogLevel::INFO,
    LogLevel::DEBUG,
    LogLevel::VERBOSE
  };
  return values;
}

inline const char * const *EnumNamesLogLevel() {
  static const char * const names[6] = {
    "ERROR",
    "WARNING",
    "INFO",
    "DEBUG",
    "VERBOSE",
    nullptr
  };
  return names;
}

inline const char *EnumNameLogLevel(LogLevel e) {
  if (flatbuffers::IsOutRange(e, LogLevel::ERROR, LogLevel::VERBOSE)) return "";
  const size_t index = static_cast<size_t>(e) - static_cast<size_t>(LogLevel::ERROR);
  return EnumNamesLogLevel()[index];
}

enum class LogType : int8_t {
  STRING = 0,
  TOKENIZED = 1,
  BLUETOOTH = 2,
  MIN = STRING,
  MAX = BLUETOOTH
};

inline const LogType (&EnumValuesLogType())[3] {
  static const LogType values[] = {
    LogType::STRING,
    LogType::TOKENIZED,
    LogType::BLUETOOTH
  };
  return values;
}

inline const char * const *EnumNamesLogType() {
  static const char * const names[4] = {
    "STRING",
    "TOKENIZED",
    "BLUETOOTH",
    nullptr
  };
  return names;
}

inline const char *EnumNameLogType(LogType e) {
  if (flatbuffers::IsOutRange(e, LogType::STRING, LogType::BLUETOOTH)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesLogType()[index];
}

enum class BtSnoopDirection : int8_t {
  INCOMING_FROM_BT_CONTROLLER = 0,
  OUTGOING_TO_ARBITER = 1,
  MIN = INCOMING_FROM_BT_CONTROLLER,
  MAX = OUTGOING_TO_ARBITER
};

inline const BtSnoopDirection (&EnumValuesBtSnoopDirection())[2] {
  static const BtSnoopDirection values[] = {
    BtSnoopDirection::INCOMING_FROM_BT_CONTROLLER,
    BtSnoopDirection::OUTGOING_TO_ARBITER
  };
  return values;
}

inline const char * const *EnumNamesBtSnoopDirection() {
  static const char * const names[3] = {
    "INCOMING_FROM_BT_CONTROLLER",
    "OUTGOING_TO_ARBITER",
    nullptr
  };
  return names;
}

inline const char *EnumNameBtSnoopDirection(BtSnoopDirection e) {
  if (flatbuffers::IsOutRange(e, BtSnoopDirection::INCOMING_FROM_BT_CONTROLLER, BtSnoopDirection::OUTGOING_TO_ARBITER)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesBtSnoopDirection()[index];
}

/// A union that joins together all possible messages. Note that in FlatBuffers,
/// unions have an implicit type
enum class ChreMessage : uint8_t {
  NONE = 0,
  NanoappMessage = 1,
  HubInfoRequest = 2,
  HubInfoResponse = 3,
  NanoappListRequest = 4,
  NanoappListResponse = 5,
  LoadNanoappRequest = 6,
  LoadNanoappResponse = 7,
  UnloadNanoappRequest = 8,
  UnloadNanoappResponse = 9,
  LogMessage = 10,
  TimeSyncMessage = 11,
  DebugDumpRequest = 12,
  DebugDumpData = 13,
  DebugDumpResponse = 14,
  TimeSyncRequest = 15,
  LowPowerMicAccessRequest = 16,
  LowPowerMicAccessRelease = 17,
  SettingChangeMessage = 18,
  LogMessageV2 = 19,
  SelfTestRequest = 20,
  SelfTestResponse = 21,
  HostEndpointConnected = 22,
  HostEndpointDisconnected = 23,
  MetricLog = 24,
  BatchedMetricLog = 25,
  NanConfigurationRequest = 26,
  NanConfigurationUpdate = 27,
  DebugConfiguration = 28,
  MIN = NONE,
  MAX = DebugConfiguration
};

inline const ChreMessage (&EnumValuesChreMessage())[29] {
  static const ChreMessage values[] = {
    ChreMessage::NONE,
    ChreMessage::NanoappMessage,
    ChreMessage::HubInfoRequest,
    ChreMessage::HubInfoResponse,
    ChreMessage::NanoappListRequest,
    ChreMessage::NanoappListResponse,
    ChreMessage::LoadNanoappRequest,
    ChreMessage::LoadNanoappResponse,
    ChreMessage::UnloadNanoappRequest,
    ChreMessage::UnloadNanoappResponse,
    ChreMessage::LogMessage,
    ChreMessage::TimeSyncMessage,
    ChreMessage::DebugDumpRequest,
    ChreMessage::DebugDumpData,
    ChreMessage::DebugDumpResponse,
    ChreMessage::TimeSyncRequest,
    ChreMessage::LowPowerMicAccessRequest,
    ChreMessage::LowPowerMicAccessRelease,
    ChreMessage::SettingChangeMessage,
    ChreMessage::LogMessageV2,
    ChreMessage::SelfTestRequest,
    ChreMessage::SelfTestResponse,
    ChreMessage::HostEndpointConnected,
    ChreMessage::HostEndpointDisconnected,
    ChreMessage::MetricLog,
    ChreMessage::BatchedMetricLog,
    ChreMessage::NanConfigurationRequest,
    ChreMessage::NanConfigurationUpdate,
    ChreMessage::DebugConfiguration
  };
  return values;
}

inline const char * const *EnumNamesChreMessage() {
  static const char * const names[30] = {
    "NONE",
    "NanoappMessage",
    "HubInfoRequest",
    "HubInfoResponse",
    "NanoappListRequest",
    "NanoappListResponse",
    "LoadNanoappRequest",
    "LoadNanoappResponse",
    "UnloadNanoappRequest",
    "UnloadNanoappResponse",
    "LogMessage",
    "TimeSyncMessage",
    "DebugDumpRequest",
    "DebugDumpData",
    "DebugDumpResponse",
    "TimeSyncRequest",
    "LowPowerMicAccessRequest",
    "LowPowerMicAccessRelease",
    "SettingChangeMessage",
    "LogMessageV2",
    "SelfTestRequest",
    "SelfTestResponse",
    "HostEndpointConnected",
    "HostEndpointDisconnected",
    "MetricLog",
    "BatchedMetricLog",
    "NanConfigurationRequest",
    "NanConfigurationUpdate",
    "DebugConfiguration",
    nullptr
  };
  return names;
}

inline const char *EnumNameChreMessage(ChreMessage e) {
  if (flatbuffers::IsOutRange(e, ChreMessage::NONE, ChreMessage::DebugConfiguration)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesChreMessage()[index];
}

template<typename T> struct ChreMessageTraits {
  static const ChreMessage enum_value = ChreMessage::NONE;
};

template<> struct ChreMessageTraits<chre::fbs::NanoappMessage> {
  static const ChreMessage enum_value = ChreMessage::NanoappMessage;
};

template<> struct ChreMessageTraits<chre::fbs::HubInfoRequest> {
  static const ChreMessage enum_value = ChreMessage::HubInfoRequest;
};

template<> struct ChreMessageTraits<chre::fbs::HubInfoResponse> {
  static const ChreMessage enum_value = ChreMessage::HubInfoResponse;
};

template<> struct ChreMessageTraits<chre::fbs::NanoappListRequest> {
  static const ChreMessage enum_value = ChreMessage::NanoappListRequest;
};

template<> struct ChreMessageTraits<chre::fbs::NanoappListResponse> {
  static const ChreMessage enum_value = ChreMessage::NanoappListResponse;
};

template<> struct ChreMessageTraits<chre::fbs::LoadNanoappRequest> {
  static const ChreMessage enum_value = ChreMessage::LoadNanoappRequest;
};

template<> struct ChreMessageTraits<chre::fbs::LoadNanoappResponse> {
  static const ChreMessage enum_value = ChreMessage::LoadNanoappResponse;
};

template<> struct ChreMessageTraits<chre::fbs::UnloadNanoappRequest> {
  static const ChreMessage enum_value = ChreMessage::UnloadNanoappRequest;
};

template<> struct ChreMessageTraits<chre::fbs::UnloadNanoappResponse> {
  static const ChreMessage enum_value = ChreMessage::UnloadNanoappResponse;
};

template<> struct ChreMessageTraits<chre::fbs::LogMessage> {
  static const ChreMessage enum_value = ChreMessage::LogMessage;
};

template<> struct ChreMessageTraits<chre::fbs::TimeSyncMessage> {
  static const ChreMessage enum_value = ChreMessage::TimeSyncMessage;
};

template<> struct ChreMessageTraits<chre::fbs::DebugDumpRequest> {
  static const ChreMessage enum_value = ChreMessage::DebugDumpRequest;
};

template<> struct ChreMessageTraits<chre::fbs::DebugDumpData> {
  static const ChreMessage enum_value = ChreMessage::DebugDumpData;
};

template<> struct ChreMessageTraits<chre::fbs::DebugDumpResponse> {
  static const ChreMessage enum_value = ChreMessage::DebugDumpResponse;
};

template<> struct ChreMessageTraits<chre::fbs::TimeSyncRequest> {
  static const ChreMessage enum_value = ChreMessage::TimeSyncRequest;
};

template<> struct ChreMessageTraits<chre::fbs::LowPowerMicAccessRequest> {
  static const ChreMessage enum_value = ChreMessage::LowPowerMicAccessRequest;
};

template<> struct ChreMessageTraits<chre::fbs::LowPowerMicAccessRelease> {
  static const ChreMessage enum_value = ChreMessage::LowPowerMicAccessRelease;
};

template<> struct ChreMessageTraits<chre::fbs::SettingChangeMessage> {
  static const ChreMessage enum_value = ChreMessage::SettingChangeMessage;
};

template<> struct ChreMessageTraits<chre::fbs::LogMessageV2> {
  static const ChreMessage enum_value = ChreMessage::LogMessageV2;
};

template<> struct ChreMessageTraits<chre::fbs::SelfTestRequest> {
  static const ChreMessage enum_value = ChreMessage::SelfTestRequest;
};

template<> struct ChreMessageTraits<chre::fbs::SelfTestResponse> {
  static const ChreMessage enum_value = ChreMessage::SelfTestResponse;
};

template<> struct ChreMessageTraits<chre::fbs::HostEndpointConnected> {
  static const ChreMessage enum_value = ChreMessage::HostEndpointConnected;
};

template<> struct ChreMessageTraits<chre::fbs::HostEndpointDisconnected> {
  static const ChreMessage enum_value = ChreMessage::HostEndpointDisconnected;
};

template<> struct ChreMessageTraits<chre::fbs::MetricLog> {
  static const ChreMessage enum_value = ChreMessage::MetricLog;
};

template<> struct ChreMessageTraits<chre::fbs::BatchedMetricLog> {
  static const ChreMessage enum_value = ChreMessage::BatchedMetricLog;
};

template<> struct ChreMessageTraits<chre::fbs::NanConfigurationRequest> {
  static const ChreMessage enum_value = ChreMessage::NanConfigurationRequest;
};

template<> struct ChreMessageTraits<chre::fbs::NanConfigurationUpdate> {
  static const ChreMessage enum_value = ChreMessage::NanConfigurationUpdate;
};

template<> struct ChreMessageTraits<chre::fbs::DebugConfiguration> {
  static const ChreMessage enum_value = ChreMessage::DebugConfiguration;
};

struct ChreMessageUnion {
  ChreMessage type;
  void *value;

  ChreMessageUnion() : type(ChreMessage::NONE), value(nullptr) {}
  ChreMessageUnion(ChreMessageUnion&& u) FLATBUFFERS_NOEXCEPT :
    type(ChreMessage::NONE), value(nullptr)
    { std::swap(type, u.type); std::swap(value, u.value); }
  ChreMessageUnion(const ChreMessageUnion &);
  ChreMessageUnion &operator=(const ChreMessageUnion &u)
    { ChreMessageUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
  ChreMessageUnion &operator=(ChreMessageUnion &&u) FLATBUFFERS_NOEXCEPT
    { std::swap(type, u.type); std::swap(value, u.value); return *this; }
  ~ChreMessageUnion() { Reset(); }

  void Reset();

#ifndef FLATBUFFERS_CPP98_STL
  template <typename T>
  void Set(T&& val) {
    using RT = typename std::remove_reference<T>::type;
    Reset();
    type = ChreMessageTraits<typename RT::TableType>::enum_value;
    if (type != ChreMessage::NONE) {
      value = new RT(std::forward<T>(val));
    }
  }
#endif  // FLATBUFFERS_CPP98_STL

  static void *UnPack(const void *obj, ChreMessage type, const flatbuffers::resolver_function_t *resolver);
  flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;

  chre::fbs::NanoappMessageT *AsNanoappMessage() {
    return type == ChreMessage::NanoappMessage ?
      reinterpret_cast<chre::fbs::NanoappMessageT *>(value) : nullptr;
  }
  const chre::fbs::NanoappMessageT *AsNanoappMessage() const {
    return type == ChreMessage::NanoappMessage ?
      reinterpret_cast<const chre::fbs::NanoappMessageT *>(value) : nullptr;
  }
  chre::fbs::HubInfoRequestT *AsHubInfoRequest() {
    return type == ChreMessage::HubInfoRequest ?
      reinterpret_cast<chre::fbs::HubInfoRequestT *>(value) : nullptr;
  }
  const chre::fbs::HubInfoRequestT *AsHubInfoRequest() const {
    return type == ChreMessage::HubInfoRequest ?
      reinterpret_cast<const chre::fbs::HubInfoRequestT *>(value) : nullptr;
  }
  chre::fbs::HubInfoResponseT *AsHubInfoResponse() {
    return type == ChreMessage::HubInfoResponse ?
      reinterpret_cast<chre::fbs::HubInfoResponseT *>(value) : nullptr;
  }
  const chre::fbs::HubInfoResponseT *AsHubInfoResponse() const {
    return type == ChreMessage::HubInfoResponse ?
      reinterpret_cast<const chre::fbs::HubInfoResponseT *>(value) : nullptr;
  }
  chre::fbs::NanoappListRequestT *AsNanoappListRequest() {
    return type == ChreMessage::NanoappListRequest ?
      reinterpret_cast<chre::fbs::NanoappListRequestT *>(value) : nullptr;
  }
  const chre::fbs::NanoappListRequestT *AsNanoappListRequest() const {
    return type == ChreMessage::NanoappListRequest ?
      reinterpret_cast<const chre::fbs::NanoappListRequestT *>(value) : nullptr;
  }
  chre::fbs::NanoappListResponseT *AsNanoappListResponse() {
    return type == ChreMessage::NanoappListResponse ?
      reinterpret_cast<chre::fbs::NanoappListResponseT *>(value) : nullptr;
  }
  const chre::fbs::NanoappListResponseT *AsNanoappListResponse() const {
    return type == ChreMessage::NanoappListResponse ?
      reinterpret_cast<const chre::fbs::NanoappListResponseT *>(value) : nullptr;
  }
  chre::fbs::LoadNanoappRequestT *AsLoadNanoappRequest() {
    return type == ChreMessage::LoadNanoappRequest ?
      reinterpret_cast<chre::fbs::LoadNanoappRequestT *>(value) : nullptr;
  }
  const chre::fbs::LoadNanoappRequestT *AsLoadNanoappRequest() const {
    return type == ChreMessage::LoadNanoappRequest ?
      reinterpret_cast<const chre::fbs::LoadNanoappRequestT *>(value) : nullptr;
  }
  chre::fbs::LoadNanoappResponseT *AsLoadNanoappResponse() {
    return type == ChreMessage::LoadNanoappResponse ?
      reinterpret_cast<chre::fbs::LoadNanoappResponseT *>(value) : nullptr;
  }
  const chre::fbs::LoadNanoappResponseT *AsLoadNanoappResponse() const {
    return type == ChreMessage::LoadNanoappResponse ?
      reinterpret_cast<const chre::fbs::LoadNanoappResponseT *>(value) : nullptr;
  }
  chre::fbs::UnloadNanoappRequestT *AsUnloadNanoappRequest() {
    return type == ChreMessage::UnloadNanoappRequest ?
      reinterpret_cast<chre::fbs::UnloadNanoappRequestT *>(value) : nullptr;
  }
  const chre::fbs::UnloadNanoappRequestT *AsUnloadNanoappRequest() const {
    return type == ChreMessage::UnloadNanoappRequest ?
      reinterpret_cast<const chre::fbs::UnloadNanoappRequestT *>(value) : nullptr;
  }
  chre::fbs::UnloadNanoappResponseT *AsUnloadNanoappResponse() {
    return type == ChreMessage::UnloadNanoappResponse ?
      reinterpret_cast<chre::fbs::UnloadNanoappResponseT *>(value) : nullptr;
  }
  const chre::fbs::UnloadNanoappResponseT *AsUnloadNanoappResponse() const {
    return type == ChreMessage::UnloadNanoappResponse ?
      reinterpret_cast<const chre::fbs::UnloadNanoappResponseT *>(value) : nullptr;
  }
  chre::fbs::LogMessageT *AsLogMessage() {
    return type == ChreMessage::LogMessage ?
      reinterpret_cast<chre::fbs::LogMessageT *>(value) : nullptr;
  }
  const chre::fbs::LogMessageT *AsLogMessage() const {
    return type == ChreMessage::LogMessage ?
      reinterpret_cast<const chre::fbs::LogMessageT *>(value) : nullptr;
  }
  chre::fbs::TimeSyncMessageT *AsTimeSyncMessage() {
    return type == ChreMessage::TimeSyncMessage ?
      reinterpret_cast<chre::fbs::TimeSyncMessageT *>(value) : nullptr;
  }
  const chre::fbs::TimeSyncMessageT *AsTimeSyncMessage() const {
    return type == ChreMessage::TimeSyncMessage ?
      reinterpret_cast<const chre::fbs::TimeSyncMessageT *>(value) : nullptr;
  }
  chre::fbs::DebugDumpRequestT *AsDebugDumpRequest() {
    return type == ChreMessage::DebugDumpRequest ?
      reinterpret_cast<chre::fbs::DebugDumpRequestT *>(value) : nullptr;
  }
  const chre::fbs::DebugDumpRequestT *AsDebugDumpRequest() const {
    return type == ChreMessage::DebugDumpRequest ?
      reinterpret_cast<const chre::fbs::DebugDumpRequestT *>(value) : nullptr;
  }
  chre::fbs::DebugDumpDataT *AsDebugDumpData() {
    return type == ChreMessage::DebugDumpData ?
      reinterpret_cast<chre::fbs::DebugDumpDataT *>(value) : nullptr;
  }
  const chre::fbs::DebugDumpDataT *AsDebugDumpData() const {
    return type == ChreMessage::DebugDumpData ?
      reinterpret_cast<const chre::fbs::DebugDumpDataT *>(value) : nullptr;
  }
  chre::fbs::DebugDumpResponseT *AsDebugDumpResponse() {
    return type == ChreMessage::DebugDumpResponse ?
      reinterpret_cast<chre::fbs::DebugDumpResponseT *>(value) : nullptr;
  }
  const chre::fbs::DebugDumpResponseT *AsDebugDumpResponse() const {
    return type == ChreMessage::DebugDumpResponse ?
      reinterpret_cast<const chre::fbs::DebugDumpResponseT *>(value) : nullptr;
  }
  chre::fbs::TimeSyncRequestT *AsTimeSyncRequest() {
    return type == ChreMessage::TimeSyncRequest ?
      reinterpret_cast<chre::fbs::TimeSyncRequestT *>(value) : nullptr;
  }
  const chre::fbs::TimeSyncRequestT *AsTimeSyncRequest() const {
    return type == ChreMessage::TimeSyncRequest ?
      reinterpret_cast<const chre::fbs::TimeSyncRequestT *>(value) : nullptr;
  }
  chre::fbs::LowPowerMicAccessRequestT *AsLowPowerMicAccessRequest() {
    return type == ChreMessage::LowPowerMicAccessRequest ?
      reinterpret_cast<chre::fbs::LowPowerMicAccessRequestT *>(value) : nullptr;
  }
  const chre::fbs::LowPowerMicAccessRequestT *AsLowPowerMicAccessRequest() const {
    return type == ChreMessage::LowPowerMicAccessRequest ?
      reinterpret_cast<const chre::fbs::LowPowerMicAccessRequestT *>(value) : nullptr;
  }
  chre::fbs::LowPowerMicAccessReleaseT *AsLowPowerMicAccessRelease() {
    return type == ChreMessage::LowPowerMicAccessRelease ?
      reinterpret_cast<chre::fbs::LowPowerMicAccessReleaseT *>(value) : nullptr;
  }
  const chre::fbs::LowPowerMicAccessReleaseT *AsLowPowerMicAccessRelease() const {
    return type == ChreMessage::LowPowerMicAccessRelease ?
      reinterpret_cast<const chre::fbs::LowPowerMicAccessReleaseT *>(value) : nullptr;
  }
  chre::fbs::SettingChangeMessageT *AsSettingChangeMessage() {
    return type == ChreMessage::SettingChangeMessage ?
      reinterpret_cast<chre::fbs::SettingChangeMessageT *>(value) : nullptr;
  }
  const chre::fbs::SettingChangeMessageT *AsSettingChangeMessage() const {
    return type == ChreMessage::SettingChangeMessage ?
      reinterpret_cast<const chre::fbs::SettingChangeMessageT *>(value) : nullptr;
  }
  chre::fbs::LogMessageV2T *AsLogMessageV2() {
    return type == ChreMessage::LogMessageV2 ?
      reinterpret_cast<chre::fbs::LogMessageV2T *>(value) : nullptr;
  }
  const chre::fbs::LogMessageV2T *AsLogMessageV2() const {
    return type == ChreMessage::LogMessageV2 ?
      reinterpret_cast<const chre::fbs::LogMessageV2T *>(value) : nullptr;
  }
  chre::fbs::SelfTestRequestT *AsSelfTestRequest() {
    return type == ChreMessage::SelfTestRequest ?
      reinterpret_cast<chre::fbs::SelfTestRequestT *>(value) : nullptr;
  }
  const chre::fbs::SelfTestRequestT *AsSelfTestRequest() const {
    return type == ChreMessage::SelfTestRequest ?
      reinterpret_cast<const chre::fbs::SelfTestRequestT *>(value) : nullptr;
  }
  chre::fbs::SelfTestResponseT *AsSelfTestResponse() {
    return type == ChreMessage::SelfTestResponse ?
      reinterpret_cast<chre::fbs::SelfTestResponseT *>(value) : nullptr;
  }
  const chre::fbs::SelfTestResponseT *AsSelfTestResponse() const {
    return type == ChreMessage::SelfTestResponse ?
      reinterpret_cast<const chre::fbs::SelfTestResponseT *>(value) : nullptr;
  }
  chre::fbs::HostEndpointConnectedT *AsHostEndpointConnected() {
    return type == ChreMessage::HostEndpointConnected ?
      reinterpret_cast<chre::fbs::HostEndpointConnectedT *>(value) : nullptr;
  }
  const chre::fbs::HostEndpointConnectedT *AsHostEndpointConnected() const {
    return type == ChreMessage::HostEndpointConnected ?
      reinterpret_cast<const chre::fbs::HostEndpointConnectedT *>(value) : nullptr;
  }
  chre::fbs::HostEndpointDisconnectedT *AsHostEndpointDisconnected() {
    return type == ChreMessage::HostEndpointDisconnected ?
      reinterpret_cast<chre::fbs::HostEndpointDisconnectedT *>(value) : nullptr;
  }
  const chre::fbs::HostEndpointDisconnectedT *AsHostEndpointDisconnected() const {
    return type == ChreMessage::HostEndpointDisconnected ?
      reinterpret_cast<const chre::fbs::HostEndpointDisconnectedT *>(value) : nullptr;
  }
  chre::fbs::MetricLogT *AsMetricLog() {
    return type == ChreMessage::MetricLog ?
      reinterpret_cast<chre::fbs::MetricLogT *>(value) : nullptr;
  }
  const chre::fbs::MetricLogT *AsMetricLog() const {
    return type == ChreMessage::MetricLog ?
      reinterpret_cast<const chre::fbs::MetricLogT *>(value) : nullptr;
  }
  chre::fbs::BatchedMetricLogT *AsBatchedMetricLog() {
    return type == ChreMessage::BatchedMetricLog ?
      reinterpret_cast<chre::fbs::BatchedMetricLogT *>(value) : nullptr;
  }
  const chre::fbs::BatchedMetricLogT *AsBatchedMetricLog() const {
    return type == ChreMessage::BatchedMetricLog ?
      reinterpret_cast<const chre::fbs::BatchedMetricLogT *>(value) : nullptr;
  }
  chre::fbs::NanConfigurationRequestT *AsNanConfigurationRequest() {
    return type == ChreMessage::NanConfigurationRequest ?
      reinterpret_cast<chre::fbs::NanConfigurationRequestT *>(value) : nullptr;
  }
  const chre::fbs::NanConfigurationRequestT *AsNanConfigurationRequest() const {
    return type == ChreMessage::NanConfigurationRequest ?
      reinterpret_cast<const chre::fbs::NanConfigurationRequestT *>(value) : nullptr;
  }
  chre::fbs::NanConfigurationUpdateT *AsNanConfigurationUpdate() {
    return type == ChreMessage::NanConfigurationUpdate ?
      reinterpret_cast<chre::fbs::NanConfigurationUpdateT *>(value) : nullptr;
  }
  const chre::fbs::NanConfigurationUpdateT *AsNanConfigurationUpdate() const {
    return type == ChreMessage::NanConfigurationUpdate ?
      reinterpret_cast<const chre::fbs::NanConfigurationUpdateT *>(value) : nullptr;
  }
  chre::fbs::DebugConfigurationT *AsDebugConfiguration() {
    return type == ChreMessage::DebugConfiguration ?
      reinterpret_cast<chre::fbs::DebugConfigurationT *>(value) : nullptr;
  }
  const chre::fbs::DebugConfigurationT *AsDebugConfiguration() const {
    return type == ChreMessage::DebugConfiguration ?
      reinterpret_cast<const chre::fbs::DebugConfigurationT *>(value) : nullptr;
  }
};

bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type);
bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) HostAddress FLATBUFFERS_FINAL_CLASS {
 private:
  uint16_t client_id_;

 public:
  HostAddress() {
    memset(static_cast<void *>(this), 0, sizeof(HostAddress));
  }
  HostAddress(uint16_t _client_id)
      : client_id_(flatbuffers::EndianScalar(_client_id)) {
  }
  uint16_t client_id() const {
    return flatbuffers::EndianScalar(client_id_);
  }
  void mutate_client_id(uint16_t _client_id) {
    flatbuffers::WriteScalar(&client_id_, _client_id);
  }
};
FLATBUFFERS_STRUCT_END(HostAddress, 2);

struct NanoappMessageT : public flatbuffers::NativeTable {
  typedef NanoappMessage TableType;
  uint64_t app_id;
  uint32_t message_type;
  uint16_t host_endpoint;
  std::vector<uint8_t> message;
  uint32_t message_permissions;
  uint32_t permissions;
  bool woke_host;
  NanoappMessageT()
      : app_id(0),
        message_type(0),
        host_endpoint(65534),
        message_permissions(0),
        permissions(0),
        woke_host(false) {
  }
};

/// Represents a message sent to/from a nanoapp from/to a client on the host
struct NanoappMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef NanoappMessageT NativeTableType;
  typedef NanoappMessageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_APP_ID = 4,
    VT_MESSAGE_TYPE = 6,
    VT_HOST_ENDPOINT = 8,
    VT_MESSAGE = 10,
    VT_MESSAGE_PERMISSIONS = 12,
    VT_PERMISSIONS = 14,
    VT_WOKE_HOST = 16
  };
  uint64_t app_id() const {
    return GetField<uint64_t>(VT_APP_ID, 0);
  }
  bool mutate_app_id(uint64_t _app_id) {
    return SetField<uint64_t>(VT_APP_ID, _app_id, 0);
  }
  uint32_t message_type() const {
    return GetField<uint32_t>(VT_MESSAGE_TYPE, 0);
  }
  bool mutate_message_type(uint32_t _message_type) {
    return SetField<uint32_t>(VT_MESSAGE_TYPE, _message_type, 0);
  }
  /// Identifies the host-side endpoint on the host that sent or should receive
  /// this message. The default value is a special value defined in the HAL and
  /// elsewhere that indicates that the endpoint is unspecified.
  uint16_t host_endpoint() const {
    return GetField<uint16_t>(VT_HOST_ENDPOINT, 65534);
  }
  bool mutate_host_endpoint(uint16_t _host_endpoint) {
    return SetField<uint16_t>(VT_HOST_ENDPOINT, _host_endpoint, 65534);
  }
  /// Vector containing arbitrary application-specific message data
  const flatbuffers::Vector<uint8_t> *message() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MESSAGE);
  }
  flatbuffers::Vector<uint8_t> *mutable_message() {
    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_MESSAGE);
  }
  /// List of Android permissions that cover the contents of a message from a
  /// nanoapp to the host.
  /// These permissions are used to record and attribute access to
  /// permissions-controlled resources.
  uint32_t message_permissions() const {
    return GetField<uint32_t>(VT_MESSAGE_PERMISSIONS, 0);
  }
  bool mutate_message_permissions(uint32_t _message_permissions) {
    return SetField<uint32_t>(VT_MESSAGE_PERMISSIONS, _message_permissions, 0);
  }
  /// List of Android permissions declared by the nanoapp / granted to the host.
  /// For messages from a nanoaapp to the host, this must be a superset of
  /// message_permissions.
  uint32_t permissions() const {
    return GetField<uint32_t>(VT_PERMISSIONS, 0);
  }
  bool mutate_permissions(uint32_t _permissions) {
    return SetField<uint32_t>(VT_PERMISSIONS, _permissions, 0);
  }
  bool woke_host() const {
    return GetField<uint8_t>(VT_WOKE_HOST, 0) != 0;
  }
  bool mutate_woke_host(bool _woke_host) {
    return SetField<uint8_t>(VT_WOKE_HOST, static_cast<uint8_t>(_woke_host), 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_APP_ID) &&
           VerifyField<uint32_t>(verifier, VT_MESSAGE_TYPE) &&
           VerifyField<uint16_t>(verifier, VT_HOST_ENDPOINT) &&
           VerifyOffsetRequired(verifier, VT_MESSAGE) &&
           verifier.VerifyVector(message()) &&
           VerifyField<uint32_t>(verifier, VT_MESSAGE_PERMISSIONS) &&
           VerifyField<uint32_t>(verifier, VT_PERMISSIONS) &&
           VerifyField<uint8_t>(verifier, VT_WOKE_HOST) &&
           verifier.EndTable();
  }
  NanoappMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(NanoappMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<NanoappMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct NanoappMessageBuilder {
  typedef NanoappMessage Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_app_id(uint64_t app_id) {
    fbb_.AddElement<uint64_t>(NanoappMessage::VT_APP_ID, app_id, 0);
  }
  void add_message_type(uint32_t message_type) {
    fbb_.AddElement<uint32_t>(NanoappMessage::VT_MESSAGE_TYPE, message_type, 0);
  }
  void add_host_endpoint(uint16_t host_endpoint) {
    fbb_.AddElement<uint16_t>(NanoappMessage::VT_HOST_ENDPOINT, host_endpoint, 65534);
  }
  void add_message(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message) {
    fbb_.AddOffset(NanoappMessage::VT_MESSAGE, message);
  }
  void add_message_permissions(uint32_t message_permissions) {
    fbb_.AddElement<uint32_t>(NanoappMessage::VT_MESSAGE_PERMISSIONS, message_permissions, 0);
  }
  void add_permissions(uint32_t permissions) {
    fbb_.AddElement<uint32_t>(NanoappMessage::VT_PERMISSIONS, permissions, 0);
  }
  void add_woke_host(bool woke_host) {
    fbb_.AddElement<uint8_t>(NanoappMessage::VT_WOKE_HOST, static_cast<uint8_t>(woke_host), 0);
  }
  explicit NanoappMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  NanoappMessageBuilder &operator=(const NanoappMessageBuilder &);
  flatbuffers::Offset<NanoappMessage> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<NanoappMessage>(end);
    fbb_.Required(o, NanoappMessage::VT_MESSAGE);
    return o;
  }
};

inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t app_id = 0,
    uint32_t message_type = 0,
    uint16_t host_endpoint = 65534,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message = 0,
    uint32_t message_permissions = 0,
    uint32_t permissions = 0,
    bool woke_host = false) {
  NanoappMessageBuilder builder_(_fbb);
  builder_.add_app_id(app_id);
  builder_.add_permissions(permissions);
  builder_.add_message_permissions(message_permissions);
  builder_.add_message(message);
  builder_.add_message_type(message_type);
  builder_.add_host_endpoint(host_endpoint);
  builder_.add_woke_host(woke_host);
  return builder_.Finish();
}

inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessageDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t app_id = 0,
    uint32_t message_type = 0,
    uint16_t host_endpoint = 65534,
    const std::vector<uint8_t> *message = nullptr,
    uint32_t message_permissions = 0,
    uint32_t permissions = 0,
    bool woke_host = false) {
  auto message__ = message ? _fbb.CreateVector<uint8_t>(*message) : 0;
  return chre::fbs::CreateNanoappMessage(
      _fbb,
      app_id,
      message_type,
      host_endpoint,
      message__,
      message_permissions,
      permissions,
      woke_host);
}

flatbuffers::Offset<NanoappMessage> CreateNanoappMessage(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct HubInfoRequestT : public flatbuffers::NativeTable {
  typedef HubInfoRequest TableType;
  HubInfoRequestT() {
  }
};

struct HubInfoRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef HubInfoRequestT NativeTableType;
  typedef HubInfoRequestBuilder Builder;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
  HubInfoRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(HubInfoRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<HubInfoRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct HubInfoRequestBuilder {
  typedef HubInfoRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit HubInfoRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  HubInfoRequestBuilder &operator=(const HubInfoRequestBuilder &);
  flatbuffers::Offset<HubInfoRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<HubInfoRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(
    flatbuffers::FlatBufferBuilder &_fbb) {
  HubInfoRequestBuilder builder_(_fbb);
  return builder_.Finish();
}

flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct HubInfoResponseT : public flatbuffers::NativeTable {
  typedef HubInfoResponse TableType;
  std::vector<int8_t> name;
  std::vector<int8_t> vendor;
  std::vector<int8_t> toolchain;
  uint32_t platform_version;
  uint32_t toolchain_version;
  float peak_mips;
  float stopped_power;
  float sleep_power;
  float peak_power;
  uint32_t max_msg_len;
  uint64_t platform_id;
  uint32_t chre_platform_version;
  HubInfoResponseT()
      : platform_version(0),
        toolchain_version(0),
        peak_mips(0.0f),
        stopped_power(0.0f),
        sleep_power(0.0f),
        peak_power(0.0f),
        max_msg_len(0),
        platform_id(0),
        chre_platform_version(0) {
  }
};

struct HubInfoResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef HubInfoResponseT NativeTableType;
  typedef HubInfoResponseBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_VENDOR = 6,
    VT_TOOLCHAIN = 8,
    VT_PLATFORM_VERSION = 10,
    VT_TOOLCHAIN_VERSION = 12,
    VT_PEAK_MIPS = 14,
    VT_STOPPED_POWER = 16,
    VT_SLEEP_POWER = 18,
    VT_PEAK_POWER = 20,
    VT_MAX_MSG_LEN = 22,
    VT_PLATFORM_ID = 24,
    VT_CHRE_PLATFORM_VERSION = 26
  };
  /// The name of the hub. Nominally a UTF-8 string, but note that we're not
  /// using the built-in "string" data type from FlatBuffers here, because the
  /// generated C++ uses std::string which is not well-supported in CHRE. This
  /// applies for vendor and toolchain as well.
  const flatbuffers::Vector<int8_t> *name() const {
    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME);
  }
  flatbuffers::Vector<int8_t> *mutable_name() {
    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_NAME);
  }
  const flatbuffers::Vector<int8_t> *vendor() const {
    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_VENDOR);
  }
  flatbuffers::Vector<int8_t> *mutable_vendor() {
    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_VENDOR);
  }
  const flatbuffers::Vector<int8_t> *toolchain() const {
    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_TOOLCHAIN);
  }
  flatbuffers::Vector<int8_t> *mutable_toolchain() {
    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_TOOLCHAIN);
  }
  /// Legacy platform version reported in the HAL; semantics not strictly
  /// defined
  uint32_t platform_version() const {
    return GetField<uint32_t>(VT_PLATFORM_VERSION, 0);
  }
  bool mutate_platform_version(uint32_t _platform_version) {
    return SetField<uint32_t>(VT_PLATFORM_VERSION, _platform_version, 0);
  }
  /// Toolchain version reported in the HAL; semantics not strictly defined
  uint32_t toolchain_version() const {
    return GetField<uint32_t>(VT_TOOLCHAIN_VERSION, 0);
  }
  bool mutate_toolchain_version(uint32_t _toolchain_version) {
    return SetField<uint32_t>(VT_TOOLCHAIN_VERSION, _toolchain_version, 0);
  }
  float peak_mips() const {
    return GetField<float>(VT_PEAK_MIPS, 0.0f);
  }
  bool mutate_peak_mips(float _peak_mips) {
    return SetField<float>(VT_PEAK_MIPS, _peak_mips, 0.0f);
  }
  float stopped_power() const {
    return GetField<float>(VT_STOPPED_POWER, 0.0f);
  }
  bool mutate_stopped_power(float _stopped_power) {
    return SetField<float>(VT_STOPPED_POWER, _stopped_power, 0.0f);
  }
  float sleep_power() const {
    return GetField<float>(VT_SLEEP_POWER, 0.0f);
  }
  bool mutate_sleep_power(float _sleep_power) {
    return SetField<float>(VT_SLEEP_POWER, _sleep_power, 0.0f);
  }
  float peak_power() const {
    return GetField<float>(VT_PEAK_POWER, 0.0f);
  }
  bool mutate_peak_power(float _peak_power) {
    return SetField<float>(VT_PEAK_POWER, _peak_power, 0.0f);
  }
  /// Maximum size message that can be sent to a nanoapp
  uint32_t max_msg_len() const {
    return GetField<uint32_t>(VT_MAX_MSG_LEN, 0);
  }
  bool mutate_max_msg_len(uint32_t _max_msg_len) {
    return SetField<uint32_t>(VT_MAX_MSG_LEN, _max_msg_len, 0);
  }
  /// @see chreGetPlatformId()
  uint64_t platform_id() const {
    return GetField<uint64_t>(VT_PLATFORM_ID, 0);
  }
  bool mutate_platform_id(uint64_t _platform_id) {
    return SetField<uint64_t>(VT_PLATFORM_ID, _platform_id, 0);
  }
  /// @see chreGetVersion()
  uint32_t chre_platform_version() const {
    return GetField<uint32_t>(VT_CHRE_PLATFORM_VERSION, 0);
  }
  bool mutate_chre_platform_version(uint32_t _chre_platform_version) {
    return SetField<uint32_t>(VT_CHRE_PLATFORM_VERSION, _chre_platform_version, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyVector(name()) &&
           VerifyOffset(verifier, VT_VENDOR) &&
           verifier.VerifyVector(vendor()) &&
           VerifyOffset(verifier, VT_TOOLCHAIN) &&
           verifier.VerifyVector(toolchain()) &&
           VerifyField<uint32_t>(verifier, VT_PLATFORM_VERSION) &&
           VerifyField<uint32_t>(verifier, VT_TOOLCHAIN_VERSION) &&
           VerifyField<float>(verifier, VT_PEAK_MIPS) &&
           VerifyField<float>(verifier, VT_STOPPED_POWER) &&
           VerifyField<float>(verifier, VT_SLEEP_POWER) &&
           VerifyField<float>(verifier, VT_PEAK_POWER) &&
           VerifyField<uint32_t>(verifier, VT_MAX_MSG_LEN) &&
           VerifyField<uint64_t>(verifier, VT_PLATFORM_ID) &&
           VerifyField<uint32_t>(verifier, VT_CHRE_PLATFORM_VERSION) &&
           verifier.EndTable();
  }
  HubInfoResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(HubInfoResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<HubInfoResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct HubInfoResponseBuilder {
  typedef HubInfoResponse Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) {
    fbb_.AddOffset(HubInfoResponse::VT_NAME, name);
  }
  void add_vendor(flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor) {
    fbb_.AddOffset(HubInfoResponse::VT_VENDOR, vendor);
  }
  void add_toolchain(flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain) {
    fbb_.AddOffset(HubInfoResponse::VT_TOOLCHAIN, toolchain);
  }
  void add_platform_version(uint32_t platform_version) {
    fbb_.AddElement<uint32_t>(HubInfoResponse::VT_PLATFORM_VERSION, platform_version, 0);
  }
  void add_toolchain_version(uint32_t toolchain_version) {
    fbb_.AddElement<uint32_t>(HubInfoResponse::VT_TOOLCHAIN_VERSION, toolchain_version, 0);
  }
  void add_peak_mips(float peak_mips) {
    fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_MIPS, peak_mips, 0.0f);
  }
  void add_stopped_power(float stopped_power) {
    fbb_.AddElement<float>(HubInfoResponse::VT_STOPPED_POWER, stopped_power, 0.0f);
  }
  void add_sleep_power(float sleep_power) {
    fbb_.AddElement<float>(HubInfoResponse::VT_SLEEP_POWER, sleep_power, 0.0f);
  }
  void add_peak_power(float peak_power) {
    fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_POWER, peak_power, 0.0f);
  }
  void add_max_msg_len(uint32_t max_msg_len) {
    fbb_.AddElement<uint32_t>(HubInfoResponse::VT_MAX_MSG_LEN, max_msg_len, 0);
  }
  void add_platform_id(uint64_t platform_id) {
    fbb_.AddElement<uint64_t>(HubInfoResponse::VT_PLATFORM_ID, platform_id, 0);
  }
  void add_chre_platform_version(uint32_t chre_platform_version) {
    fbb_.AddElement<uint32_t>(HubInfoResponse::VT_CHRE_PLATFORM_VERSION, chre_platform_version, 0);
  }
  explicit HubInfoResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  HubInfoResponseBuilder &operator=(const HubInfoResponseBuilder &);
  flatbuffers::Offset<HubInfoResponse> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<HubInfoResponse>(end);
    return o;
  }
};

inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0,
    flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor = 0,
    flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain = 0,
    uint32_t platform_version = 0,
    uint32_t toolchain_version = 0,
    float peak_mips = 0.0f,
    float stopped_power = 0.0f,
    float sleep_power = 0.0f,
    float peak_power = 0.0f,
    uint32_t max_msg_len = 0,
    uint64_t platform_id = 0,
    uint32_t chre_platform_version = 0) {
  HubInfoResponseBuilder builder_(_fbb);
  builder_.add_platform_id(platform_id);
  builder_.add_chre_platform_version(chre_platform_version);
  builder_.add_max_msg_len(max_msg_len);
  builder_.add_peak_power(peak_power);
  builder_.add_sleep_power(sleep_power);
  builder_.add_stopped_power(stopped_power);
  builder_.add_peak_mips(peak_mips);
  builder_.add_toolchain_version(toolchain_version);
  builder_.add_platform_version(platform_version);
  builder_.add_toolchain(toolchain);
  builder_.add_vendor(vendor);
  builder_.add_name(name);
  return builder_.Finish();
}

inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponseDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int8_t> *name = nullptr,
    const std::vector<int8_t> *vendor = nullptr,
    const std::vector<int8_t> *toolchain = nullptr,
    uint32_t platform_version = 0,
    uint32_t toolchain_version = 0,
    float peak_mips = 0.0f,
    float stopped_power = 0.0f,
    float sleep_power = 0.0f,
    float peak_power = 0.0f,
    uint32_t max_msg_len = 0,
    uint64_t platform_id = 0,
    uint32_t chre_platform_version = 0) {
  auto name__ = name ? _fbb.CreateVector<int8_t>(*name) : 0;
  auto vendor__ = vendor ? _fbb.CreateVector<int8_t>(*vendor) : 0;
  auto toolchain__ = toolchain ? _fbb.CreateVector<int8_t>(*toolchain) : 0;
  return chre::fbs::CreateHubInfoResponse(
      _fbb,
      name__,
      vendor__,
      toolchain__,
      platform_version,
      toolchain_version,
      peak_mips,
      stopped_power,
      sleep_power,
      peak_power,
      max_msg_len,
      platform_id,
      chre_platform_version);
}

flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct NanoappListRequestT : public flatbuffers::NativeTable {
  typedef NanoappListRequest TableType;
  NanoappListRequestT() {
  }
};

struct NanoappListRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef NanoappListRequestT NativeTableType;
  typedef NanoappListRequestBuilder Builder;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
  NanoappListRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(NanoappListRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<NanoappListRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct NanoappListRequestBuilder {
  typedef NanoappListRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit NanoappListRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  NanoappListRequestBuilder &operator=(const NanoappListRequestBuilder &);
  flatbuffers::Offset<NanoappListRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<NanoappListRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(
    flatbuffers::FlatBufferBuilder &_fbb) {
  NanoappListRequestBuilder builder_(_fbb);
  return builder_.Finish();
}

flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct NanoappRpcServiceT : public flatbuffers::NativeTable {
  typedef NanoappRpcService TableType;
  uint64_t id;
  uint32_t version;
  NanoappRpcServiceT()
      : id(0),
        version(0) {
  }
};

/// Metadata regarding a Nanoapp RPC service. See the Android API
/// core/java/android/hardware/location/NanoAppRpcService.java for more details
/// on how this value is used by the Android application.
struct NanoappRpcService FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef NanoappRpcServiceT NativeTableType;
  typedef NanoappRpcServiceBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_VERSION = 6
  };
  uint64_t id() const {
    return GetField<uint64_t>(VT_ID, 0);
  }
  bool mutate_id(uint64_t _id) {
    return SetField<uint64_t>(VT_ID, _id, 0);
  }
  uint32_t version() const {
    return GetField<uint32_t>(VT_VERSION, 0);
  }
  bool mutate_version(uint32_t _version) {
    return SetField<uint32_t>(VT_VERSION, _version, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_ID) &&
           VerifyField<uint32_t>(verifier, VT_VERSION) &&
           verifier.EndTable();
  }
  NanoappRpcServiceT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(NanoappRpcServiceT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<NanoappRpcService> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappRpcServiceT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct NanoappRpcServiceBuilder {
  typedef NanoappRpcService Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_id(uint64_t id) {
    fbb_.AddElement<uint64_t>(NanoappRpcService::VT_ID, id, 0);
  }
  void add_version(uint32_t version) {
    fbb_.AddElement<uint32_t>(NanoappRpcService::VT_VERSION, version, 0);
  }
  explicit NanoappRpcServiceBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  NanoappRpcServiceBuilder &operator=(const NanoappRpcServiceBuilder &);
  flatbuffers::Offset<NanoappRpcService> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<NanoappRpcService>(end);
    return o;
  }
};

inline flatbuffers::Offset<NanoappRpcService> CreateNanoappRpcService(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t id = 0,
    uint32_t version = 0) {
  NanoappRpcServiceBuilder builder_(_fbb);
  builder_.add_id(id);
  builder_.add_version(version);
  return builder_.Finish();
}

flatbuffers::Offset<NanoappRpcService> CreateNanoappRpcService(flatbuffers::FlatBufferBuilder &_fbb, const NanoappRpcServiceT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct NanoappListEntryT : public flatbuffers::NativeTable {
  typedef NanoappListEntry TableType;
  uint64_t app_id;
  uint32_t version;
  bool enabled;
  bool is_system;
  uint32_t permissions;
  std::vector<std::unique_ptr<chre::fbs::NanoappRpcServiceT>> rpc_services;
  NanoappListEntryT()
      : app_id(0),
        version(0),
        enabled(true),
        is_system(false),
        permissions(0) {
  }
};

struct NanoappListEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef NanoappListEntryT NativeTableType;
  typedef NanoappListEntryBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_APP_ID = 4,
    VT_VERSION = 6,
    VT_ENABLED = 8,
    VT_IS_SYSTEM = 10,
    VT_PERMISSIONS = 12,
    VT_RPC_SERVICES = 14
  };
  uint64_t app_id() const {
    return GetField<uint64_t>(VT_APP_ID, 0);
  }
  bool mutate_app_id(uint64_t _app_id) {
    return SetField<uint64_t>(VT_APP_ID, _app_id, 0);
  }
  uint32_t version() const {
    return GetField<uint32_t>(VT_VERSION, 0);
  }
  bool mutate_version(uint32_t _version) {
    return SetField<uint32_t>(VT_VERSION, _version, 0);
  }
  bool enabled() const {
    return GetField<uint8_t>(VT_ENABLED, 1) != 0;
  }
  bool mutate_enabled(bool _enabled) {
    return SetField<uint8_t>(VT_ENABLED, static_cast<uint8_t>(_enabled), 1);
  }
  /// Whether the nanoapp is a pre-loaded "system" nanoapp, i.e. one that should
  /// not show up in the list of nanoapps in the context hub HAL. System
  /// nanoapps are typically used to leverage CHRE for some device functionality
  /// and do not interact via the context hub HAL.
  bool is_system() const {
    return GetField<uint8_t>(VT_IS_SYSTEM, 0) != 0;
  }
  bool mutate_is_system(bool _is_system) {
    return SetField<uint8_t>(VT_IS_SYSTEM, static_cast<uint8_t>(_is_system), 0);
  }
  /// Nanoapp permissions, if supported. Nanoapp permissions are required on
  /// CHRE API v1.5+, and are defined in chre/util/system/napp_permissions.h
  uint32_t permissions() const {
    return GetField<uint32_t>(VT_PERMISSIONS, 0);
  }
  bool mutate_permissions(uint32_t _permissions) {
    return SetField<uint32_t>(VT_PERMISSIONS, _permissions, 0);
  }
  /// The list of RPC services supported by this nanoapp.
  const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappRpcService>> *rpc_services() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappRpcService>> *>(VT_RPC_SERVICES);
  }
  flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappRpcService>> *mutable_rpc_services() {
    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappRpcService>> *>(VT_RPC_SERVICES);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_APP_ID) &&
           VerifyField<uint32_t>(verifier, VT_VERSION) &&
           VerifyField<uint8_t>(verifier, VT_ENABLED) &&
           VerifyField<uint8_t>(verifier, VT_IS_SYSTEM) &&
           VerifyField<uint32_t>(verifier, VT_PERMISSIONS) &&
           VerifyOffset(verifier, VT_RPC_SERVICES) &&
           verifier.VerifyVector(rpc_services()) &&
           verifier.VerifyVectorOfTables(rpc_services()) &&
           verifier.EndTable();
  }
  NanoappListEntryT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(NanoappListEntryT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<NanoappListEntry> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct NanoappListEntryBuilder {
  typedef NanoappListEntry Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_app_id(uint64_t app_id) {
    fbb_.AddElement<uint64_t>(NanoappListEntry::VT_APP_ID, app_id, 0);
  }
  void add_version(uint32_t version) {
    fbb_.AddElement<uint32_t>(NanoappListEntry::VT_VERSION, version, 0);
  }
  void add_enabled(bool enabled) {
    fbb_.AddElement<uint8_t>(NanoappListEntry::VT_ENABLED, static_cast<uint8_t>(enabled), 1);
  }
  void add_is_system(bool is_system) {
    fbb_.AddElement<uint8_t>(NanoappListEntry::VT_IS_SYSTEM, static_cast<uint8_t>(is_system), 0);
  }
  void add_permissions(uint32_t permissions) {
    fbb_.AddElement<uint32_t>(NanoappListEntry::VT_PERMISSIONS, permissions, 0);
  }
  void add_rpc_services(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappRpcService>>> rpc_services) {
    fbb_.AddOffset(NanoappListEntry::VT_RPC_SERVICES, rpc_services);
  }
  explicit NanoappListEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  NanoappListEntryBuilder &operator=(const NanoappListEntryBuilder &);
  flatbuffers::Offset<NanoappListEntry> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<NanoappListEntry>(end);
    return o;
  }
};

inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t app_id = 0,
    uint32_t version = 0,
    bool enabled = true,
    bool is_system = false,
    uint32_t permissions = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappRpcService>>> rpc_services = 0) {
  NanoappListEntryBuilder builder_(_fbb);
  builder_.add_app_id(app_id);
  builder_.add_rpc_services(rpc_services);
  builder_.add_permissions(permissions);
  builder_.add_version(version);
  builder_.add_is_system(is_system);
  builder_.add_enabled(enabled);
  return builder_.Finish();
}

inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntryDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t app_id = 0,
    uint32_t version = 0,
    bool enabled = true,
    bool is_system = false,
    uint32_t permissions = 0,
    const std::vector<flatbuffers::Offset<chre::fbs::NanoappRpcService>> *rpc_services = nullptr) {
  auto rpc_services__ = rpc_services ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::NanoappRpcService>>(*rpc_services) : 0;
  return chre::fbs::CreateNanoappListEntry(
      _fbb,
      app_id,
      version,
      enabled,
      is_system,
      permissions,
      rpc_services__);
}

flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct NanoappListResponseT : public flatbuffers::NativeTable {
  typedef NanoappListResponse TableType;
  std::vector<std::unique_ptr<chre::fbs::NanoappListEntryT>> nanoapps;
  NanoappListResponseT() {
  }
};

struct NanoappListResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef NanoappListResponseT NativeTableType;
  typedef NanoappListResponseBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NANOAPPS = 4
  };
  const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> *nanoapps() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> *>(VT_NANOAPPS);
  }
  flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> *mutable_nanoapps() {
    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> *>(VT_NANOAPPS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_NANOAPPS) &&
           verifier.VerifyVector(nanoapps()) &&
           verifier.VerifyVectorOfTables(nanoapps()) &&
           verifier.EndTable();
  }
  NanoappListResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(NanoappListResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<NanoappListResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct NanoappListResponseBuilder {
  typedef NanoappListResponse Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_nanoapps(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>>> nanoapps) {
    fbb_.AddOffset(NanoappListResponse::VT_NANOAPPS, nanoapps);
  }
  explicit NanoappListResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  NanoappListResponseBuilder &operator=(const NanoappListResponseBuilder &);
  flatbuffers::Offset<NanoappListResponse> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<NanoappListResponse>(end);
    fbb_.Required(o, NanoappListResponse::VT_NANOAPPS);
    return o;
  }
};

inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>>> nanoapps = 0) {
  NanoappListResponseBuilder builder_(_fbb);
  builder_.add_nanoapps(nanoapps);
  return builder_.Finish();
}

inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponseDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> *nanoapps = nullptr) {
  auto nanoapps__ = nanoapps ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::NanoappListEntry>>(*nanoapps) : 0;
  return chre::fbs::CreateNanoappListResponse(
      _fbb,
      nanoapps__);
}

flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct LoadNanoappRequestT : public flatbuffers::NativeTable {
  typedef LoadNanoappRequest TableType;
  uint32_t transaction_id;
  uint64_t app_id;
  uint32_t app_version;
  uint32_t target_api_version;
  std::vector<uint8_t> app_binary;
  uint32_t fragment_id;
  uint32_t total_app_size;
  std::vector<int8_t> app_binary_file_name;
  uint32_t app_flags;
  bool respond_before_start;
  LoadNanoappRequestT()
      : transaction_id(0),
        app_id(0),
        app_version(0),
        target_api_version(0),
        fragment_id(0),
        total_app_size(0),
        app_flags(0),
        respond_before_start(false) {
  }
};

/// Represents a request for loading a nanoapp.
/// The nanaopp can either be requested to be loaded via a file or via a buffer.
/// For loading via a file, the following steps will be taken:
/// 1. The loader sends a LoadNanoappRequest message to CHRE. app_binary must
///    be set for legacy purposes, but should be empty. Additionally,
///    fragment_id and total_app_size are unused in this request. The loading
///    that happens as part of this request is serialized, but asynchronous
///    meaning that load requests will be processed in the order they are sent
///    but multiple requests can be outstanding at any given time.
/// 2. CHRE stores the filename and waits until its event loop is able to
///    process the request.
/// 3. Once ready, the nanoapp will be loaded from the file specified in the
///    original request and will send a callback indicating the
///    completion/failure of the request.
/// For loading via a buffer, loading may optionally be fragmented into multiple
/// sequential requests, which will follow the following steps:
/// 1. The loader sends a LoadNanoappRequest message to CHRE. If the request
///    is fragmented, then the fields fragment_id and total_app_size must
///    be defined. Once the first fragment is sent to CHRE, all subsequent
///    fragments must be delivered before a new LoadNanoappRequest can be
///    issued. If a new request is received while a current request has
///    outstanding fragments, the current request will be overridden with the
///    new one.
/// 2. CHRE preallocates the required amount of memory, and loads app_binary,
///    appending to already loaded fragments as appropriate.
/// 3. If the request is fragmented, then the requestor must sequentially send
///    multiple LoadNanoappRequest with incremental nanoapp binary fragments.
///    CHRE will respond with LoadNanoappResponse for each request. For
///    requests starting from the second fragment, all fields except
///    fragment_id and app_binary should be ignored by CHRE.
///
///    Once the LoadNanoappRepsonse for the last fragment is received
///    by the HAL, the HAL client will receive a callback indicating the
///    completion/failure of a load request.
///
/// If any request fragment is lost, then the entire load request will be
/// considered to have failed. If the request times out (e.g. the requestor
/// process crashes), then the load request will be cancelled at CHRE and fail.
struct LoadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef LoadNanoappRequestT NativeTableType;
  typedef LoadNanoappRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TRANSACTION_ID = 4,
    VT_APP_ID = 6,
    VT_APP_VERSION = 8,
    VT_TARGET_API_VERSION = 10,
    VT_APP_BINARY = 12,
    VT_FRAGMENT_ID = 14,
    VT_TOTAL_APP_SIZE = 16,
    VT_APP_BINARY_FILE_NAME = 18,
    VT_APP_FLAGS = 20,
    VT_RESPOND_BEFORE_START = 22
  };
  uint32_t transaction_id() const {
    return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
  }
  bool mutate_transaction_id(uint32_t _transaction_id) {
    return SetField<uint32_t>(VT_TRANSACTION_ID, _transaction_id, 0);
  }
  uint64_t app_id() const {
    return GetField<uint64_t>(VT_APP_ID, 0);
  }
  bool mutate_app_id(uint64_t _app_id) {
    return SetField<uint64_t>(VT_APP_ID, _app_id, 0);
  }
  uint32_t app_version() const {
    return GetField<uint32_t>(VT_APP_VERSION, 0);
  }
  bool mutate_app_version(uint32_t _app_version) {
    return SetField<uint32_t>(VT_APP_VERSION, _app_version, 0);
  }
  uint32_t target_api_version() const {
    return GetField<uint32_t>(VT_TARGET_API_VERSION, 0);
  }
  bool mutate_target_api_version(uint32_t _target_api_version) {
    return SetField<uint32_t>(VT_TARGET_API_VERSION, _target_api_version, 0);
  }
  const flatbuffers::Vector<uint8_t> *app_binary() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_APP_BINARY);
  }
  flatbuffers::Vector<uint8_t> *mutable_app_binary() {
    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_APP_BINARY);
  }
  /// Fields that are relevant for fragmented loading
  /// The framgent count starts at 1 and should end at the total number of
  /// fragments. For clients that do not support fragmented loading, the
  /// default behavior should be to assume one fragment.
  uint32_t fragment_id() const {
    return GetField<uint32_t>(VT_FRAGMENT_ID, 0);
  }
  bool mutate_fragment_id(uint32_t _fragment_id) {
    return SetField<uint32_t>(VT_FRAGMENT_ID, _fragment_id, 0);
  }
  uint32_t total_app_size() const {
    return GetField<uint32_t>(VT_TOTAL_APP_SIZE, 0);
  }
  bool mutate_total_app_size(uint32_t _total_app_size) {
    return SetField<uint32_t>(VT_TOTAL_APP_SIZE, _total_app_size, 0);
  }
  /// Null-terminated ASCII string containing the file name that contains the
  /// app binary to be loaded.
  const flatbuffers::Vector<int8_t> *app_binary_file_name() const {
    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_APP_BINARY_FILE_NAME);
  }
  flatbuffers::Vector<int8_t> *mutable_app_binary_file_name() {
    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_APP_BINARY_FILE_NAME);
  }
  /// The nanoapp flag values from the nanoapp header defined in
  /// build/build_template.mk. Refer to that file for more details.
  uint32_t app_flags() const {
    return GetField<uint32_t>(VT_APP_FLAGS, 0);
  }
  bool mutate_app_flags(uint32_t _app_flags) {
    return SetField<uint32_t>(VT_APP_FLAGS, _app_flags, 0);
  }
  /// If true and fragmented loading is requested, the LoadNanoappResponse
  /// for the last fragment will be sent after the fragment was confirmed
  /// to be placed in memory and no additional response will be sent after
  /// the nanoapp is linked and started in the framework.
  bool respond_before_start() const {
    return GetField<uint8_t>(VT_RESPOND_BEFORE_START, 0) != 0;
  }
  bool mutate_respond_before_start(bool _respond_before_start) {
    return SetField<uint8_t>(VT_RESPOND_BEFORE_START, static_cast<uint8_t>(_respond_before_start), 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
           VerifyField<uint64_t>(verifier, VT_APP_ID) &&
           VerifyField<uint32_t>(verifier, VT_APP_VERSION) &&
           VerifyField<uint32_t>(verifier, VT_TARGET_API_VERSION) &&
           VerifyOffsetRequired(verifier, VT_APP_BINARY) &&
           verifier.VerifyVector(app_binary()) &&
           VerifyField<uint32_t>(verifier, VT_FRAGMENT_ID) &&
           VerifyField<uint32_t>(verifier, VT_TOTAL_APP_SIZE) &&
           VerifyOffset(verifier, VT_APP_BINARY_FILE_NAME) &&
           verifier.VerifyVector(app_binary_file_name()) &&
           VerifyField<uint32_t>(verifier, VT_APP_FLAGS) &&
           VerifyField<uint8_t>(verifier, VT_RESPOND_BEFORE_START) &&
           verifier.EndTable();
  }
  LoadNanoappRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(LoadNanoappRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<LoadNanoappRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct LoadNanoappRequestBuilder {
  typedef LoadNanoappRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_transaction_id(uint32_t transaction_id) {
    fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0);
  }
  void add_app_id(uint64_t app_id) {
    fbb_.AddElement<uint64_t>(LoadNanoappRequest::VT_APP_ID, app_id, 0);
  }
  void add_app_version(uint32_t app_version) {
    fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_APP_VERSION, app_version, 0);
  }
  void add_target_api_version(uint32_t target_api_version) {
    fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TARGET_API_VERSION, target_api_version, 0);
  }
  void add_app_binary(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary) {
    fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY, app_binary);
  }
  void add_fragment_id(uint32_t fragment_id) {
    fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_FRAGMENT_ID, fragment_id, 0);
  }
  void add_total_app_size(uint32_t total_app_size) {
    fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TOTAL_APP_SIZE, total_app_size, 0);
  }
  void add_app_binary_file_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> app_binary_file_name) {
    fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY_FILE_NAME, app_binary_file_name);
  }
  void add_app_flags(uint32_t app_flags) {
    fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_APP_FLAGS, app_flags, 0);
  }
  void add_respond_before_start(bool respond_before_start) {
    fbb_.AddElement<uint8_t>(LoadNanoappRequest::VT_RESPOND_BEFORE_START, static_cast<uint8_t>(respond_before_start), 0);
  }
  explicit LoadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  LoadNanoappRequestBuilder &operator=(const LoadNanoappRequestBuilder &);
  flatbuffers::Offset<LoadNanoappRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<LoadNanoappRequest>(end);
    fbb_.Required(o, LoadNanoappRequest::VT_APP_BINARY);
    return o;
  }
};

inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t transaction_id = 0,
    uint64_t app_id = 0,
    uint32_t app_version = 0,
    uint32_t target_api_version = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary = 0,
    uint32_t fragment_id = 0,
    uint32_t total_app_size = 0,
    flatbuffers::Offset<flatbuffers::Vector<int8_t>> app_binary_file_name = 0,
    uint32_t app_flags = 0,
    bool respond_before_start = false) {
  LoadNanoappRequestBuilder builder_(_fbb);
  builder_.add_app_id(app_id);
  builder_.add_app_flags(app_flags);
  builder_.add_app_binary_file_name(app_binary_file_name);
  builder_.add_total_app_size(total_app_size);
  builder_.add_fragment_id(fragment_id);
  builder_.add_app_binary(app_binary);
  builder_.add_target_api_version(target_api_version);
  builder_.add_app_version(app_version);
  builder_.add_transaction_id(transaction_id);
  builder_.add_respond_before_start(respond_before_start);
  return builder_.Finish();
}

inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t transaction_id = 0,
    uint64_t app_id = 0,
    uint32_t app_version = 0,
    uint32_t target_api_version = 0,
    const std::vector<uint8_t> *app_binary = nullptr,
    uint32_t fragment_id = 0,
    uint32_t total_app_size = 0,
    const std::vector<int8_t> *app_binary_file_name = nullptr,
    uint32_t app_flags = 0,
    bool respond_before_start = false) {
  auto app_binary__ = app_binary ? _fbb.CreateVector<uint8_t>(*app_binary) : 0;
  auto app_binary_file_name__ = app_binary_file_name ? _fbb.CreateVector<int8_t>(*app_binary_file_name) : 0;
  return chre::fbs::CreateLoadNanoappRequest(
      _fbb,
      transaction_id,
      app_id,
      app_version,
      target_api_version,
      app_binary__,
      fragment_id,
      total_app_size,
      app_binary_file_name__,
      app_flags,
      respond_before_start);
}

flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct LoadNanoappResponseT : public flatbuffers::NativeTable {
  typedef LoadNanoappResponse TableType;
  uint32_t transaction_id;
  bool success;
  uint32_t fragment_id;
  LoadNanoappResponseT()
      : transaction_id(0),
        success(false),
        fragment_id(0) {
  }
};

struct LoadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef LoadNanoappResponseT NativeTableType;
  typedef LoadNanoappResponseBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TRANSACTION_ID = 4,
    VT_SUCCESS = 6,
    VT_FRAGMENT_ID = 8
  };
  uint32_t transaction_id() const {
    return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
  }
  bool mutate_transaction_id(uint32_t _transaction_id) {
    return SetField<uint32_t>(VT_TRANSACTION_ID, _transaction_id, 0);
  }
  /// Denotes whether a load request succeeded or failed.
  /// If any fragment of a load request fails, the entire load request for
  /// the same transaction will fail.
  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);
  }
  /// The fragment count of the load reponse is for.
  uint32_t fragment_id() const {
    return GetField<uint32_t>(VT_FRAGMENT_ID, 0);
  }
  bool mutate_fragment_id(uint32_t _fragment_id) {
    return SetField<uint32_t>(VT_FRAGMENT_ID, _fragment_id, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
           VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
           VerifyField<uint32_t>(verifier, VT_FRAGMENT_ID) &&
           verifier.EndTable();
  }
  LoadNanoappResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(LoadNanoappResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<LoadNanoappResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct LoadNanoappResponseBuilder {
  typedef LoadNanoappResponse Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_transaction_id(uint32_t transaction_id) {
    fbb_.AddElement<uint32_t>(LoadNanoappResponse::VT_TRANSACTION_ID, transaction_id, 0);
  }
  void add_success(bool success) {
    fbb_.AddElement<uint8_t>(LoadNanoappResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
  }
  void add_fragment_id(uint32_t fragment_id) {
    fbb_.AddElement<uint32_t>(LoadNanoappResponse::VT_FRAGMENT_ID, fragment_id, 0);
  }
  explicit LoadNanoappResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  LoadNanoappResponseBuilder &operator=(const LoadNanoappResponseBuilder &);
  flatbuffers::Offset<LoadNanoappResponse> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<LoadNanoappResponse>(end);
    return o;
  }
};

inline flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t transaction_id = 0,
    bool success = false,
    uint32_t fragment_id = 0) {
  LoadNanoappResponseBuilder builder_(_fbb);
  builder_.add_fragment_id(fragment_id);
  builder_.add_transaction_id(transaction_id);
  builder_.add_success(success);
  return builder_.Finish();
}

flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct UnloadNanoappRequestT : public flatbuffers::NativeTable {
  typedef UnloadNanoappRequest TableType;
  uint32_t transaction_id;
  uint64_t app_id;
  bool allow_system_nanoapp_unload;
  UnloadNanoappRequestT()
      : transaction_id(0),
        app_id(0),
        allow_system_nanoapp_unload(false) {
  }
};

struct UnloadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef UnloadNanoappRequestT NativeTableType;
  typedef UnloadNanoappRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TRANSACTION_ID = 4,
    VT_APP_ID = 6,
    VT_ALLOW_SYSTEM_NANOAPP_UNLOAD = 8
  };
  uint32_t transaction_id() const {
    return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
  }
  bool mutate_transaction_id(uint32_t _transaction_id) {
    return SetField<uint32_t>(VT_TRANSACTION_ID, _transaction_id, 0);
  }
  uint64_t app_id() const {
    return GetField<uint64_t>(VT_APP_ID, 0);
  }
  bool mutate_app_id(uint64_t _app_id) {
    return SetField<uint64_t>(VT_APP_ID, _app_id, 0);
  }
  /// Set to true to allow this request to unload nanoapps identified as "system
  /// nanoapps", i.e. ones with is_system set to true in NanoappListResponse.
  bool allow_system_nanoapp_unload() const {
    return GetField<uint8_t>(VT_ALLOW_SYSTEM_NANOAPP_UNLOAD, 0) != 0;
  }
  bool mutate_allow_system_nanoapp_unload(bool _allow_system_nanoapp_unload) {
    return SetField<uint8_t>(VT_ALLOW_SYSTEM_NANOAPP_UNLOAD, static_cast<uint8_t>(_allow_system_nanoapp_unload), 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
           VerifyField<uint64_t>(verifier, VT_APP_ID) &&
           VerifyField<uint8_t>(verifier, VT_ALLOW_SYSTEM_NANOAPP_UNLOAD) &&
           verifier.EndTable();
  }
  UnloadNanoappRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(UnloadNanoappRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<UnloadNanoappRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct UnloadNanoappRequestBuilder {
  typedef UnloadNanoappRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_transaction_id(uint32_t transaction_id) {
    fbb_.AddElement<uint32_t>(UnloadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0);
  }
  void add_app_id(uint64_t app_id) {
    fbb_.AddElement<uint64_t>(UnloadNanoappRequest::VT_APP_ID, app_id, 0);
  }
  void add_allow_system_nanoapp_unload(bool allow_system_nanoapp_unload) {
    fbb_.AddElement<uint8_t>(UnloadNanoappRequest::VT_ALLOW_SYSTEM_NANOAPP_UNLOAD, static_cast<uint8_t>(allow_system_nanoapp_unload), 0);
  }
  explicit UnloadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  UnloadNanoappRequestBuilder &operator=(const UnloadNanoappRequestBuilder &);
  flatbuffers::Offset<UnloadNanoappRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<UnloadNanoappRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<UnloadNanoappRequest> CreateUnloadNanoappRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t transaction_id = 0,
    uint64_t app_id = 0,
    bool allow_system_nanoapp_unload = false) {
  UnloadNanoappRequestBuilder builder_(_fbb);
  builder_.add_app_id(app_id);
  builder_.add_transaction_id(transaction_id);
  builder_.add_allow_system_nanoapp_unload(allow_system_nanoapp_unload);
  return builder_.Finish();
}

flatbuffers::Offset<UnloadNanoappRequest> CreateUnloadNanoappRequest(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct UnloadNanoappResponseT : public flatbuffers::NativeTable {
  typedef UnloadNanoappResponse TableType;
  uint32_t transaction_id;
  bool success;
  UnloadNanoappResponseT()
      : transaction_id(0),
        success(false) {
  }
};

struct UnloadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef UnloadNanoappResponseT NativeTableType;
  typedef UnloadNanoappResponseBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TRANSACTION_ID = 4,
    VT_SUCCESS = 6
  };
  uint32_t transaction_id() const {
    return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
  }
  bool mutate_transaction_id(uint32_t _transaction_id) {
    return SetField<uint32_t>(VT_TRANSACTION_ID, _transaction_id, 0);
  }
  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<uint32_t>(verifier, VT_TRANSACTION_ID) &&
           VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
           verifier.EndTable();
  }
  UnloadNanoappResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(UnloadNanoappResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<UnloadNanoappResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

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

inline flatbuffers::Offset<UnloadNanoappResponse> CreateUnloadNanoappResponse(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t transaction_id = 0,
    bool success = false) {
  UnloadNanoappResponseBuilder builder_(_fbb);
  builder_.add_transaction_id(transaction_id);
  builder_.add_success(success);
  return builder_.Finish();
}

flatbuffers::Offset<UnloadNanoappResponse> CreateUnloadNanoappResponse(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct LogMessageT : public flatbuffers::NativeTable {
  typedef LogMessage TableType;
  std::vector<int8_t> buffer;
  LogMessageT() {
  }
};

/// Represents log messages from CHRE.
struct LogMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef LogMessageT NativeTableType;
  typedef LogMessageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BUFFER = 4
  };
  /// A buffer containing formatted log data. A flat array is used here to avoid
  /// overhead in serializing and deserializing. The format is as follows:
  ///
  /// uint8_t                 - log level (1 = error, 2 = warning,
  ///                                      3 = info, 4 = debug)
  /// uint64_t, little-endian - timestamp in nanoseconds
  /// char[]                  - message to log
  /// char, \0                - null-terminator
  ///
  /// This pattern repeats until the end of the buffer for multiple log
  /// messages. The last byte will always be a null-terminator. There are no
  /// padding bytes between these fields. Treat this like a packed struct and be
  /// cautious with unaligned access when reading/writing this buffer.
  const flatbuffers::Vector<int8_t> *buffer() const {
    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_BUFFER);
  }
  flatbuffers::Vector<int8_t> *mutable_buffer() {
    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_BUFFER);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_BUFFER) &&
           verifier.VerifyVector(buffer()) &&
           verifier.EndTable();
  }
  LogMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(LogMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<LogMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct LogMessageBuilder {
  typedef LogMessage Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_buffer(flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer) {
    fbb_.AddOffset(LogMessage::VT_BUFFER, buffer);
  }
  explicit LogMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  LogMessageBuilder &operator=(const LogMessageBuilder &);
  flatbuffers::Offset<LogMessage> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<LogMessage>(end);
    return o;
  }
};

inline flatbuffers::Offset<LogMessage> CreateLogMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer = 0) {
  LogMessageBuilder builder_(_fbb);
  builder_.add_buffer(buffer);
  return builder_.Finish();
}

inline flatbuffers::Offset<LogMessage> CreateLogMessageDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int8_t> *buffer = nullptr) {
  auto buffer__ = buffer ? _fbb.CreateVector<int8_t>(*buffer) : 0;
  return chre::fbs::CreateLogMessage(
      _fbb,
      buffer__);
}

flatbuffers::Offset<LogMessage> CreateLogMessage(flatbuffers::FlatBufferBuilder &_fbb, const LogMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct TimeSyncMessageT : public flatbuffers::NativeTable {
  typedef TimeSyncMessage TableType;
  int64_t offset;
  TimeSyncMessageT()
      : offset(0) {
  }
};

/// Represents a message sent to CHRE to indicate AP timestamp for time sync
struct TimeSyncMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef TimeSyncMessageT NativeTableType;
  typedef TimeSyncMessageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OFFSET = 4
  };
  /// Offset between AP and CHRE timestamp
  int64_t offset() const {
    return GetField<int64_t>(VT_OFFSET, 0);
  }
  bool mutate_offset(int64_t _offset) {
    return SetField<int64_t>(VT_OFFSET, _offset, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int64_t>(verifier, VT_OFFSET) &&
           verifier.EndTable();
  }
  TimeSyncMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(TimeSyncMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<TimeSyncMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct TimeSyncMessageBuilder {
  typedef TimeSyncMessage Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_offset(int64_t offset) {
    fbb_.AddElement<int64_t>(TimeSyncMessage::VT_OFFSET, offset, 0);
  }
  explicit TimeSyncMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  TimeSyncMessageBuilder &operator=(const TimeSyncMessageBuilder &);
  flatbuffers::Offset<TimeSyncMessage> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<TimeSyncMessage>(end);
    return o;
  }
};

inline flatbuffers::Offset<TimeSyncMessage> CreateTimeSyncMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    int64_t offset = 0) {
  TimeSyncMessageBuilder builder_(_fbb);
  builder_.add_offset(offset);
  return builder_.Finish();
}

flatbuffers::Offset<TimeSyncMessage> CreateTimeSyncMessage(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct DebugDumpRequestT : public flatbuffers::NativeTable {
  typedef DebugDumpRequest TableType;
  DebugDumpRequestT() {
  }
};

/// A request to gather and return debugging information. Only one debug dump
/// session can be active at a time. Upon accepting a request, zero or more
/// DebugDumpData messages are generated, followed by a DebugDumpResponse
/// indicating the completion of the operation.
struct DebugDumpRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef DebugDumpRequestT NativeTableType;
  typedef DebugDumpRequestBuilder Builder;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
  DebugDumpRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(DebugDumpRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<DebugDumpRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct DebugDumpRequestBuilder {
  typedef DebugDumpRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit DebugDumpRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  DebugDumpRequestBuilder &operator=(const DebugDumpRequestBuilder &);
  flatbuffers::Offset<DebugDumpRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<DebugDumpRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<DebugDumpRequest> CreateDebugDumpRequest(
    flatbuffers::FlatBufferBuilder &_fbb) {
  DebugDumpRequestBuilder builder_(_fbb);
  return builder_.Finish();
}

flatbuffers::Offset<DebugDumpRequest> CreateDebugDumpRequest(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct DebugDumpDataT : public flatbuffers::NativeTable {
  typedef DebugDumpData TableType;
  std::vector<int8_t> debug_str;
  DebugDumpDataT() {
  }
};

struct DebugDumpData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef DebugDumpDataT NativeTableType;
  typedef DebugDumpDataBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DEBUG_STR = 4
  };
  /// Null-terminated ASCII string containing debugging information
  const flatbuffers::Vector<int8_t> *debug_str() const {
    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_DEBUG_STR);
  }
  flatbuffers::Vector<int8_t> *mutable_debug_str() {
    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_DEBUG_STR);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DEBUG_STR) &&
           verifier.VerifyVector(debug_str()) &&
           verifier.EndTable();
  }
  DebugDumpDataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(DebugDumpDataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<DebugDumpData> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpDataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct DebugDumpDataBuilder {
  typedef DebugDumpData Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_debug_str(flatbuffers::Offset<flatbuffers::Vector<int8_t>> debug_str) {
    fbb_.AddOffset(DebugDumpData::VT_DEBUG_STR, debug_str);
  }
  explicit DebugDumpDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  DebugDumpDataBuilder &operator=(const DebugDumpDataBuilder &);
  flatbuffers::Offset<DebugDumpData> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<DebugDumpData>(end);
    return o;
  }
};

inline flatbuffers::Offset<DebugDumpData> CreateDebugDumpData(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<int8_t>> debug_str = 0) {
  DebugDumpDataBuilder builder_(_fbb);
  builder_.add_debug_str(debug_str);
  return builder_.Finish();
}

inline flatbuffers::Offset<DebugDumpData> CreateDebugDumpDataDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int8_t> *debug_str = nullptr) {
  auto debug_str__ = debug_str ? _fbb.CreateVector<int8_t>(*debug_str) : 0;
  return chre::fbs::CreateDebugDumpData(
      _fbb,
      debug_str__);
}

flatbuffers::Offset<DebugDumpData> CreateDebugDumpData(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpDataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct DebugDumpResponseT : public flatbuffers::NativeTable {
  typedef DebugDumpResponse TableType;
  bool success;
  uint32_t data_count;
  DebugDumpResponseT()
      : success(false),
        data_count(0) {
  }
};

struct DebugDumpResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef DebugDumpResponseT NativeTableType;
  typedef DebugDumpResponseBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SUCCESS = 4,
    VT_DATA_COUNT = 6
  };
  /// true if the request was accepted and a dump was performed, false if it was
  /// rejected or failed to complete for some reason
  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);
  }
  /// The number of DebugDumpData messages sent in this session
  uint32_t data_count() const {
    return GetField<uint32_t>(VT_DATA_COUNT, 0);
  }
  bool mutate_data_count(uint32_t _data_count) {
    return SetField<uint32_t>(VT_DATA_COUNT, _data_count, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
           VerifyField<uint32_t>(verifier, VT_DATA_COUNT) &&
           verifier.EndTable();
  }
  DebugDumpResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(DebugDumpResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<DebugDumpResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

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

inline flatbuffers::Offset<DebugDumpResponse> CreateDebugDumpResponse(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool success = false,
    uint32_t data_count = 0) {
  DebugDumpResponseBuilder builder_(_fbb);
  builder_.add_data_count(data_count);
  builder_.add_success(success);
  return builder_.Finish();
}

flatbuffers::Offset<DebugDumpResponse> CreateDebugDumpResponse(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct TimeSyncRequestT : public flatbuffers::NativeTable {
  typedef TimeSyncRequest TableType;
  TimeSyncRequestT() {
  }
};

/// A request from CHRE for host to initiate a time sync message
/// (system feature, platform-specific - not all platforms necessarily use this)
struct TimeSyncRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef TimeSyncRequestT NativeTableType;
  typedef TimeSyncRequestBuilder Builder;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
  TimeSyncRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(TimeSyncRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<TimeSyncRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct TimeSyncRequestBuilder {
  typedef TimeSyncRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit TimeSyncRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  TimeSyncRequestBuilder &operator=(const TimeSyncRequestBuilder &);
  flatbuffers::Offset<TimeSyncRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<TimeSyncRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<TimeSyncRequest> CreateTimeSyncRequest(
    flatbuffers::FlatBufferBuilder &_fbb) {
  TimeSyncRequestBuilder builder_(_fbb);
  return builder_.Finish();
}

flatbuffers::Offset<TimeSyncRequest> CreateTimeSyncRequest(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct LowPowerMicAccessRequestT : public flatbuffers::NativeTable {
  typedef LowPowerMicAccessRequest TableType;
  LowPowerMicAccessRequestT() {
  }
};

/// Request from CHRE to enable direct access to data from the low-power
/// microphone. On some systems, coordination via the AP (e.g. with
/// SoundTrigger HAL) is needed to ensure this capability is powered up when
/// CHRE needs it. The host does not send a response.
struct LowPowerMicAccessRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef LowPowerMicAccessRequestT NativeTableType;
  typedef LowPowerMicAccessRequestBuilder Builder;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
  LowPowerMicAccessRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(LowPowerMicAccessRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<LowPowerMicAccessRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LowPowerMicAccessRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct LowPowerMicAccessRequestBuilder {
  typedef LowPowerMicAccessRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit LowPowerMicAccessRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  LowPowerMicAccessRequestBuilder &operator=(const LowPowerMicAccessRequestBuilder &);
  flatbuffers::Offset<LowPowerMicAccessRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<LowPowerMicAccessRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<LowPowerMicAccessRequest> CreateLowPowerMicAccessRequest(
    flatbuffers::FlatBufferBuilder &_fbb) {
  LowPowerMicAccessRequestBuilder builder_(_fbb);
  return builder_.Finish();
}

flatbuffers::Offset<LowPowerMicAccessRequest> CreateLowPowerMicAccessRequest(flatbuffers::FlatBufferBuilder &_fbb, const LowPowerMicAccessRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct LowPowerMicAccessReleaseT : public flatbuffers::NativeTable {
  typedef LowPowerMicAccessRelease TableType;
  LowPowerMicAccessReleaseT() {
  }
};

/// Notification from CHRE that it no longer needs direct access to low-power
/// microphone data.
struct LowPowerMicAccessRelease FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef LowPowerMicAccessReleaseT NativeTableType;
  typedef LowPowerMicAccessReleaseBuilder Builder;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
  LowPowerMicAccessReleaseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(LowPowerMicAccessReleaseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<LowPowerMicAccessRelease> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LowPowerMicAccessReleaseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct LowPowerMicAccessReleaseBuilder {
  typedef LowPowerMicAccessRelease Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit LowPowerMicAccessReleaseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  LowPowerMicAccessReleaseBuilder &operator=(const LowPowerMicAccessReleaseBuilder &);
  flatbuffers::Offset<LowPowerMicAccessRelease> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<LowPowerMicAccessRelease>(end);
    return o;
  }
};

inline flatbuffers::Offset<LowPowerMicAccessRelease> CreateLowPowerMicAccessRelease(
    flatbuffers::FlatBufferBuilder &_fbb) {
  LowPowerMicAccessReleaseBuilder builder_(_fbb);
  return builder_.Finish();
}

flatbuffers::Offset<LowPowerMicAccessRelease> CreateLowPowerMicAccessRelease(flatbuffers::FlatBufferBuilder &_fbb, const LowPowerMicAccessReleaseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct SettingChangeMessageT : public flatbuffers::NativeTable {
  typedef SettingChangeMessage TableType;
  chre::fbs::Setting setting;
  chre::fbs::SettingState state;
  SettingChangeMessageT()
      : setting(chre::fbs::Setting::LOCATION),
        state(chre::fbs::SettingState::DISABLED) {
  }
};

/// Notification from the host that a system setting has changed
struct SettingChangeMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SettingChangeMessageT NativeTableType;
  typedef SettingChangeMessageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SETTING = 4,
    VT_STATE = 6
  };
  /// The setting that has changed
  chre::fbs::Setting setting() const {
    return static_cast<chre::fbs::Setting>(GetField<int8_t>(VT_SETTING, 0));
  }
  bool mutate_setting(chre::fbs::Setting _setting) {
    return SetField<int8_t>(VT_SETTING, static_cast<int8_t>(_setting), 0);
  }
  /// The new setting value
  chre::fbs::SettingState state() const {
    return static_cast<chre::fbs::SettingState>(GetField<int8_t>(VT_STATE, 0));
  }
  bool mutate_state(chre::fbs::SettingState _state) {
    return SetField<int8_t>(VT_STATE, static_cast<int8_t>(_state), 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, VT_SETTING) &&
           VerifyField<int8_t>(verifier, VT_STATE) &&
           verifier.EndTable();
  }
  SettingChangeMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(SettingChangeMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<SettingChangeMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SettingChangeMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct SettingChangeMessageBuilder {
  typedef SettingChangeMessage Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_setting(chre::fbs::Setting setting) {
    fbb_.AddElement<int8_t>(SettingChangeMessage::VT_SETTING, static_cast<int8_t>(setting), 0);
  }
  void add_state(chre::fbs::SettingState state) {
    fbb_.AddElement<int8_t>(SettingChangeMessage::VT_STATE, static_cast<int8_t>(state), 0);
  }
  explicit SettingChangeMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  SettingChangeMessageBuilder &operator=(const SettingChangeMessageBuilder &);
  flatbuffers::Offset<SettingChangeMessage> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SettingChangeMessage>(end);
    return o;
  }
};

inline flatbuffers::Offset<SettingChangeMessage> CreateSettingChangeMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    chre::fbs::Setting setting = chre::fbs::Setting::LOCATION,
    chre::fbs::SettingState state = chre::fbs::SettingState::DISABLED) {
  SettingChangeMessageBuilder builder_(_fbb);
  builder_.add_state(state);
  builder_.add_setting(setting);
  return builder_.Finish();
}

flatbuffers::Offset<SettingChangeMessage> CreateSettingChangeMessage(flatbuffers::FlatBufferBuilder &_fbb, const SettingChangeMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct LogMessageV2T : public flatbuffers::NativeTable {
  typedef LogMessageV2 TableType;
  std::vector<int8_t> buffer;
  uint32_t num_logs_dropped;
  LogMessageV2T()
      : num_logs_dropped(0) {
  }
};

/// Represents V2 log messages from CHRE.
struct LogMessageV2 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef LogMessageV2T NativeTableType;
  typedef LogMessageV2Builder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BUFFER = 4,
    VT_NUM_LOGS_DROPPED = 6
  };
  /// A buffer containing formatted log data. A flat array is used here to avoid
  /// overhead in serializing and deserializing. The format is as follows:
  ///
  /// uint8_t                 - Log metadata, encoded as follows:
  ///                           [EI(Upper nibble) | Level(Lower nibble)]
  ///                            * Log Type
  ///                              (0 = No encoding, 1 = Tokenized log, 2 = BT snoop log)
  ///                            * LogBuffer log level (1 = error, 2 = warn,
  ///                                                   3 = info,  4 = debug,
  ///                                                   5 = verbose)
  /// uint32_t, little-endian - timestamp in milliseconds
  /// char[]                  - Log data buffer
  ///
  /// The log data buffer format is as follows:
  /// * Unencoded (string) logs: The log buffer can be interpreted as a NULL
  ///   terminated string (eg: pass to string manipulation functions, get its
  ///   size via strlen(), etc.).
  ///
  /// * Encoded logs: The first byte of the log buffer indicates the size of
  ///   the actual encoded data to follow. For example, if a tokenized log of
  ///   size 24 bytes were to be represented, a buffer of size 25 bytes would
  ///   be needed to encode this as: [Size(1B) | Data(24B)]. A decoder would
  ///   then have to decode this starting from a 1 byte offset from the
  ///   received buffer.
  ///
  /// * Bt Snoop logs: The first byte of the log buffer indicates the direction
  ///   of the bt snoop log, depending on whether it is incoming for the BT
  ///   controller or outgoing to the arbiter. The second byte indicates the size
  ///   of the actual BT payload followed. For example, if a bt snoop log of
  ///   size 24 bytes were to be represented, a buffer of size 26 bytes would
  ///   be needed to encode this as: [Direction(1B) | Size(1B) | Data(24B)].
  ///
  /// This pattern repeats until the end of the buffer for multiple log
  /// messages. The last byte will always be a null-terminator. There are no
  /// padding bytes between these fields. Treat this like a packed struct and be
  /// cautious with unaligned access when reading/writing this buffer.
  /// Note that the log message might not be null-terminated if an encoding is
  /// used.
  const flatbuffers::Vector<int8_t> *buffer() const {
    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_BUFFER);
  }
  flatbuffers::Vector<int8_t> *mutable_buffer() {
    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_BUFFER);
  }
  /// The number of logs dropped since CHRE started
  uint32_t num_logs_dropped() const {
    return GetField<uint32_t>(VT_NUM_LOGS_DROPPED, 0);
  }
  bool mutate_num_logs_dropped(uint32_t _num_logs_dropped) {
    return SetField<uint32_t>(VT_NUM_LOGS_DROPPED, _num_logs_dropped, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_BUFFER) &&
           verifier.VerifyVector(buffer()) &&
           VerifyField<uint32_t>(verifier, VT_NUM_LOGS_DROPPED) &&
           verifier.EndTable();
  }
  LogMessageV2T *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(LogMessageV2T *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<LogMessageV2> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogMessageV2T* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct LogMessageV2Builder {
  typedef LogMessageV2 Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_buffer(flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer) {
    fbb_.AddOffset(LogMessageV2::VT_BUFFER, buffer);
  }
  void add_num_logs_dropped(uint32_t num_logs_dropped) {
    fbb_.AddElement<uint32_t>(LogMessageV2::VT_NUM_LOGS_DROPPED, num_logs_dropped, 0);
  }
  explicit LogMessageV2Builder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  LogMessageV2Builder &operator=(const LogMessageV2Builder &);
  flatbuffers::Offset<LogMessageV2> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<LogMessageV2>(end);
    return o;
  }
};

inline flatbuffers::Offset<LogMessageV2> CreateLogMessageV2(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer = 0,
    uint32_t num_logs_dropped = 0) {
  LogMessageV2Builder builder_(_fbb);
  builder_.add_num_logs_dropped(num_logs_dropped);
  builder_.add_buffer(buffer);
  return builder_.Finish();
}

inline flatbuffers::Offset<LogMessageV2> CreateLogMessageV2Direct(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int8_t> *buffer = nullptr,
    uint32_t num_logs_dropped = 0) {
  auto buffer__ = buffer ? _fbb.CreateVector<int8_t>(*buffer) : 0;
  return chre::fbs::CreateLogMessageV2(
      _fbb,
      buffer__,
      num_logs_dropped);
}

flatbuffers::Offset<LogMessageV2> CreateLogMessageV2(flatbuffers::FlatBufferBuilder &_fbb, const LogMessageV2T *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct SelfTestRequestT : public flatbuffers::NativeTable {
  typedef SelfTestRequest TableType;
  SelfTestRequestT() {
  }
};

struct SelfTestRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SelfTestRequestT NativeTableType;
  typedef SelfTestRequestBuilder Builder;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
  SelfTestRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(SelfTestRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<SelfTestRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelfTestRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct SelfTestRequestBuilder {
  typedef SelfTestRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit SelfTestRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  SelfTestRequestBuilder &operator=(const SelfTestRequestBuilder &);
  flatbuffers::Offset<SelfTestRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SelfTestRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<SelfTestRequest> CreateSelfTestRequest(
    flatbuffers::FlatBufferBuilder &_fbb) {
  SelfTestRequestBuilder builder_(_fbb);
  return builder_.Finish();
}

flatbuffers::Offset<SelfTestRequest> CreateSelfTestRequest(flatbuffers::FlatBufferBuilder &_fbb, const SelfTestRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct SelfTestResponseT : public flatbuffers::NativeTable {
  typedef SelfTestResponse TableType;
  bool success;
  SelfTestResponseT()
      : success(false) {
  }
};

struct SelfTestResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SelfTestResponseT NativeTableType;
  typedef SelfTestResponseBuilder 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();
  }
  SelfTestResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(SelfTestResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<SelfTestResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelfTestResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

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

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

flatbuffers::Offset<SelfTestResponse> CreateSelfTestResponse(flatbuffers::FlatBufferBuilder &_fbb, const SelfTestResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct HostEndpointConnectedT : public flatbuffers::NativeTable {
  typedef HostEndpointConnected TableType;
  uint16_t host_endpoint;
  uint8_t type;
  std::vector<int8_t> package_name;
  std::vector<int8_t> attribution_tag;
  HostEndpointConnectedT()
      : host_endpoint(0),
        type(0) {
  }
};

struct HostEndpointConnected FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef HostEndpointConnectedT NativeTableType;
  typedef HostEndpointConnectedBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_HOST_ENDPOINT = 4,
    VT_TYPE = 6,
    VT_PACKAGE_NAME = 8,
    VT_ATTRIBUTION_TAG = 10
  };
  /// The host-side endpoint that has connected to the framework.
  uint16_t host_endpoint() const {
    return GetField<uint16_t>(VT_HOST_ENDPOINT, 0);
  }
  bool mutate_host_endpoint(uint16_t _host_endpoint) {
    return SetField<uint16_t>(VT_HOST_ENDPOINT, _host_endpoint, 0);
  }
  /// The type of host endpoint, which should be any of the CHRE_HOST_ENDPOINT_TYPE_*
  /// values defined in the chre_api/chre/event.h.
  uint8_t type() const {
    return GetField<uint8_t>(VT_TYPE, 0);
  }
  bool mutate_type(uint8_t _type) {
    return SetField<uint8_t>(VT_TYPE, _type, 0);
  }
  /// The (optional) package name associated with the host endpoint.
  const flatbuffers::Vector<int8_t> *package_name() const {
    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_PACKAGE_NAME);
  }
  flatbuffers::Vector<int8_t> *mutable_package_name() {
    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_PACKAGE_NAME);
  }
  /// The (optional) attribution tag associated with this host.
  const flatbuffers::Vector<int8_t> *attribution_tag() const {
    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_ATTRIBUTION_TAG);
  }
  flatbuffers::Vector<int8_t> *mutable_attribution_tag() {
    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_ATTRIBUTION_TAG);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint16_t>(verifier, VT_HOST_ENDPOINT) &&
           VerifyField<uint8_t>(verifier, VT_TYPE) &&
           VerifyOffset(verifier, VT_PACKAGE_NAME) &&
           verifier.VerifyVector(package_name()) &&
           VerifyOffset(verifier, VT_ATTRIBUTION_TAG) &&
           verifier.VerifyVector(attribution_tag()) &&
           verifier.EndTable();
  }
  HostEndpointConnectedT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(HostEndpointConnectedT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<HostEndpointConnected> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HostEndpointConnectedT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct HostEndpointConnectedBuilder {
  typedef HostEndpointConnected Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_host_endpoint(uint16_t host_endpoint) {
    fbb_.AddElement<uint16_t>(HostEndpointConnected::VT_HOST_ENDPOINT, host_endpoint, 0);
  }
  void add_type(uint8_t type) {
    fbb_.AddElement<uint8_t>(HostEndpointConnected::VT_TYPE, type, 0);
  }
  void add_package_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> package_name) {
    fbb_.AddOffset(HostEndpointConnected::VT_PACKAGE_NAME, package_name);
  }
  void add_attribution_tag(flatbuffers::Offset<flatbuffers::Vector<int8_t>> attribution_tag) {
    fbb_.AddOffset(HostEndpointConnected::VT_ATTRIBUTION_TAG, attribution_tag);
  }
  explicit HostEndpointConnectedBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  HostEndpointConnectedBuilder &operator=(const HostEndpointConnectedBuilder &);
  flatbuffers::Offset<HostEndpointConnected> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<HostEndpointConnected>(end);
    return o;
  }
};

inline flatbuffers::Offset<HostEndpointConnected> CreateHostEndpointConnected(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint16_t host_endpoint = 0,
    uint8_t type = 0,
    flatbuffers::Offset<flatbuffers::Vector<int8_t>> package_name = 0,
    flatbuffers::Offset<flatbuffers::Vector<int8_t>> attribution_tag = 0) {
  HostEndpointConnectedBuilder builder_(_fbb);
  builder_.add_attribution_tag(attribution_tag);
  builder_.add_package_name(package_name);
  builder_.add_host_endpoint(host_endpoint);
  builder_.add_type(type);
  return builder_.Finish();
}

inline flatbuffers::Offset<HostEndpointConnected> CreateHostEndpointConnectedDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint16_t host_endpoint = 0,
    uint8_t type = 0,
    const std::vector<int8_t> *package_name = nullptr,
    const std::vector<int8_t> *attribution_tag = nullptr) {
  auto package_name__ = package_name ? _fbb.CreateVector<int8_t>(*package_name) : 0;
  auto attribution_tag__ = attribution_tag ? _fbb.CreateVector<int8_t>(*attribution_tag) : 0;
  return chre::fbs::CreateHostEndpointConnected(
      _fbb,
      host_endpoint,
      type,
      package_name__,
      attribution_tag__);
}

flatbuffers::Offset<HostEndpointConnected> CreateHostEndpointConnected(flatbuffers::FlatBufferBuilder &_fbb, const HostEndpointConnectedT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct HostEndpointDisconnectedT : public flatbuffers::NativeTable {
  typedef HostEndpointDisconnected TableType;
  uint16_t host_endpoint;
  HostEndpointDisconnectedT()
      : host_endpoint(0) {
  }
};

struct HostEndpointDisconnected FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef HostEndpointDisconnectedT NativeTableType;
  typedef HostEndpointDisconnectedBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_HOST_ENDPOINT = 4
  };
  /// The host-side endpoint that has disconnected from the framework.
  uint16_t host_endpoint() const {
    return GetField<uint16_t>(VT_HOST_ENDPOINT, 0);
  }
  bool mutate_host_endpoint(uint16_t _host_endpoint) {
    return SetField<uint16_t>(VT_HOST_ENDPOINT, _host_endpoint, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint16_t>(verifier, VT_HOST_ENDPOINT) &&
           verifier.EndTable();
  }
  HostEndpointDisconnectedT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(HostEndpointDisconnectedT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<HostEndpointDisconnected> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HostEndpointDisconnectedT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct HostEndpointDisconnectedBuilder {
  typedef HostEndpointDisconnected Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_host_endpoint(uint16_t host_endpoint) {
    fbb_.AddElement<uint16_t>(HostEndpointDisconnected::VT_HOST_ENDPOINT, host_endpoint, 0);
  }
  explicit HostEndpointDisconnectedBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  HostEndpointDisconnectedBuilder &operator=(const HostEndpointDisconnectedBuilder &);
  flatbuffers::Offset<HostEndpointDisconnected> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<HostEndpointDisconnected>(end);
    return o;
  }
};

inline flatbuffers::Offset<HostEndpointDisconnected> CreateHostEndpointDisconnected(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint16_t host_endpoint = 0) {
  HostEndpointDisconnectedBuilder builder_(_fbb);
  builder_.add_host_endpoint(host_endpoint);
  return builder_.Finish();
}

flatbuffers::Offset<HostEndpointDisconnected> CreateHostEndpointDisconnected(flatbuffers::FlatBufferBuilder &_fbb, const HostEndpointDisconnectedT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct MetricLogT : public flatbuffers::NativeTable {
  typedef MetricLog TableType;
  uint32_t id;
  std::vector<int8_t> encoded_metric;
  MetricLogT()
      : id(0) {
  }
};

struct MetricLog FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef MetricLogT NativeTableType;
  typedef MetricLogBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_ENCODED_METRIC = 6
  };
  uint32_t id() const {
    return GetField<uint32_t>(VT_ID, 0);
  }
  bool mutate_id(uint32_t _id) {
    return SetField<uint32_t>(VT_ID, _id, 0);
  }
  const flatbuffers::Vector<int8_t> *encoded_metric() const {
    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_ENCODED_METRIC);
  }
  flatbuffers::Vector<int8_t> *mutable_encoded_metric() {
    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_ENCODED_METRIC);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_ID) &&
           VerifyOffset(verifier, VT_ENCODED_METRIC) &&
           verifier.VerifyVector(encoded_metric()) &&
           verifier.EndTable();
  }
  MetricLogT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(MetricLogT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<MetricLog> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetricLogT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct MetricLogBuilder {
  typedef MetricLog Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_id(uint32_t id) {
    fbb_.AddElement<uint32_t>(MetricLog::VT_ID, id, 0);
  }
  void add_encoded_metric(flatbuffers::Offset<flatbuffers::Vector<int8_t>> encoded_metric) {
    fbb_.AddOffset(MetricLog::VT_ENCODED_METRIC, encoded_metric);
  }
  explicit MetricLogBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  MetricLogBuilder &operator=(const MetricLogBuilder &);
  flatbuffers::Offset<MetricLog> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<MetricLog>(end);
    return o;
  }
};

inline flatbuffers::Offset<MetricLog> CreateMetricLog(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t id = 0,
    flatbuffers::Offset<flatbuffers::Vector<int8_t>> encoded_metric = 0) {
  MetricLogBuilder builder_(_fbb);
  builder_.add_encoded_metric(encoded_metric);
  builder_.add_id(id);
  return builder_.Finish();
}

inline flatbuffers::Offset<MetricLog> CreateMetricLogDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t id = 0,
    const std::vector<int8_t> *encoded_metric = nullptr) {
  auto encoded_metric__ = encoded_metric ? _fbb.CreateVector<int8_t>(*encoded_metric) : 0;
  return chre::fbs::CreateMetricLog(
      _fbb,
      id,
      encoded_metric__);
}

flatbuffers::Offset<MetricLog> CreateMetricLog(flatbuffers::FlatBufferBuilder &_fbb, const MetricLogT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct BatchedMetricLogT : public flatbuffers::NativeTable {
  typedef BatchedMetricLog TableType;
  std::vector<std::unique_ptr<chre::fbs::MetricLogT>> metrics;
  BatchedMetricLogT() {
  }
};

struct BatchedMetricLog FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef BatchedMetricLogT NativeTableType;
  typedef BatchedMetricLogBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_METRICS = 4
  };
  const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MetricLog>> *metrics() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MetricLog>> *>(VT_METRICS);
  }
  flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MetricLog>> *mutable_metrics() {
    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MetricLog>> *>(VT_METRICS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_METRICS) &&
           verifier.VerifyVector(metrics()) &&
           verifier.VerifyVectorOfTables(metrics()) &&
           verifier.EndTable();
  }
  BatchedMetricLogT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(BatchedMetricLogT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<BatchedMetricLog> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchedMetricLogT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct BatchedMetricLogBuilder {
  typedef BatchedMetricLog Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_metrics(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MetricLog>>> metrics) {
    fbb_.AddOffset(BatchedMetricLog::VT_METRICS, metrics);
  }
  explicit BatchedMetricLogBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  BatchedMetricLogBuilder &operator=(const BatchedMetricLogBuilder &);
  flatbuffers::Offset<BatchedMetricLog> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<BatchedMetricLog>(end);
    return o;
  }
};

inline flatbuffers::Offset<BatchedMetricLog> CreateBatchedMetricLog(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MetricLog>>> metrics = 0) {
  BatchedMetricLogBuilder builder_(_fbb);
  builder_.add_metrics(metrics);
  return builder_.Finish();
}

inline flatbuffers::Offset<BatchedMetricLog> CreateBatchedMetricLogDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<chre::fbs::MetricLog>> *metrics = nullptr) {
  auto metrics__ = metrics ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::MetricLog>>(*metrics) : 0;
  return chre::fbs::CreateBatchedMetricLog(
      _fbb,
      metrics__);
}

flatbuffers::Offset<BatchedMetricLog> CreateBatchedMetricLog(flatbuffers::FlatBufferBuilder &_fbb, const BatchedMetricLogT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct NanConfigurationRequestT : public flatbuffers::NativeTable {
  typedef NanConfigurationRequest TableType;
  bool enable;
  NanConfigurationRequestT()
      : enable(false) {
  }
};

struct NanConfigurationRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef NanConfigurationRequestT NativeTableType;
  typedef NanConfigurationRequestBuilder 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();
  }
  NanConfigurationRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(NanConfigurationRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<NanConfigurationRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanConfigurationRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

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

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

flatbuffers::Offset<NanConfigurationRequest> CreateNanConfigurationRequest(flatbuffers::FlatBufferBuilder &_fbb, const NanConfigurationRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct NanConfigurationUpdateT : public flatbuffers::NativeTable {
  typedef NanConfigurationUpdate TableType;
  bool enabled;
  NanConfigurationUpdateT()
      : enabled(false) {
  }
};

struct NanConfigurationUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef NanConfigurationUpdateT NativeTableType;
  typedef NanConfigurationUpdateBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ENABLED = 4
  };
  bool enabled() const {
    return GetField<uint8_t>(VT_ENABLED, 0) != 0;
  }
  bool mutate_enabled(bool _enabled) {
    return SetField<uint8_t>(VT_ENABLED, static_cast<uint8_t>(_enabled), 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ENABLED) &&
           verifier.EndTable();
  }
  NanConfigurationUpdateT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(NanConfigurationUpdateT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<NanConfigurationUpdate> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanConfigurationUpdateT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct NanConfigurationUpdateBuilder {
  typedef NanConfigurationUpdate Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_enabled(bool enabled) {
    fbb_.AddElement<uint8_t>(NanConfigurationUpdate::VT_ENABLED, static_cast<uint8_t>(enabled), 0);
  }
  explicit NanConfigurationUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  NanConfigurationUpdateBuilder &operator=(const NanConfigurationUpdateBuilder &);
  flatbuffers::Offset<NanConfigurationUpdate> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<NanConfigurationUpdate>(end);
    return o;
  }
};

inline flatbuffers::Offset<NanConfigurationUpdate> CreateNanConfigurationUpdate(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool enabled = false) {
  NanConfigurationUpdateBuilder builder_(_fbb);
  builder_.add_enabled(enabled);
  return builder_.Finish();
}

flatbuffers::Offset<NanConfigurationUpdate> CreateNanConfigurationUpdate(flatbuffers::FlatBufferBuilder &_fbb, const NanConfigurationUpdateT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct DebugConfigurationT : public flatbuffers::NativeTable {
  typedef DebugConfiguration TableType;
  bool health_monitor_failure_crash;
  DebugConfigurationT()
      : health_monitor_failure_crash(false) {
  }
};

struct DebugConfiguration FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef DebugConfigurationT NativeTableType;
  typedef DebugConfigurationBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_HEALTH_MONITOR_FAILURE_CRASH = 4
  };
  bool health_monitor_failure_crash() const {
    return GetField<uint8_t>(VT_HEALTH_MONITOR_FAILURE_CRASH, 0) != 0;
  }
  bool mutate_health_monitor_failure_crash(bool _health_monitor_failure_crash) {
    return SetField<uint8_t>(VT_HEALTH_MONITOR_FAILURE_CRASH, static_cast<uint8_t>(_health_monitor_failure_crash), 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_HEALTH_MONITOR_FAILURE_CRASH) &&
           verifier.EndTable();
  }
  DebugConfigurationT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(DebugConfigurationT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<DebugConfiguration> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugConfigurationT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct DebugConfigurationBuilder {
  typedef DebugConfiguration Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_health_monitor_failure_crash(bool health_monitor_failure_crash) {
    fbb_.AddElement<uint8_t>(DebugConfiguration::VT_HEALTH_MONITOR_FAILURE_CRASH, static_cast<uint8_t>(health_monitor_failure_crash), 0);
  }
  explicit DebugConfigurationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  DebugConfigurationBuilder &operator=(const DebugConfigurationBuilder &);
  flatbuffers::Offset<DebugConfiguration> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<DebugConfiguration>(end);
    return o;
  }
};

inline flatbuffers::Offset<DebugConfiguration> CreateDebugConfiguration(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool health_monitor_failure_crash = false) {
  DebugConfigurationBuilder builder_(_fbb);
  builder_.add_health_monitor_failure_crash(health_monitor_failure_crash);
  return builder_.Finish();
}

flatbuffers::Offset<DebugConfiguration> CreateDebugConfiguration(flatbuffers::FlatBufferBuilder &_fbb, const DebugConfigurationT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct MessageContainerT : public flatbuffers::NativeTable {
  typedef MessageContainer TableType;
  chre::fbs::ChreMessageUnion message;
  std::unique_ptr<chre::fbs::HostAddress> host_addr;
  MessageContainerT() {
  }
};

/// The top-level container that encapsulates all possible messages. Note that
/// per FlatBuffers requirements, we can't use a union as the top-level
/// structure (root type), so we must wrap it in a table.
struct MessageContainer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef MessageContainerT NativeTableType;
  typedef MessageContainerBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_MESSAGE_TYPE = 4,
    VT_MESSAGE = 6,
    VT_HOST_ADDR = 8
  };
  chre::fbs::ChreMessage message_type() const {
    return static_cast<chre::fbs::ChreMessage>(GetField<uint8_t>(VT_MESSAGE_TYPE, 0));
  }
  const void *message() const {
    return GetPointer<const void *>(VT_MESSAGE);
  }
  template<typename T> const T *message_as() const;
  const chre::fbs::NanoappMessage *message_as_NanoappMessage() const {
    return message_type() == chre::fbs::ChreMessage::NanoappMessage ? static_cast<const chre::fbs::NanoappMessage *>(message()) : nullptr;
  }
  const chre::fbs::HubInfoRequest *message_as_HubInfoRequest() const {
    return message_type() == chre::fbs::ChreMessage::HubInfoRequest ? static_cast<const chre::fbs::HubInfoRequest *>(message()) : nullptr;
  }
  const chre::fbs::HubInfoResponse *message_as_HubInfoResponse() const {
    return message_type() == chre::fbs::ChreMessage::HubInfoResponse ? static_cast<const chre::fbs::HubInfoResponse *>(message()) : nullptr;
  }
  const chre::fbs::NanoappListRequest *message_as_NanoappListRequest() const {
    return message_type() == chre::fbs::ChreMessage::NanoappListRequest ? static_cast<const chre::fbs::NanoappListRequest *>(message()) : nullptr;
  }
  const chre::fbs::NanoappListResponse *message_as_NanoappListResponse() const {
    return message_type() == chre::fbs::ChreMessage::NanoappListResponse ? static_cast<const chre::fbs::NanoappListResponse *>(message()) : nullptr;
  }
  const chre::fbs::LoadNanoappRequest *message_as_LoadNanoappRequest() const {
    return message_type() == chre::fbs::ChreMessage::LoadNanoappRequest ? static_cast<const chre::fbs::LoadNanoappRequest *>(message()) : nullptr;
  }
  const chre::fbs::LoadNanoappResponse *message_as_LoadNanoappResponse() const {
    return message_type() == chre::fbs::ChreMessage::LoadNanoappResponse ? static_cast<const chre::fbs::LoadNanoappResponse *>(message()) : nullptr;
  }
  const chre::fbs::UnloadNanoappRequest *message_as_UnloadNanoappRequest() const {
    return message_type() == chre::fbs::ChreMessage::UnloadNanoappRequest ? static_cast<const chre::fbs::UnloadNanoappRequest *>(message()) : nullptr;
  }
  const chre::fbs::UnloadNanoappResponse *message_as_UnloadNanoappResponse() const {
    return message_type() == chre::fbs::ChreMessage::UnloadNanoappResponse ? static_cast<const chre::fbs::UnloadNanoappResponse *>(message()) : nullptr;
  }
  const chre::fbs::LogMessage *message_as_LogMessage() const {
    return message_type() == chre::fbs::ChreMessage::LogMessage ? static_cast<const chre::fbs::LogMessage *>(message()) : nullptr;
  }
  const chre::fbs::TimeSyncMessage *message_as_TimeSyncMessage() const {
    return message_type() == chre::fbs::ChreMessage::TimeSyncMessage ? static_cast<const chre::fbs::TimeSyncMessage *>(message()) : nullptr;
  }
  const chre::fbs::DebugDumpRequest *message_as_DebugDumpRequest() const {
    return message_type() == chre::fbs::ChreMessage::DebugDumpRequest ? static_cast<const chre::fbs::DebugDumpRequest *>(message()) : nullptr;
  }
  const chre::fbs::DebugDumpData *message_as_DebugDumpData() const {
    return message_type() == chre::fbs::ChreMessage::DebugDumpData ? static_cast<const chre::fbs::DebugDumpData *>(message()) : nullptr;
  }
  const chre::fbs::DebugDumpResponse *message_as_DebugDumpResponse() const {
    return message_type() == chre::fbs::ChreMessage::DebugDumpResponse ? static_cast<const chre::fbs::DebugDumpResponse *>(message()) : nullptr;
  }
  const chre::fbs::TimeSyncRequest *message_as_TimeSyncRequest() const {
    return message_type() == chre::fbs::ChreMessage::TimeSyncRequest ? static_cast<const chre::fbs::TimeSyncRequest *>(message()) : nullptr;
  }
  const chre::fbs::LowPowerMicAccessRequest *message_as_LowPowerMicAccessRequest() const {
    return message_type() == chre::fbs::ChreMessage::LowPowerMicAccessRequest ? static_cast<const chre::fbs::LowPowerMicAccessRequest *>(message()) : nullptr;
  }
  const chre::fbs::LowPowerMicAccessRelease *message_as_LowPowerMicAccessRelease() const {
    return message_type() == chre::fbs::ChreMessage::LowPowerMicAccessRelease ? static_cast<const chre::fbs::LowPowerMicAccessRelease *>(message()) : nullptr;
  }
  const chre::fbs::SettingChangeMessage *message_as_SettingChangeMessage() const {
    return message_type() == chre::fbs::ChreMessage::SettingChangeMessage ? static_cast<const chre::fbs::SettingChangeMessage *>(message()) : nullptr;
  }
  const chre::fbs::LogMessageV2 *message_as_LogMessageV2() const {
    return message_type() == chre::fbs::ChreMessage::LogMessageV2 ? static_cast<const chre::fbs::LogMessageV2 *>(message()) : nullptr;
  }
  const chre::fbs::SelfTestRequest *message_as_SelfTestRequest() const {
    return message_type() == chre::fbs::ChreMessage::SelfTestRequest ? static_cast<const chre::fbs::SelfTestRequest *>(message()) : nullptr;
  }
  const chre::fbs::SelfTestResponse *message_as_SelfTestResponse() const {
    return message_type() == chre::fbs::ChreMessage::SelfTestResponse ? static_cast<const chre::fbs::SelfTestResponse *>(message()) : nullptr;
  }
  const chre::fbs::HostEndpointConnected *message_as_HostEndpointConnected() const {
    return message_type() == chre::fbs::ChreMessage::HostEndpointConnected ? static_cast<const chre::fbs::HostEndpointConnected *>(message()) : nullptr;
  }
  const chre::fbs::HostEndpointDisconnected *message_as_HostEndpointDisconnected() const {
    return message_type() == chre::fbs::ChreMessage::HostEndpointDisconnected ? static_cast<const chre::fbs::HostEndpointDisconnected *>(message()) : nullptr;
  }
  const chre::fbs::MetricLog *message_as_MetricLog() const {
    return message_type() == chre::fbs::ChreMessage::MetricLog ? static_cast<const chre::fbs::MetricLog *>(message()) : nullptr;
  }
  const chre::fbs::BatchedMetricLog *message_as_BatchedMetricLog() const {
    return message_type() == chre::fbs::ChreMessage::BatchedMetricLog ? static_cast<const chre::fbs::BatchedMetricLog *>(message()) : nullptr;
  }
  const chre::fbs::NanConfigurationRequest *message_as_NanConfigurationRequest() const {
    return message_type() == chre::fbs::ChreMessage::NanConfigurationRequest ? static_cast<const chre::fbs::NanConfigurationRequest *>(message()) : nullptr;
  }
  const chre::fbs::NanConfigurationUpdate *message_as_NanConfigurationUpdate() const {
    return message_type() == chre::fbs::ChreMessage::NanConfigurationUpdate ? static_cast<const chre::fbs::NanConfigurationUpdate *>(message()) : nullptr;
  }
  const chre::fbs::DebugConfiguration *message_as_DebugConfiguration() const {
    return message_type() == chre::fbs::ChreMessage::DebugConfiguration ? static_cast<const chre::fbs::DebugConfiguration *>(message()) : nullptr;
  }
  void *mutable_message() {
    return GetPointer<void *>(VT_MESSAGE);
  }
  /// The originating or destination client ID on the host side, used to direct
  /// responses only to the client that sent the request. Although initially
  /// populated by the requesting client, this is enforced to be the correct
  /// value by the entity guarding access to CHRE.
  /// This is wrapped in a struct to ensure that it is always included when
  /// encoding the message, so it can be mutated by the host daemon.
  const chre::fbs::HostAddress *host_addr() const {
    return GetStruct<const chre::fbs::HostAddress *>(VT_HOST_ADDR);
  }
  chre::fbs::HostAddress *mutable_host_addr() {
    return GetStruct<chre::fbs::HostAddress *>(VT_HOST_ADDR);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_MESSAGE_TYPE) &&
           VerifyOffsetRequired(verifier, VT_MESSAGE) &&
           VerifyChreMessage(verifier, message(), message_type()) &&
           VerifyFieldRequired<chre::fbs::HostAddress>(verifier, VT_HOST_ADDR) &&
           verifier.EndTable();
  }
  MessageContainerT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(MessageContainerT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<MessageContainer> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

template<> inline const chre::fbs::NanoappMessage *MessageContainer::message_as<chre::fbs::NanoappMessage>() const {
  return message_as_NanoappMessage();
}

template<> inline const chre::fbs::HubInfoRequest *MessageContainer::message_as<chre::fbs::HubInfoRequest>() const {
  return message_as_HubInfoRequest();
}

template<> inline const chre::fbs::HubInfoResponse *MessageContainer::message_as<chre::fbs::HubInfoResponse>() const {
  return message_as_HubInfoResponse();
}

template<> inline const chre::fbs::NanoappListRequest *MessageContainer::message_as<chre::fbs::NanoappListRequest>() const {
  return message_as_NanoappListRequest();
}

template<> inline const chre::fbs::NanoappListResponse *MessageContainer::message_as<chre::fbs::NanoappListResponse>() const {
  return message_as_NanoappListResponse();
}

template<> inline const chre::fbs::LoadNanoappRequest *MessageContainer::message_as<chre::fbs::LoadNanoappRequest>() const {
  return message_as_LoadNanoappRequest();
}

template<> inline const chre::fbs::LoadNanoappResponse *MessageContainer::message_as<chre::fbs::LoadNanoappResponse>() const {
  return message_as_LoadNanoappResponse();
}

template<> inline const chre::fbs::UnloadNanoappRequest *MessageContainer::message_as<chre::fbs::UnloadNanoappRequest>() const {
  return message_as_UnloadNanoappRequest();
}

template<> inline const chre::fbs::UnloadNanoappResponse *MessageContainer::message_as<chre::fbs::UnloadNanoappResponse>() const {
  return message_as_UnloadNanoappResponse();
}

template<> inline const chre::fbs::LogMessage *MessageContainer::message_as<chre::fbs::LogMessage>() const {
  return message_as_LogMessage();
}

template<> inline const chre::fbs::TimeSyncMessage *MessageContainer::message_as<chre::fbs::TimeSyncMessage>() const {
  return message_as_TimeSyncMessage();
}

template<> inline const chre::fbs::DebugDumpRequest *MessageContainer::message_as<chre::fbs::DebugDumpRequest>() const {
  return message_as_DebugDumpRequest();
}

template<> inline const chre::fbs::DebugDumpData *MessageContainer::message_as<chre::fbs::DebugDumpData>() const {
  return message_as_DebugDumpData();
}

template<> inline const chre::fbs::DebugDumpResponse *MessageContainer::message_as<chre::fbs::DebugDumpResponse>() const {
  return message_as_DebugDumpResponse();
}

template<> inline const chre::fbs::TimeSyncRequest *MessageContainer::message_as<chre::fbs::TimeSyncRequest>() const {
  return message_as_TimeSyncRequest();
}

template<> inline const chre::fbs::LowPowerMicAccessRequest *MessageContainer::message_as<chre::fbs::LowPowerMicAccessRequest>() const {
  return message_as_LowPowerMicAccessRequest();
}

template<> inline const chre::fbs::LowPowerMicAccessRelease *MessageContainer::message_as<chre::fbs::LowPowerMicAccessRelease>() const {
  return message_as_LowPowerMicAccessRelease();
}

template<> inline const chre::fbs::SettingChangeMessage *MessageContainer::message_as<chre::fbs::SettingChangeMessage>() const {
  return message_as_SettingChangeMessage();
}

template<> inline const chre::fbs::LogMessageV2 *MessageContainer::message_as<chre::fbs::LogMessageV2>() const {
  return message_as_LogMessageV2();
}

template<> inline const chre::fbs::SelfTestRequest *MessageContainer::message_as<chre::fbs::SelfTestRequest>() const {
  return message_as_SelfTestRequest();
}

template<> inline const chre::fbs::SelfTestResponse *MessageContainer::message_as<chre::fbs::SelfTestResponse>() const {
  return message_as_SelfTestResponse();
}

template<> inline const chre::fbs::HostEndpointConnected *MessageContainer::message_as<chre::fbs::HostEndpointConnected>() const {
  return message_as_HostEndpointConnected();
}

template<> inline const chre::fbs::HostEndpointDisconnected *MessageContainer::message_as<chre::fbs::HostEndpointDisconnected>() const {
  return message_as_HostEndpointDisconnected();
}

template<> inline const chre::fbs::MetricLog *MessageContainer::message_as<chre::fbs::MetricLog>() const {
  return message_as_MetricLog();
}

template<> inline const chre::fbs::BatchedMetricLog *MessageContainer::message_as<chre::fbs::BatchedMetricLog>() const {
  return message_as_BatchedMetricLog();
}

template<> inline const chre::fbs::NanConfigurationRequest *MessageContainer::message_as<chre::fbs::NanConfigurationRequest>() const {
  return message_as_NanConfigurationRequest();
}

template<> inline const chre::fbs::NanConfigurationUpdate *MessageContainer::message_as<chre::fbs::NanConfigurationUpdate>() const {
  return message_as_NanConfigurationUpdate();
}

template<> inline const chre::fbs::DebugConfiguration *MessageContainer::message_as<chre::fbs::DebugConfiguration>() const {
  return message_as_DebugConfiguration();
}

struct MessageContainerBuilder {
  typedef MessageContainer Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_message_type(chre::fbs::ChreMessage message_type) {
    fbb_.AddElement<uint8_t>(MessageContainer::VT_MESSAGE_TYPE, static_cast<uint8_t>(message_type), 0);
  }
  void add_message(flatbuffers::Offset<void> message) {
    fbb_.AddOffset(MessageContainer::VT_MESSAGE, message);
  }
  void add_host_addr(const chre::fbs::HostAddress *host_addr) {
    fbb_.AddStruct(MessageContainer::VT_HOST_ADDR, host_addr);
  }
  explicit MessageContainerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  MessageContainerBuilder &operator=(const MessageContainerBuilder &);
  flatbuffers::Offset<MessageContainer> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<MessageContainer>(end);
    fbb_.Required(o, MessageContainer::VT_MESSAGE);
    fbb_.Required(o, MessageContainer::VT_HOST_ADDR);
    return o;
  }
};

inline flatbuffers::Offset<MessageContainer> CreateMessageContainer(
    flatbuffers::FlatBufferBuilder &_fbb,
    chre::fbs::ChreMessage message_type = chre::fbs::ChreMessage::NONE,
    flatbuffers::Offset<void> message = 0,
    const chre::fbs::HostAddress *host_addr = 0) {
  MessageContainerBuilder builder_(_fbb);
  builder_.add_host_addr(host_addr);
  builder_.add_message(message);
  builder_.add_message_type(message_type);
  return builder_.Finish();
}

flatbuffers::Offset<MessageContainer> CreateMessageContainer(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

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

inline void NanoappMessage::UnPackTo(NanoappMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = app_id(); _o->app_id = _e; }
  { auto _e = message_type(); _o->message_type = _e; }
  { auto _e = host_endpoint(); _o->host_endpoint = _e; }
  { auto _e = message(); if (_e) { _o->message.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->message[_i] = _e->Get(_i); } } }
  { auto _e = message_permissions(); _o->message_permissions = _e; }
  { auto _e = permissions(); _o->permissions = _e; }
  { auto _e = woke_host(); _o->woke_host = _e; }
}

inline flatbuffers::Offset<NanoappMessage> NanoappMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateNanoappMessage(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessage(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NanoappMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _app_id = _o->app_id;
  auto _message_type = _o->message_type;
  auto _host_endpoint = _o->host_endpoint;
  auto _message = _fbb.CreateVector(_o->message);
  auto _message_permissions = _o->message_permissions;
  auto _permissions = _o->permissions;
  auto _woke_host = _o->woke_host;
  return chre::fbs::CreateNanoappMessage(
      _fbb,
      _app_id,
      _message_type,
      _host_endpoint,
      _message,
      _message_permissions,
      _permissions,
      _woke_host);
}

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

inline void HubInfoRequest::UnPackTo(HubInfoRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
}

inline flatbuffers::Offset<HubInfoRequest> HubInfoRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateHubInfoRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HubInfoRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  return chre::fbs::CreateHubInfoRequest(
      _fbb);
}

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

inline void HubInfoResponse::UnPackTo(HubInfoResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = name(); if (_e) { _o->name.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->name[_i] = _e->Get(_i); } } }
  { auto _e = vendor(); if (_e) { _o->vendor.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vendor[_i] = _e->Get(_i); } } }
  { auto _e = toolchain(); if (_e) { _o->toolchain.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->toolchain[_i] = _e->Get(_i); } } }
  { auto _e = platform_version(); _o->platform_version = _e; }
  { auto _e = toolchain_version(); _o->toolchain_version = _e; }
  { auto _e = peak_mips(); _o->peak_mips = _e; }
  { auto _e = stopped_power(); _o->stopped_power = _e; }
  { auto _e = sleep_power(); _o->sleep_power = _e; }
  { auto _e = peak_power(); _o->peak_power = _e; }
  { auto _e = max_msg_len(); _o->max_msg_len = _e; }
  { auto _e = platform_id(); _o->platform_id = _e; }
  { auto _e = chre_platform_version(); _o->chre_platform_version = _e; }
}

inline flatbuffers::Offset<HubInfoResponse> HubInfoResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateHubInfoResponse(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HubInfoResponseT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _name = _o->name.size() ? _fbb.CreateVector(_o->name) : 0;
  auto _vendor = _o->vendor.size() ? _fbb.CreateVector(_o->vendor) : 0;
  auto _toolchain = _o->toolchain.size() ? _fbb.CreateVector(_o->toolchain) : 0;
  auto _platform_version = _o->platform_version;
  auto _toolchain_version = _o->toolchain_version;
  auto _peak_mips = _o->peak_mips;
  auto _stopped_power = _o->stopped_power;
  auto _sleep_power = _o->sleep_power;
  auto _peak_power = _o->peak_power;
  auto _max_msg_len = _o->max_msg_len;
  auto _platform_id = _o->platform_id;
  auto _chre_platform_version = _o->chre_platform_version;
  return chre::fbs::CreateHubInfoResponse(
      _fbb,
      _name,
      _vendor,
      _toolchain,
      _platform_version,
      _toolchain_version,
      _peak_mips,
      _stopped_power,
      _sleep_power,
      _peak_power,
      _max_msg_len,
      _platform_id,
      _chre_platform_version);
}

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

inline void NanoappListRequest::UnPackTo(NanoappListRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
}

inline flatbuffers::Offset<NanoappListRequest> NanoappListRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateNanoappListRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NanoappListRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  return chre::fbs::CreateNanoappListRequest(
      _fbb);
}

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

inline void NanoappRpcService::UnPackTo(NanoappRpcServiceT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = id(); _o->id = _e; }
  { auto _e = version(); _o->version = _e; }
}

inline flatbuffers::Offset<NanoappRpcService> NanoappRpcService::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappRpcServiceT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateNanoappRpcService(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<NanoappRpcService> CreateNanoappRpcService(flatbuffers::FlatBufferBuilder &_fbb, const NanoappRpcServiceT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NanoappRpcServiceT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _id = _o->id;
  auto _version = _o->version;
  return chre::fbs::CreateNanoappRpcService(
      _fbb,
      _id,
      _version);
}

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

inline void NanoappListEntry::UnPackTo(NanoappListEntryT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = app_id(); _o->app_id = _e; }
  { auto _e = version(); _o->version = _e; }
  { auto _e = enabled(); _o->enabled = _e; }
  { auto _e = is_system(); _o->is_system = _e; }
  { auto _e = permissions(); _o->permissions = _e; }
  { auto _e = rpc_services(); if (_e) { _o->rpc_services.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->rpc_services[_i] = std::unique_ptr<chre::fbs::NanoappRpcServiceT>(_e->Get(_i)->UnPack(_resolver)); } } }
}

inline flatbuffers::Offset<NanoappListEntry> NanoappListEntry::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateNanoappListEntry(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NanoappListEntryT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _app_id = _o->app_id;
  auto _version = _o->version;
  auto _enabled = _o->enabled;
  auto _is_system = _o->is_system;
  auto _permissions = _o->permissions;
  auto _rpc_services = _o->rpc_services.size() ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::NanoappRpcService>> (_o->rpc_services.size(), [](size_t i, _VectorArgs *__va) { return CreateNanoappRpcService(*__va->__fbb, __va->__o->rpc_services[i].get(), __va->__rehasher); }, &_va ) : 0;
  return chre::fbs::CreateNanoappListEntry(
      _fbb,
      _app_id,
      _version,
      _enabled,
      _is_system,
      _permissions,
      _rpc_services);
}

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

inline void NanoappListResponse::UnPackTo(NanoappListResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = nanoapps(); if (_e) { _o->nanoapps.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->nanoapps[_i] = std::unique_ptr<chre::fbs::NanoappListEntryT>(_e->Get(_i)->UnPack(_resolver)); } } }
}

inline flatbuffers::Offset<NanoappListResponse> NanoappListResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateNanoappListResponse(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NanoappListResponseT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _nanoapps = _fbb.CreateVector<flatbuffers::Offset<chre::fbs::NanoappListEntry>> (_o->nanoapps.size(), [](size_t i, _VectorArgs *__va) { return CreateNanoappListEntry(*__va->__fbb, __va->__o->nanoapps[i].get(), __va->__rehasher); }, &_va );
  return chre::fbs::CreateNanoappListResponse(
      _fbb,
      _nanoapps);
}

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

inline void LoadNanoappRequest::UnPackTo(LoadNanoappRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = transaction_id(); _o->transaction_id = _e; }
  { auto _e = app_id(); _o->app_id = _e; }
  { auto _e = app_version(); _o->app_version = _e; }
  { auto _e = target_api_version(); _o->target_api_version = _e; }
  { auto _e = app_binary(); if (_e) { _o->app_binary.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->app_binary[_i] = _e->Get(_i); } } }
  { auto _e = fragment_id(); _o->fragment_id = _e; }
  { auto _e = total_app_size(); _o->total_app_size = _e; }
  { auto _e = app_binary_file_name(); if (_e) { _o->app_binary_file_name.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->app_binary_file_name[_i] = _e->Get(_i); } } }
  { auto _e = app_flags(); _o->app_flags = _e; }
  { auto _e = respond_before_start(); _o->respond_before_start = _e; }
}

inline flatbuffers::Offset<LoadNanoappRequest> LoadNanoappRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateLoadNanoappRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LoadNanoappRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _transaction_id = _o->transaction_id;
  auto _app_id = _o->app_id;
  auto _app_version = _o->app_version;
  auto _target_api_version = _o->target_api_version;
  auto _app_binary = _fbb.CreateVector(_o->app_binary);
  auto _fragment_id = _o->fragment_id;
  auto _total_app_size = _o->total_app_size;
  auto _app_binary_file_name = _o->app_binary_file_name.size() ? _fbb.CreateVector(_o->app_binary_file_name) : 0;
  auto _app_flags = _o->app_flags;
  auto _respond_before_start = _o->respond_before_start;
  return chre::fbs::CreateLoadNanoappRequest(
      _fbb,
      _transaction_id,
      _app_id,
      _app_version,
      _target_api_version,
      _app_binary,
      _fragment_id,
      _total_app_size,
      _app_binary_file_name,
      _app_flags,
      _respond_before_start);
}

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

inline void LoadNanoappResponse::UnPackTo(LoadNanoappResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = transaction_id(); _o->transaction_id = _e; }
  { auto _e = success(); _o->success = _e; }
  { auto _e = fragment_id(); _o->fragment_id = _e; }
}

inline flatbuffers::Offset<LoadNanoappResponse> LoadNanoappResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateLoadNanoappResponse(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LoadNanoappResponseT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _transaction_id = _o->transaction_id;
  auto _success = _o->success;
  auto _fragment_id = _o->fragment_id;
  return chre::fbs::CreateLoadNanoappResponse(
      _fbb,
      _transaction_id,
      _success,
      _fragment_id);
}

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

inline void UnloadNanoappRequest::UnPackTo(UnloadNanoappRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = transaction_id(); _o->transaction_id = _e; }
  { auto _e = app_id(); _o->app_id = _e; }
  { auto _e = allow_system_nanoapp_unload(); _o->allow_system_nanoapp_unload = _e; }
}

inline flatbuffers::Offset<UnloadNanoappRequest> UnloadNanoappRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateUnloadNanoappRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<UnloadNanoappRequest> CreateUnloadNanoappRequest(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnloadNanoappRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _transaction_id = _o->transaction_id;
  auto _app_id = _o->app_id;
  auto _allow_system_nanoapp_unload = _o->allow_system_nanoapp_unload;
  return chre::fbs::CreateUnloadNanoappRequest(
      _fbb,
      _transaction_id,
      _app_id,
      _allow_system_nanoapp_unload);
}

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

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

inline flatbuffers::Offset<UnloadNanoappResponse> UnloadNanoappResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateUnloadNanoappResponse(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<UnloadNanoappResponse> CreateUnloadNanoappResponse(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnloadNanoappResponseT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _transaction_id = _o->transaction_id;
  auto _success = _o->success;
  return chre::fbs::CreateUnloadNanoappResponse(
      _fbb,
      _transaction_id,
      _success);
}

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

inline void LogMessage::UnPackTo(LogMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = buffer(); if (_e) { _o->buffer.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->buffer[_i] = _e->Get(_i); } } }
}

inline flatbuffers::Offset<LogMessage> LogMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateLogMessage(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<LogMessage> CreateLogMessage(flatbuffers::FlatBufferBuilder &_fbb, const LogMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _buffer = _o->buffer.size() ? _fbb.CreateVector(_o->buffer) : 0;
  return chre::fbs::CreateLogMessage(
      _fbb,
      _buffer);
}

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

inline void TimeSyncMessage::UnPackTo(TimeSyncMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = offset(); _o->offset = _e; }
}

inline flatbuffers::Offset<TimeSyncMessage> TimeSyncMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateTimeSyncMessage(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<TimeSyncMessage> CreateTimeSyncMessage(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TimeSyncMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _offset = _o->offset;
  return chre::fbs::CreateTimeSyncMessage(
      _fbb,
      _offset);
}

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

inline void DebugDumpRequest::UnPackTo(DebugDumpRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
}

inline flatbuffers::Offset<DebugDumpRequest> DebugDumpRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateDebugDumpRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<DebugDumpRequest> CreateDebugDumpRequest(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DebugDumpRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  return chre::fbs::CreateDebugDumpRequest(
      _fbb);
}

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

inline void DebugDumpData::UnPackTo(DebugDumpDataT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = debug_str(); if (_e) { _o->debug_str.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->debug_str[_i] = _e->Get(_i); } } }
}

inline flatbuffers::Offset<DebugDumpData> DebugDumpData::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpDataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateDebugDumpData(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<DebugDumpData> CreateDebugDumpData(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpDataT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DebugDumpDataT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _debug_str = _o->debug_str.size() ? _fbb.CreateVector(_o->debug_str) : 0;
  return chre::fbs::CreateDebugDumpData(
      _fbb,
      _debug_str);
}

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

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

inline flatbuffers::Offset<DebugDumpResponse> DebugDumpResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateDebugDumpResponse(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<DebugDumpResponse> CreateDebugDumpResponse(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DebugDumpResponseT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _success = _o->success;
  auto _data_count = _o->data_count;
  return chre::fbs::CreateDebugDumpResponse(
      _fbb,
      _success,
      _data_count);
}

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

inline void TimeSyncRequest::UnPackTo(TimeSyncRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
}

inline flatbuffers::Offset<TimeSyncRequest> TimeSyncRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateTimeSyncRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<TimeSyncRequest> CreateTimeSyncRequest(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TimeSyncRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  return chre::fbs::CreateTimeSyncRequest(
      _fbb);
}

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

inline void LowPowerMicAccessRequest::UnPackTo(LowPowerMicAccessRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
}

inline flatbuffers::Offset<LowPowerMicAccessRequest> LowPowerMicAccessRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LowPowerMicAccessRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateLowPowerMicAccessRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<LowPowerMicAccessRequest> CreateLowPowerMicAccessRequest(flatbuffers::FlatBufferBuilder &_fbb, const LowPowerMicAccessRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LowPowerMicAccessRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  return chre::fbs::CreateLowPowerMicAccessRequest(
      _fbb);
}

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

inline void LowPowerMicAccessRelease::UnPackTo(LowPowerMicAccessReleaseT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
}

inline flatbuffers::Offset<LowPowerMicAccessRelease> LowPowerMicAccessRelease::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LowPowerMicAccessReleaseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateLowPowerMicAccessRelease(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<LowPowerMicAccessRelease> CreateLowPowerMicAccessRelease(flatbuffers::FlatBufferBuilder &_fbb, const LowPowerMicAccessReleaseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LowPowerMicAccessReleaseT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  return chre::fbs::CreateLowPowerMicAccessRelease(
      _fbb);
}

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

inline void SettingChangeMessage::UnPackTo(SettingChangeMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = setting(); _o->setting = _e; }
  { auto _e = state(); _o->state = _e; }
}

inline flatbuffers::Offset<SettingChangeMessage> SettingChangeMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SettingChangeMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateSettingChangeMessage(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<SettingChangeMessage> CreateSettingChangeMessage(flatbuffers::FlatBufferBuilder &_fbb, const SettingChangeMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SettingChangeMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _setting = _o->setting;
  auto _state = _o->state;
  return chre::fbs::CreateSettingChangeMessage(
      _fbb,
      _setting,
      _state);
}

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

inline void LogMessageV2::UnPackTo(LogMessageV2T *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = buffer(); if (_e) { _o->buffer.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->buffer[_i] = _e->Get(_i); } } }
  { auto _e = num_logs_dropped(); _o->num_logs_dropped = _e; }
}

inline flatbuffers::Offset<LogMessageV2> LogMessageV2::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogMessageV2T* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateLogMessageV2(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<LogMessageV2> CreateLogMessageV2(flatbuffers::FlatBufferBuilder &_fbb, const LogMessageV2T *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogMessageV2T* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _buffer = _o->buffer.size() ? _fbb.CreateVector(_o->buffer) : 0;
  auto _num_logs_dropped = _o->num_logs_dropped;
  return chre::fbs::CreateLogMessageV2(
      _fbb,
      _buffer,
      _num_logs_dropped);
}

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

inline void SelfTestRequest::UnPackTo(SelfTestRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
}

inline flatbuffers::Offset<SelfTestRequest> SelfTestRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelfTestRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateSelfTestRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<SelfTestRequest> CreateSelfTestRequest(flatbuffers::FlatBufferBuilder &_fbb, const SelfTestRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SelfTestRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  return chre::fbs::CreateSelfTestRequest(
      _fbb);
}

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

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

inline flatbuffers::Offset<SelfTestResponse> SelfTestResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelfTestResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateSelfTestResponse(_fbb, _o, _rehasher);
}

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

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

inline void HostEndpointConnected::UnPackTo(HostEndpointConnectedT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = host_endpoint(); _o->host_endpoint = _e; }
  { auto _e = type(); _o->type = _e; }
  { auto _e = package_name(); if (_e) { _o->package_name.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->package_name[_i] = _e->Get(_i); } } }
  { auto _e = attribution_tag(); if (_e) { _o->attribution_tag.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->attribution_tag[_i] = _e->Get(_i); } } }
}

inline flatbuffers::Offset<HostEndpointConnected> HostEndpointConnected::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HostEndpointConnectedT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateHostEndpointConnected(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<HostEndpointConnected> CreateHostEndpointConnected(flatbuffers::FlatBufferBuilder &_fbb, const HostEndpointConnectedT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HostEndpointConnectedT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _host_endpoint = _o->host_endpoint;
  auto _type = _o->type;
  auto _package_name = _o->package_name.size() ? _fbb.CreateVector(_o->package_name) : 0;
  auto _attribution_tag = _o->attribution_tag.size() ? _fbb.CreateVector(_o->attribution_tag) : 0;
  return chre::fbs::CreateHostEndpointConnected(
      _fbb,
      _host_endpoint,
      _type,
      _package_name,
      _attribution_tag);
}

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

inline void HostEndpointDisconnected::UnPackTo(HostEndpointDisconnectedT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = host_endpoint(); _o->host_endpoint = _e; }
}

inline flatbuffers::Offset<HostEndpointDisconnected> HostEndpointDisconnected::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HostEndpointDisconnectedT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateHostEndpointDisconnected(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<HostEndpointDisconnected> CreateHostEndpointDisconnected(flatbuffers::FlatBufferBuilder &_fbb, const HostEndpointDisconnectedT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HostEndpointDisconnectedT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _host_endpoint = _o->host_endpoint;
  return chre::fbs::CreateHostEndpointDisconnected(
      _fbb,
      _host_endpoint);
}

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

inline void MetricLog::UnPackTo(MetricLogT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = id(); _o->id = _e; }
  { auto _e = encoded_metric(); if (_e) { _o->encoded_metric.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->encoded_metric[_i] = _e->Get(_i); } } }
}

inline flatbuffers::Offset<MetricLog> MetricLog::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetricLogT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateMetricLog(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<MetricLog> CreateMetricLog(flatbuffers::FlatBufferBuilder &_fbb, const MetricLogT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MetricLogT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _id = _o->id;
  auto _encoded_metric = _o->encoded_metric.size() ? _fbb.CreateVector(_o->encoded_metric) : 0;
  return chre::fbs::CreateMetricLog(
      _fbb,
      _id,
      _encoded_metric);
}

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

inline void BatchedMetricLog::UnPackTo(BatchedMetricLogT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = metrics(); if (_e) { _o->metrics.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->metrics[_i] = std::unique_ptr<chre::fbs::MetricLogT>(_e->Get(_i)->UnPack(_resolver)); } } }
}

inline flatbuffers::Offset<BatchedMetricLog> BatchedMetricLog::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchedMetricLogT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateBatchedMetricLog(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<BatchedMetricLog> CreateBatchedMetricLog(flatbuffers::FlatBufferBuilder &_fbb, const BatchedMetricLogT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BatchedMetricLogT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _metrics = _o->metrics.size() ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::MetricLog>> (_o->metrics.size(), [](size_t i, _VectorArgs *__va) { return CreateMetricLog(*__va->__fbb, __va->__o->metrics[i].get(), __va->__rehasher); }, &_va ) : 0;
  return chre::fbs::CreateBatchedMetricLog(
      _fbb,
      _metrics);
}

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

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

inline flatbuffers::Offset<NanConfigurationRequest> NanConfigurationRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanConfigurationRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateNanConfigurationRequest(_fbb, _o, _rehasher);
}

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

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

inline void NanConfigurationUpdate::UnPackTo(NanConfigurationUpdateT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = enabled(); _o->enabled = _e; }
}

inline flatbuffers::Offset<NanConfigurationUpdate> NanConfigurationUpdate::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanConfigurationUpdateT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateNanConfigurationUpdate(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<NanConfigurationUpdate> CreateNanConfigurationUpdate(flatbuffers::FlatBufferBuilder &_fbb, const NanConfigurationUpdateT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NanConfigurationUpdateT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _enabled = _o->enabled;
  return chre::fbs::CreateNanConfigurationUpdate(
      _fbb,
      _enabled);
}

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

inline void DebugConfiguration::UnPackTo(DebugConfigurationT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = health_monitor_failure_crash(); _o->health_monitor_failure_crash = _e; }
}

inline flatbuffers::Offset<DebugConfiguration> DebugConfiguration::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugConfigurationT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateDebugConfiguration(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<DebugConfiguration> CreateDebugConfiguration(flatbuffers::FlatBufferBuilder &_fbb, const DebugConfigurationT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DebugConfigurationT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _health_monitor_failure_crash = _o->health_monitor_failure_crash;
  return chre::fbs::CreateDebugConfiguration(
      _fbb,
      _health_monitor_failure_crash);
}

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

inline void MessageContainer::UnPackTo(MessageContainerT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = message_type(); _o->message.type = _e; }
  { auto _e = message(); if (_e) _o->message.value = chre::fbs::ChreMessageUnion::UnPack(_e, message_type(), _resolver); }
  { auto _e = host_addr(); if (_e) _o->host_addr = std::unique_ptr<chre::fbs::HostAddress>(new chre::fbs::HostAddress(*_e)); }
}

inline flatbuffers::Offset<MessageContainer> MessageContainer::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateMessageContainer(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<MessageContainer> CreateMessageContainer(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MessageContainerT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _message_type = _o->message.type;
  auto _message = _o->message.Pack(_fbb);
  auto _host_addr = _o->host_addr ? _o->host_addr.get() : 0;
  return chre::fbs::CreateMessageContainer(
      _fbb,
      _message_type,
      _message,
      _host_addr);
}

inline bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type) {
  switch (type) {
    case ChreMessage::NONE: {
      return true;
    }
    case ChreMessage::NanoappMessage: {
      auto ptr = reinterpret_cast<const chre::fbs::NanoappMessage *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::HubInfoRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::HubInfoRequest *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::HubInfoResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::HubInfoResponse *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::NanoappListRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::NanoappListRequest *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::NanoappListResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::NanoappListResponse *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::LoadNanoappRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::LoadNanoappRequest *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::LoadNanoappResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::LoadNanoappResponse *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::UnloadNanoappRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::UnloadNanoappRequest *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::UnloadNanoappResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::UnloadNanoappResponse *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::LogMessage: {
      auto ptr = reinterpret_cast<const chre::fbs::LogMessage *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::TimeSyncMessage: {
      auto ptr = reinterpret_cast<const chre::fbs::TimeSyncMessage *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::DebugDumpRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::DebugDumpRequest *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::DebugDumpData: {
      auto ptr = reinterpret_cast<const chre::fbs::DebugDumpData *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::DebugDumpResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::DebugDumpResponse *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::TimeSyncRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::TimeSyncRequest *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::LowPowerMicAccessRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::LowPowerMicAccessRequest *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::LowPowerMicAccessRelease: {
      auto ptr = reinterpret_cast<const chre::fbs::LowPowerMicAccessRelease *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::SettingChangeMessage: {
      auto ptr = reinterpret_cast<const chre::fbs::SettingChangeMessage *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::LogMessageV2: {
      auto ptr = reinterpret_cast<const chre::fbs::LogMessageV2 *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::SelfTestRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::SelfTestRequest *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::SelfTestResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::SelfTestResponse *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::HostEndpointConnected: {
      auto ptr = reinterpret_cast<const chre::fbs::HostEndpointConnected *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::HostEndpointDisconnected: {
      auto ptr = reinterpret_cast<const chre::fbs::HostEndpointDisconnected *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::MetricLog: {
      auto ptr = reinterpret_cast<const chre::fbs::MetricLog *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::BatchedMetricLog: {
      auto ptr = reinterpret_cast<const chre::fbs::BatchedMetricLog *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::NanConfigurationRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::NanConfigurationRequest *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::NanConfigurationUpdate: {
      auto ptr = reinterpret_cast<const chre::fbs::NanConfigurationUpdate *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case ChreMessage::DebugConfiguration: {
      auto ptr = reinterpret_cast<const chre::fbs::DebugConfiguration *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}

inline bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
  if (!values || !types) return !values && !types;
  if (values->size() != types->size()) return false;
  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
    if (!VerifyChreMessage(
        verifier,  values->Get(i), types->GetEnum<ChreMessage>(i))) {
      return false;
    }
  }
  return true;
}

inline void *ChreMessageUnion::UnPack(const void *obj, ChreMessage type, const flatbuffers::resolver_function_t *resolver) {
  switch (type) {
    case ChreMessage::NanoappMessage: {
      auto ptr = reinterpret_cast<const chre::fbs::NanoappMessage *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::HubInfoRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::HubInfoRequest *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::HubInfoResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::HubInfoResponse *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::NanoappListRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::NanoappListRequest *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::NanoappListResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::NanoappListResponse *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::LoadNanoappRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::LoadNanoappRequest *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::LoadNanoappResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::LoadNanoappResponse *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::UnloadNanoappRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::UnloadNanoappRequest *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::UnloadNanoappResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::UnloadNanoappResponse *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::LogMessage: {
      auto ptr = reinterpret_cast<const chre::fbs::LogMessage *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::TimeSyncMessage: {
      auto ptr = reinterpret_cast<const chre::fbs::TimeSyncMessage *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::DebugDumpRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::DebugDumpRequest *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::DebugDumpData: {
      auto ptr = reinterpret_cast<const chre::fbs::DebugDumpData *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::DebugDumpResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::DebugDumpResponse *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::TimeSyncRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::TimeSyncRequest *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::LowPowerMicAccessRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::LowPowerMicAccessRequest *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::LowPowerMicAccessRelease: {
      auto ptr = reinterpret_cast<const chre::fbs::LowPowerMicAccessRelease *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::SettingChangeMessage: {
      auto ptr = reinterpret_cast<const chre::fbs::SettingChangeMessage *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::LogMessageV2: {
      auto ptr = reinterpret_cast<const chre::fbs::LogMessageV2 *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::SelfTestRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::SelfTestRequest *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::SelfTestResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::SelfTestResponse *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::HostEndpointConnected: {
      auto ptr = reinterpret_cast<const chre::fbs::HostEndpointConnected *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::HostEndpointDisconnected: {
      auto ptr = reinterpret_cast<const chre::fbs::HostEndpointDisconnected *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::MetricLog: {
      auto ptr = reinterpret_cast<const chre::fbs::MetricLog *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::BatchedMetricLog: {
      auto ptr = reinterpret_cast<const chre::fbs::BatchedMetricLog *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::NanConfigurationRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::NanConfigurationRequest *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::NanConfigurationUpdate: {
      auto ptr = reinterpret_cast<const chre::fbs::NanConfigurationUpdate *>(obj);
      return ptr->UnPack(resolver);
    }
    case ChreMessage::DebugConfiguration: {
      auto ptr = reinterpret_cast<const chre::fbs::DebugConfiguration *>(obj);
      return ptr->UnPack(resolver);
    }
    default: return nullptr;
  }
}

inline flatbuffers::Offset<void> ChreMessageUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
  switch (type) {
    case ChreMessage::NanoappMessage: {
      auto ptr = reinterpret_cast<const chre::fbs::NanoappMessageT *>(value);
      return CreateNanoappMessage(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::HubInfoRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::HubInfoRequestT *>(value);
      return CreateHubInfoRequest(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::HubInfoResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::HubInfoResponseT *>(value);
      return CreateHubInfoResponse(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::NanoappListRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::NanoappListRequestT *>(value);
      return CreateNanoappListRequest(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::NanoappListResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::NanoappListResponseT *>(value);
      return CreateNanoappListResponse(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::LoadNanoappRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::LoadNanoappRequestT *>(value);
      return CreateLoadNanoappRequest(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::LoadNanoappResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::LoadNanoappResponseT *>(value);
      return CreateLoadNanoappResponse(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::UnloadNanoappRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::UnloadNanoappRequestT *>(value);
      return CreateUnloadNanoappRequest(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::UnloadNanoappResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::UnloadNanoappResponseT *>(value);
      return CreateUnloadNanoappResponse(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::LogMessage: {
      auto ptr = reinterpret_cast<const chre::fbs::LogMessageT *>(value);
      return CreateLogMessage(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::TimeSyncMessage: {
      auto ptr = reinterpret_cast<const chre::fbs::TimeSyncMessageT *>(value);
      return CreateTimeSyncMessage(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::DebugDumpRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::DebugDumpRequestT *>(value);
      return CreateDebugDumpRequest(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::DebugDumpData: {
      auto ptr = reinterpret_cast<const chre::fbs::DebugDumpDataT *>(value);
      return CreateDebugDumpData(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::DebugDumpResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::DebugDumpResponseT *>(value);
      return CreateDebugDumpResponse(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::TimeSyncRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::TimeSyncRequestT *>(value);
      return CreateTimeSyncRequest(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::LowPowerMicAccessRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::LowPowerMicAccessRequestT *>(value);
      return CreateLowPowerMicAccessRequest(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::LowPowerMicAccessRelease: {
      auto ptr = reinterpret_cast<const chre::fbs::LowPowerMicAccessReleaseT *>(value);
      return CreateLowPowerMicAccessRelease(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::SettingChangeMessage: {
      auto ptr = reinterpret_cast<const chre::fbs::SettingChangeMessageT *>(value);
      return CreateSettingChangeMessage(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::LogMessageV2: {
      auto ptr = reinterpret_cast<const chre::fbs::LogMessageV2T *>(value);
      return CreateLogMessageV2(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::SelfTestRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::SelfTestRequestT *>(value);
      return CreateSelfTestRequest(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::SelfTestResponse: {
      auto ptr = reinterpret_cast<const chre::fbs::SelfTestResponseT *>(value);
      return CreateSelfTestResponse(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::HostEndpointConnected: {
      auto ptr = reinterpret_cast<const chre::fbs::HostEndpointConnectedT *>(value);
      return CreateHostEndpointConnected(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::HostEndpointDisconnected: {
      auto ptr = reinterpret_cast<const chre::fbs::HostEndpointDisconnectedT *>(value);
      return CreateHostEndpointDisconnected(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::MetricLog: {
      auto ptr = reinterpret_cast<const chre::fbs::MetricLogT *>(value);
      return CreateMetricLog(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::BatchedMetricLog: {
      auto ptr = reinterpret_cast<const chre::fbs::BatchedMetricLogT *>(value);
      return CreateBatchedMetricLog(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::NanConfigurationRequest: {
      auto ptr = reinterpret_cast<const chre::fbs::NanConfigurationRequestT *>(value);
      return CreateNanConfigurationRequest(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::NanConfigurationUpdate: {
      auto ptr = reinterpret_cast<const chre::fbs::NanConfigurationUpdateT *>(value);
      return CreateNanConfigurationUpdate(_fbb, ptr, _rehasher).Union();
    }
    case ChreMessage::DebugConfiguration: {
      auto ptr = reinterpret_cast<const chre::fbs::DebugConfigurationT *>(value);
      return CreateDebugConfiguration(_fbb, ptr, _rehasher).Union();
    }
    default: return 0;
  }
}

inline ChreMessageUnion::ChreMessageUnion(const ChreMessageUnion &u) : type(u.type), value(nullptr) {
  switch (type) {
    case ChreMessage::NanoappMessage: {
      value = new chre::fbs::NanoappMessageT(*reinterpret_cast<chre::fbs::NanoappMessageT *>(u.value));
      break;
    }
    case ChreMessage::HubInfoRequest: {
      value = new chre::fbs::HubInfoRequestT(*reinterpret_cast<chre::fbs::HubInfoRequestT *>(u.value));
      break;
    }
    case ChreMessage::HubInfoResponse: {
      value = new chre::fbs::HubInfoResponseT(*reinterpret_cast<chre::fbs::HubInfoResponseT *>(u.value));
      break;
    }
    case ChreMessage::NanoappListRequest: {
      value = new chre::fbs::NanoappListRequestT(*reinterpret_cast<chre::fbs::NanoappListRequestT *>(u.value));
      break;
    }
    case ChreMessage::NanoappListResponse: {
      FLATBUFFERS_ASSERT(false);  // chre::fbs::NanoappListResponseT not copyable.
      break;
    }
    case ChreMessage::LoadNanoappRequest: {
      value = new chre::fbs::LoadNanoappRequestT(*reinterpret_cast<chre::fbs::LoadNanoappRequestT *>(u.value));
      break;
    }
    case ChreMessage::LoadNanoappResponse: {
      value = new chre::fbs::LoadNanoappResponseT(*reinterpret_cast<chre::fbs::LoadNanoappResponseT *>(u.value));
      break;
    }
    case ChreMessage::UnloadNanoappRequest: {
      value = new chre::fbs::UnloadNanoappRequestT(*reinterpret_cast<chre::fbs::UnloadNanoappRequestT *>(u.value));
      break;
    }
    case ChreMessage::UnloadNanoappResponse: {
      value = new chre::fbs::UnloadNanoappResponseT(*reinterpret_cast<chre::fbs::UnloadNanoappResponseT *>(u.value));
      break;
    }
    case ChreMessage::LogMessage: {
      value = new chre::fbs::LogMessageT(*reinterpret_cast<chre::fbs::LogMessageT *>(u.value));
      break;
    }
    case ChreMessage::TimeSyncMessage: {
      value = new chre::fbs::TimeSyncMessageT(*reinterpret_cast<chre::fbs::TimeSyncMessageT *>(u.value));
      break;
    }
    case ChreMessage::DebugDumpRequest: {
      value = new chre::fbs::DebugDumpRequestT(*reinterpret_cast<chre::fbs::DebugDumpRequestT *>(u.value));
      break;
    }
    case ChreMessage::DebugDumpData: {
      value = new chre::fbs::DebugDumpDataT(*reinterpret_cast<chre::fbs::DebugDumpDataT *>(u.value));
      break;
    }
    case ChreMessage::DebugDumpResponse: {
      value = new chre::fbs::DebugDumpResponseT(*reinterpret_cast<chre::fbs::DebugDumpResponseT *>(u.value));
      break;
    }
    case ChreMessage::TimeSyncRequest: {
      value = new chre::fbs::TimeSyncRequestT(*reinterpret_cast<chre::fbs::TimeSyncRequestT *>(u.value));
      break;
    }
    case ChreMessage::LowPowerMicAccessRequest: {
      value = new chre::fbs::LowPowerMicAccessRequestT(*reinterpret_cast<chre::fbs::LowPowerMicAccessRequestT *>(u.value));
      break;
    }
    case ChreMessage::LowPowerMicAccessRelease: {
      value = new chre::fbs::LowPowerMicAccessReleaseT(*reinterpret_cast<chre::fbs::LowPowerMicAccessReleaseT *>(u.value));
      break;
    }
    case ChreMessage::SettingChangeMessage: {
      value = new chre::fbs::SettingChangeMessageT(*reinterpret_cast<chre::fbs::SettingChangeMessageT *>(u.value));
      break;
    }
    case ChreMessage::LogMessageV2: {
      value = new chre::fbs::LogMessageV2T(*reinterpret_cast<chre::fbs::LogMessageV2T *>(u.value));
      break;
    }
    case ChreMessage::SelfTestRequest: {
      value = new chre::fbs::SelfTestRequestT(*reinterpret_cast<chre::fbs::SelfTestRequestT *>(u.value));
      break;
    }
    case ChreMessage::SelfTestResponse: {
      value = new chre::fbs::SelfTestResponseT(*reinterpret_cast<chre::fbs::SelfTestResponseT *>(u.value));
      break;
    }
    case ChreMessage::HostEndpointConnected: {
      value = new chre::fbs::HostEndpointConnectedT(*reinterpret_cast<chre::fbs::HostEndpointConnectedT *>(u.value));
      break;
    }
    case ChreMessage::HostEndpointDisconnected: {
      value = new chre::fbs::HostEndpointDisconnectedT(*reinterpret_cast<chre::fbs::HostEndpointDisconnectedT *>(u.value));
      break;
    }
    case ChreMessage::MetricLog: {
      value = new chre::fbs::MetricLogT(*reinterpret_cast<chre::fbs::MetricLogT *>(u.value));
      break;
    }
    case ChreMessage::BatchedMetricLog: {
      FLATBUFFERS_ASSERT(false);  // chre::fbs::BatchedMetricLogT not copyable.
      break;
    }
    case ChreMessage::NanConfigurationRequest: {
      value = new chre::fbs::NanConfigurationRequestT(*reinterpret_cast<chre::fbs::NanConfigurationRequestT *>(u.value));
      break;
    }
    case ChreMessage::NanConfigurationUpdate: {
      value = new chre::fbs::NanConfigurationUpdateT(*reinterpret_cast<chre::fbs::NanConfigurationUpdateT *>(u.value));
      break;
    }
    case ChreMessage::DebugConfiguration: {
      value = new chre::fbs::DebugConfigurationT(*reinterpret_cast<chre::fbs::DebugConfigurationT *>(u.value));
      break;
    }
    default:
      break;
  }
}

inline void ChreMessageUnion::Reset() {
  switch (type) {
    case ChreMessage::NanoappMessage: {
      auto ptr = reinterpret_cast<chre::fbs::NanoappMessageT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::HubInfoRequest: {
      auto ptr = reinterpret_cast<chre::fbs::HubInfoRequestT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::HubInfoResponse: {
      auto ptr = reinterpret_cast<chre::fbs::HubInfoResponseT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::NanoappListRequest: {
      auto ptr = reinterpret_cast<chre::fbs::NanoappListRequestT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::NanoappListResponse: {
      auto ptr = reinterpret_cast<chre::fbs::NanoappListResponseT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::LoadNanoappRequest: {
      auto ptr = reinterpret_cast<chre::fbs::LoadNanoappRequestT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::LoadNanoappResponse: {
      auto ptr = reinterpret_cast<chre::fbs::LoadNanoappResponseT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::UnloadNanoappRequest: {
      auto ptr = reinterpret_cast<chre::fbs::UnloadNanoappRequestT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::UnloadNanoappResponse: {
      auto ptr = reinterpret_cast<chre::fbs::UnloadNanoappResponseT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::LogMessage: {
      auto ptr = reinterpret_cast<chre::fbs::LogMessageT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::TimeSyncMessage: {
      auto ptr = reinterpret_cast<chre::fbs::TimeSyncMessageT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::DebugDumpRequest: {
      auto ptr = reinterpret_cast<chre::fbs::DebugDumpRequestT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::DebugDumpData: {
      auto ptr = reinterpret_cast<chre::fbs::DebugDumpDataT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::DebugDumpResponse: {
      auto ptr = reinterpret_cast<chre::fbs::DebugDumpResponseT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::TimeSyncRequest: {
      auto ptr = reinterpret_cast<chre::fbs::TimeSyncRequestT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::LowPowerMicAccessRequest: {
      auto ptr = reinterpret_cast<chre::fbs::LowPowerMicAccessRequestT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::LowPowerMicAccessRelease: {
      auto ptr = reinterpret_cast<chre::fbs::LowPowerMicAccessReleaseT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::SettingChangeMessage: {
      auto ptr = reinterpret_cast<chre::fbs::SettingChangeMessageT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::LogMessageV2: {
      auto ptr = reinterpret_cast<chre::fbs::LogMessageV2T *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::SelfTestRequest: {
      auto ptr = reinterpret_cast<chre::fbs::SelfTestRequestT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::SelfTestResponse: {
      auto ptr = reinterpret_cast<chre::fbs::SelfTestResponseT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::HostEndpointConnected: {
      auto ptr = reinterpret_cast<chre::fbs::HostEndpointConnectedT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::HostEndpointDisconnected: {
      auto ptr = reinterpret_cast<chre::fbs::HostEndpointDisconnectedT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::MetricLog: {
      auto ptr = reinterpret_cast<chre::fbs::MetricLogT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::BatchedMetricLog: {
      auto ptr = reinterpret_cast<chre::fbs::BatchedMetricLogT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::NanConfigurationRequest: {
      auto ptr = reinterpret_cast<chre::fbs::NanConfigurationRequestT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::NanConfigurationUpdate: {
      auto ptr = reinterpret_cast<chre::fbs::NanConfigurationUpdateT *>(value);
      delete ptr;
      break;
    }
    case ChreMessage::DebugConfiguration: {
      auto ptr = reinterpret_cast<chre::fbs::DebugConfigurationT *>(value);
      delete ptr;
      break;
    }
    default: break;
  }
  value = nullptr;
  type = ChreMessage::NONE;
}

inline const chre::fbs::MessageContainer *GetMessageContainer(const void *buf) {
  return flatbuffers::GetRoot<chre::fbs::MessageContainer>(buf);
}

inline const chre::fbs::MessageContainer *GetSizePrefixedMessageContainer(const void *buf) {
  return flatbuffers::GetSizePrefixedRoot<chre::fbs::MessageContainer>(buf);
}

inline MessageContainer *GetMutableMessageContainer(void *buf) {
  return flatbuffers::GetMutableRoot<MessageContainer>(buf);
}

inline bool VerifyMessageContainerBuffer(
    flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<chre::fbs::MessageContainer>(nullptr);
}

inline bool VerifySizePrefixedMessageContainerBuffer(
    flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<chre::fbs::MessageContainer>(nullptr);
}

inline void FinishMessageContainerBuffer(
    flatbuffers::FlatBufferBuilder &fbb,
    flatbuffers::Offset<chre::fbs::MessageContainer> root) {
  fbb.Finish(root);
}

inline void FinishSizePrefixedMessageContainerBuffer(
    flatbuffers::FlatBufferBuilder &fbb,
    flatbuffers::Offset<chre::fbs::MessageContainer> root) {
  fbb.FinishSizePrefixed(root);
}

inline std::unique_ptr<chre::fbs::MessageContainerT> UnPackMessageContainer(
    const void *buf,
    const flatbuffers::resolver_function_t *res = nullptr) {
  return std::unique_ptr<chre::fbs::MessageContainerT>(GetMessageContainer(buf)->UnPack(res));
}

inline std::unique_ptr<chre::fbs::MessageContainerT> UnPackSizePrefixedMessageContainer(
    const void *buf,
    const flatbuffers::resolver_function_t *res = nullptr) {
  return std::unique_ptr<chre::fbs::MessageContainerT>(GetSizePrefixedMessageContainer(buf)->UnPack(res));
}

}  // namespace fbs
}  // namespace chre

#endif  // FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_