From 1c4f8ae97342e7bba9647cda58f3d5e0908dcc4b Mon Sep 17 00:00:00 2001
From: Johnathon Slightham <slighthamj@gmail.com>
Date: Tue, 8 Jul 2025 11:01:20 -0400
Subject: [PATCH] Create ConfigMessage_generated.h

---
 .../ConfigMessage_generated.h                 | 634 ++++++++++++++++++
 1 file changed, 634 insertions(+)
 create mode 100644 components/flatbuffers/include/flatbuffers_generated/ConfigMessage_generated.h

diff --git a/components/flatbuffers/include/flatbuffers_generated/ConfigMessage_generated.h b/components/flatbuffers/include/flatbuffers_generated/ConfigMessage_generated.h
new file mode 100644
index 0000000..c2698ef
--- /dev/null
+++ b/components/flatbuffers/include/flatbuffers_generated/ConfigMessage_generated.h
@@ -0,0 +1,634 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_CONFIGMESSAGE_MESSAGING_H_
+#define FLATBUFFERS_GENERATED_CONFIGMESSAGE_MESSAGING_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+//static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
+//              FLATBUFFERS_VERSION_MINOR == 2 &&
+//              FLATBUFFERS_VERSION_REVISION == 10,
+//             "Non-compatible flatbuffers version included");
+
+namespace Messaging {
+
+struct I32Value;
+struct I32ValueBuilder;
+
+struct U32Value;
+struct U32ValueBuilder;
+
+struct I64Value;
+struct I64ValueBuilder;
+
+struct U64Value;
+struct U64ValueBuilder;
+
+struct StringValue;
+struct StringValueBuilder;
+
+struct BlobValue;
+struct BlobValueBuilder;
+
+struct ConfigMessage;
+struct ConfigMessageBuilder;
+
+enum EntryType : int8_t {
+  EntryType_NONE = 0,
+  EntryType_I32 = 1,
+  EntryType_U32 = 2,
+  EntryType_I64 = 3,
+  EntryType_U64 = 4,
+  EntryType_STRING = 5,
+  EntryType_BLOB = 6,
+  EntryType_MIN = EntryType_NONE,
+  EntryType_MAX = EntryType_BLOB
+};
+
+inline const EntryType (&EnumValuesEntryType())[7] {
+  static const EntryType values[] = {
+    EntryType_NONE,
+    EntryType_I32,
+    EntryType_U32,
+    EntryType_I64,
+    EntryType_U64,
+    EntryType_STRING,
+    EntryType_BLOB
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesEntryType() {
+  static const char * const names[8] = {
+    "NONE",
+    "I32",
+    "U32",
+    "I64",
+    "U64",
+    "STRING",
+    "BLOB",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameEntryType(EntryType e) {
+  if (::flatbuffers::IsOutRange(e, EntryType_NONE, EntryType_BLOB)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesEntryType()[index];
+}
+
+enum NvsValue : uint8_t {
+  NvsValue_NONE = 0,
+  NvsValue_I32Value = 1,
+  NvsValue_U32Value = 2,
+  NvsValue_I64Value = 3,
+  NvsValue_U64Value = 4,
+  NvsValue_StringValue = 5,
+  NvsValue_BlobValue = 6,
+  NvsValue_MIN = NvsValue_NONE,
+  NvsValue_MAX = NvsValue_BlobValue
+};
+
+inline const NvsValue (&EnumValuesNvsValue())[7] {
+  static const NvsValue values[] = {
+    NvsValue_NONE,
+    NvsValue_I32Value,
+    NvsValue_U32Value,
+    NvsValue_I64Value,
+    NvsValue_U64Value,
+    NvsValue_StringValue,
+    NvsValue_BlobValue
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesNvsValue() {
+  static const char * const names[8] = {
+    "NONE",
+    "I32Value",
+    "U32Value",
+    "I64Value",
+    "U64Value",
+    "StringValue",
+    "BlobValue",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameNvsValue(NvsValue e) {
+  if (::flatbuffers::IsOutRange(e, NvsValue_NONE, NvsValue_BlobValue)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesNvsValue()[index];
+}
+
+template<typename T> struct NvsValueTraits {
+  static const NvsValue enum_value = NvsValue_NONE;
+};
+
+template<> struct NvsValueTraits<Messaging::I32Value> {
+  static const NvsValue enum_value = NvsValue_I32Value;
+};
+
+template<> struct NvsValueTraits<Messaging::U32Value> {
+  static const NvsValue enum_value = NvsValue_U32Value;
+};
+
+template<> struct NvsValueTraits<Messaging::I64Value> {
+  static const NvsValue enum_value = NvsValue_I64Value;
+};
+
+template<> struct NvsValueTraits<Messaging::U64Value> {
+  static const NvsValue enum_value = NvsValue_U64Value;
+};
+
+template<> struct NvsValueTraits<Messaging::StringValue> {
+  static const NvsValue enum_value = NvsValue_StringValue;
+};
+
+template<> struct NvsValueTraits<Messaging::BlobValue> {
+  static const NvsValue enum_value = NvsValue_BlobValue;
+};
+
+bool VerifyNvsValue(::flatbuffers::Verifier &verifier, const void *obj, NvsValue type);
+bool VerifyNvsValueVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+
+struct I32Value FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef I32ValueBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_VALUE = 4
+  };
+  int32_t value() const {
+    return GetField<int32_t>(VT_VALUE, 0);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int32_t>(verifier, VT_VALUE, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct I32ValueBuilder {
+  typedef I32Value Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_value(int32_t value) {
+    fbb_.AddElement<int32_t>(I32Value::VT_VALUE, value, 0);
+  }
+  explicit I32ValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<I32Value> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<I32Value>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<I32Value> CreateI32Value(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    int32_t value = 0) {
+  I32ValueBuilder builder_(_fbb);
+  builder_.add_value(value);
+  return builder_.Finish();
+}
+
+struct U32Value FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef U32ValueBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_VALUE = 4
+  };
+  uint32_t value() const {
+    return GetField<uint32_t>(VT_VALUE, 0);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint32_t>(verifier, VT_VALUE, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct U32ValueBuilder {
+  typedef U32Value Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_value(uint32_t value) {
+    fbb_.AddElement<uint32_t>(U32Value::VT_VALUE, value, 0);
+  }
+  explicit U32ValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<U32Value> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<U32Value>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<U32Value> CreateU32Value(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t value = 0) {
+  U32ValueBuilder builder_(_fbb);
+  builder_.add_value(value);
+  return builder_.Finish();
+}
+
+struct I64Value FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef I64ValueBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_VALUE = 4
+  };
+  int64_t value() const {
+    return GetField<int64_t>(VT_VALUE, 0);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int64_t>(verifier, VT_VALUE, 8) &&
+           verifier.EndTable();
+  }
+};
+
+struct I64ValueBuilder {
+  typedef I64Value Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_value(int64_t value) {
+    fbb_.AddElement<int64_t>(I64Value::VT_VALUE, value, 0);
+  }
+  explicit I64ValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<I64Value> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<I64Value>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<I64Value> CreateI64Value(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    int64_t value = 0) {
+  I64ValueBuilder builder_(_fbb);
+  builder_.add_value(value);
+  return builder_.Finish();
+}
+
+struct U64Value FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef U64ValueBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_VALUE = 4
+  };
+  uint64_t value() const {
+    return GetField<uint64_t>(VT_VALUE, 0);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint64_t>(verifier, VT_VALUE, 8) &&
+           verifier.EndTable();
+  }
+};
+
+struct U64ValueBuilder {
+  typedef U64Value Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_value(uint64_t value) {
+    fbb_.AddElement<uint64_t>(U64Value::VT_VALUE, value, 0);
+  }
+  explicit U64ValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<U64Value> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<U64Value>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<U64Value> CreateU64Value(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint64_t value = 0) {
+  U64ValueBuilder builder_(_fbb);
+  builder_.add_value(value);
+  return builder_.Finish();
+}
+
+struct StringValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef StringValueBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_VALUE = 4
+  };
+  const ::flatbuffers::String *value() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_VALUE);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_VALUE) &&
+           verifier.VerifyString(value()) &&
+           verifier.EndTable();
+  }
+};
+
+struct StringValueBuilder {
+  typedef StringValue Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_value(::flatbuffers::Offset<::flatbuffers::String> value) {
+    fbb_.AddOffset(StringValue::VT_VALUE, value);
+  }
+  explicit StringValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<StringValue> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<StringValue>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<StringValue> CreateStringValue(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> value = 0) {
+  StringValueBuilder builder_(_fbb);
+  builder_.add_value(value);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<StringValue> CreateStringValueDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const char *value = nullptr) {
+  auto value__ = value ? _fbb.CreateString(value) : 0;
+  return Messaging::CreateStringValue(
+      _fbb,
+      value__);
+}
+
+struct BlobValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef BlobValueBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_VALUE = 4
+  };
+  const ::flatbuffers::Vector<uint8_t> *value() const {
+    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_VALUE);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_VALUE) &&
+           verifier.VerifyVector(value()) &&
+           verifier.EndTable();
+  }
+};
+
+struct BlobValueBuilder {
+  typedef BlobValue Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_value(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> value) {
+    fbb_.AddOffset(BlobValue::VT_VALUE, value);
+  }
+  explicit BlobValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<BlobValue> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<BlobValue>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<BlobValue> CreateBlobValue(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> value = 0) {
+  BlobValueBuilder builder_(_fbb);
+  builder_.add_value(value);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<BlobValue> CreateBlobValueDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<uint8_t> *value = nullptr) {
+  auto value__ = value ? _fbb.CreateVector<uint8_t>(*value) : 0;
+  return Messaging::CreateBlobValue(
+      _fbb,
+      value__);
+}
+
+struct ConfigMessage FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef ConfigMessageBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_KEY = 4,
+    VT_TYPE = 6,
+    VT_VALUE_TYPE = 8,
+    VT_VALUE = 10
+  };
+  const ::flatbuffers::String *key() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_KEY);
+  }
+  Messaging::EntryType type() const {
+    return static_cast<Messaging::EntryType>(GetField<int8_t>(VT_TYPE, 0));
+  }
+  Messaging::NvsValue value_type() const {
+    return static_cast<Messaging::NvsValue>(GetField<uint8_t>(VT_VALUE_TYPE, 0));
+  }
+  const void *value() const {
+    return GetPointer<const void *>(VT_VALUE);
+  }
+  template<typename T> const T *value_as() const;
+  const Messaging::I32Value *value_as_I32Value() const {
+    return value_type() == Messaging::NvsValue_I32Value ? static_cast<const Messaging::I32Value *>(value()) : nullptr;
+  }
+  const Messaging::U32Value *value_as_U32Value() const {
+    return value_type() == Messaging::NvsValue_U32Value ? static_cast<const Messaging::U32Value *>(value()) : nullptr;
+  }
+  const Messaging::I64Value *value_as_I64Value() const {
+    return value_type() == Messaging::NvsValue_I64Value ? static_cast<const Messaging::I64Value *>(value()) : nullptr;
+  }
+  const Messaging::U64Value *value_as_U64Value() const {
+    return value_type() == Messaging::NvsValue_U64Value ? static_cast<const Messaging::U64Value *>(value()) : nullptr;
+  }
+  const Messaging::StringValue *value_as_StringValue() const {
+    return value_type() == Messaging::NvsValue_StringValue ? static_cast<const Messaging::StringValue *>(value()) : nullptr;
+  }
+  const Messaging::BlobValue *value_as_BlobValue() const {
+    return value_type() == Messaging::NvsValue_BlobValue ? static_cast<const Messaging::BlobValue *>(value()) : nullptr;
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_KEY) &&
+           verifier.VerifyString(key()) &&
+           VerifyField<int8_t>(verifier, VT_TYPE, 1) &&
+           VerifyField<uint8_t>(verifier, VT_VALUE_TYPE, 1) &&
+           VerifyOffset(verifier, VT_VALUE) &&
+           VerifyNvsValue(verifier, value(), value_type()) &&
+           verifier.EndTable();
+  }
+};
+
+template<> inline const Messaging::I32Value *ConfigMessage::value_as<Messaging::I32Value>() const {
+  return value_as_I32Value();
+}
+
+template<> inline const Messaging::U32Value *ConfigMessage::value_as<Messaging::U32Value>() const {
+  return value_as_U32Value();
+}
+
+template<> inline const Messaging::I64Value *ConfigMessage::value_as<Messaging::I64Value>() const {
+  return value_as_I64Value();
+}
+
+template<> inline const Messaging::U64Value *ConfigMessage::value_as<Messaging::U64Value>() const {
+  return value_as_U64Value();
+}
+
+template<> inline const Messaging::StringValue *ConfigMessage::value_as<Messaging::StringValue>() const {
+  return value_as_StringValue();
+}
+
+template<> inline const Messaging::BlobValue *ConfigMessage::value_as<Messaging::BlobValue>() const {
+  return value_as_BlobValue();
+}
+
+struct ConfigMessageBuilder {
+  typedef ConfigMessage Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_key(::flatbuffers::Offset<::flatbuffers::String> key) {
+    fbb_.AddOffset(ConfigMessage::VT_KEY, key);
+  }
+  void add_type(Messaging::EntryType type) {
+    fbb_.AddElement<int8_t>(ConfigMessage::VT_TYPE, static_cast<int8_t>(type), 0);
+  }
+  void add_value_type(Messaging::NvsValue value_type) {
+    fbb_.AddElement<uint8_t>(ConfigMessage::VT_VALUE_TYPE, static_cast<uint8_t>(value_type), 0);
+  }
+  void add_value(::flatbuffers::Offset<void> value) {
+    fbb_.AddOffset(ConfigMessage::VT_VALUE, value);
+  }
+  explicit ConfigMessageBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<ConfigMessage> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<ConfigMessage>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<ConfigMessage> CreateConfigMessage(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> key = 0,
+    Messaging::EntryType type = Messaging::EntryType_NONE,
+    Messaging::NvsValue value_type = Messaging::NvsValue_NONE,
+    ::flatbuffers::Offset<void> value = 0) {
+  ConfigMessageBuilder builder_(_fbb);
+  builder_.add_value(value);
+  builder_.add_key(key);
+  builder_.add_value_type(value_type);
+  builder_.add_type(type);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<ConfigMessage> CreateConfigMessageDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const char *key = nullptr,
+    Messaging::EntryType type = Messaging::EntryType_NONE,
+    Messaging::NvsValue value_type = Messaging::NvsValue_NONE,
+    ::flatbuffers::Offset<void> value = 0) {
+  auto key__ = key ? _fbb.CreateString(key) : 0;
+  return Messaging::CreateConfigMessage(
+      _fbb,
+      key__,
+      type,
+      value_type,
+      value);
+}
+
+inline bool VerifyNvsValue(::flatbuffers::Verifier &verifier, const void *obj, NvsValue type) {
+  switch (type) {
+    case NvsValue_NONE: {
+      return true;
+    }
+    case NvsValue_I32Value: {
+      auto ptr = reinterpret_cast<const Messaging::I32Value *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case NvsValue_U32Value: {
+      auto ptr = reinterpret_cast<const Messaging::U32Value *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case NvsValue_I64Value: {
+      auto ptr = reinterpret_cast<const Messaging::I64Value *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case NvsValue_U64Value: {
+      auto ptr = reinterpret_cast<const Messaging::U64Value *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case NvsValue_StringValue: {
+      auto ptr = reinterpret_cast<const Messaging::StringValue *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case NvsValue_BlobValue: {
+      auto ptr = reinterpret_cast<const Messaging::BlobValue *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    default: return true;
+  }
+}
+
+inline bool VerifyNvsValueVector(::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 (!VerifyNvsValue(
+        verifier,  values->Get(i), types->GetEnum<NvsValue>(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+inline const Messaging::ConfigMessage *GetConfigMessage(const void *buf) {
+  return ::flatbuffers::GetRoot<Messaging::ConfigMessage>(buf);
+}
+
+inline const Messaging::ConfigMessage *GetSizePrefixedConfigMessage(const void *buf) {
+  return ::flatbuffers::GetSizePrefixedRoot<Messaging::ConfigMessage>(buf);
+}
+
+inline bool VerifyConfigMessageBuffer(
+    ::flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<Messaging::ConfigMessage>(nullptr);
+}
+
+inline bool VerifySizePrefixedConfigMessageBuffer(
+    ::flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<Messaging::ConfigMessage>(nullptr);
+}
+
+inline void FinishConfigMessageBuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<Messaging::ConfigMessage> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedConfigMessageBuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<Messaging::ConfigMessage> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+}  // namespace Messaging
+
+#endif  // FLATBUFFERS_GENERATED_CONFIGMESSAGE_MESSAGING_H_