MobileGL/MobileGL/MG_Remote/Protocol/generated/protocol_generated.h

// MobileGL - MobileGL/MG_Remote/Protocol/generated/protocol_generated.h
// Copyright (c) 2025-2026 MobileGL-Dev
// Licensed under the GNU Lesser General Public License v3.0:
//   https://www.gnu.org/licenses/gpl-3.0.txt
//   https://www.gnu.org/licenses/lgpl-3.0.txt
// SPDX-License-Identifier: LGPL-3.0-only
// End of Source File Header

// GENERATED FILE - DO NOT EDIT.
// Regenerate with `python3 scripts/gen_protocol.py` after changing
// MobileGL/MG_Remote/Protocol/protocol.fbs. CI's flatc-check step regenerates
// this file and fails on `git diff --exit-code`.

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


#ifndef FLATBUFFERS_GENERATED_PROTOCOL_MOBILEGL_WIRE_H_
#define FLATBUFFERS_GENERATED_PROTOCOL_MOBILEGL_WIRE_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 == 12 &&
              FLATBUFFERS_VERSION_REVISION == 19,
             "Non-compatible flatbuffers version included");

namespace MobileGL {
namespace Wire {

struct SegmentRef;
struct SegmentRefBuilder;

struct LinkTerms;
struct LinkTermsBuilder;

struct Refuse;
struct RefuseBuilder;

struct LogFlush;
struct LogFlushBuilder;

struct Hello;
struct HelloBuilder;

struct Welcome;
struct WelcomeBuilder;

struct DataBind;
struct DataBindBuilder;

struct PairBind;
struct PairBindBuilder;

struct CapsSnapshot;
struct CapsSnapshotBuilder;

struct DefaultFramebufferInfo;
struct DefaultFramebufferInfoBuilder;

struct SurfaceOp;
struct SurfaceOpBuilder;

struct SurfaceReply;
struct SurfaceReplyBuilder;

struct ResyncRequest;
struct ResyncRequestBuilder;

struct ResyncDone;
struct ResyncDoneBuilder;

struct AuxRequest;
struct AuxRequestBuilder;

struct Fatal;
struct FatalBuilder;

struct LogLine;
struct LogLineBuilder;

struct SurfaceProgress;
struct SurfaceProgressBuilder;

struct CtrlEnvelope;
struct CtrlEnvelopeBuilder;

enum class SegmentKind : uint8_t {
  None = 0,
  Cmd = 1,
  Stage = 2,
  Reply = 3,
  Event = 4,
  Shadow = 5,
  Adopt = 6,
  MIN = None,
  MAX = Adopt
};

inline const SegmentKind (&EnumValuesSegmentKind())[7] {
  static const SegmentKind values[] = {
    SegmentKind::None,
    SegmentKind::Cmd,
    SegmentKind::Stage,
    SegmentKind::Reply,
    SegmentKind::Event,
    SegmentKind::Shadow,
    SegmentKind::Adopt
  };
  return values;
}

inline const char * const *EnumNamesSegmentKind() {
  static const char * const names[8] = {
    "None",
    "Cmd",
    "Stage",
    "Reply",
    "Event",
    "Shadow",
    "Adopt",
    nullptr
  };
  return names;
}

inline const char *EnumNameSegmentKind(SegmentKind e) {
  if (::flatbuffers::IsOutRange(e, SegmentKind::None, SegmentKind::Adopt)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesSegmentKind()[index];
}

enum class DataPlane : uint8_t {
  SharedSegments = 0,
  Stream = 1,
  MIN = SharedSegments,
  MAX = Stream
};

inline const DataPlane (&EnumValuesDataPlane())[2] {
  static const DataPlane values[] = {
    DataPlane::SharedSegments,
    DataPlane::Stream
  };
  return values;
}

inline const char * const *EnumNamesDataPlane() {
  static const char * const names[3] = {
    "SharedSegments",
    "Stream",
    nullptr
  };
  return names;
}

inline const char *EnumNameDataPlane(DataPlane e) {
  if (::flatbuffers::IsOutRange(e, DataPlane::SharedSegments, DataPlane::Stream)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesDataPlane()[index];
}

enum class WireForm : uint8_t {
  StructImage = 0,
  MIN = StructImage,
  MAX = StructImage
};

inline const WireForm (&EnumValuesWireForm())[1] {
  static const WireForm values[] = {
    WireForm::StructImage
  };
  return values;
}

inline const char * const *EnumNamesWireForm() {
  static const char * const names[2] = {
    "StructImage",
    nullptr
  };
  return names;
}

inline const char *EnumNameWireForm(WireForm e) {
  if (::flatbuffers::IsOutRange(e, WireForm::StructImage, WireForm::StructImage)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesWireForm()[index];
}

enum class DialMode : uint8_t {
  No = 0,
  Fork = 1,
  Connect = 2,
  MIN = No,
  MAX = Connect
};

inline const DialMode (&EnumValuesDialMode())[3] {
  static const DialMode values[] = {
    DialMode::No,
    DialMode::Fork,
    DialMode::Connect
  };
  return values;
}

inline const char * const *EnumNamesDialMode() {
  static const char * const names[4] = {
    "No",
    "Fork",
    "Connect",
    nullptr
  };
  return names;
}

inline const char *EnumNameDialMode(DialMode e) {
  if (::flatbuffers::IsOutRange(e, DialMode::No, DialMode::Connect)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesDialMode()[index];
}

enum class RefuseCode : uint32_t {
  None = 0,
  ProtocolVersion = 1,
  WireFingerprint = 2,
  BuildFingerprint = 3,
  Authentication = 4,
  LinkTerms = 5,
  Backend = 6,
  Busy = 7,
  MalformedHello = 8,
  MIN = None,
  MAX = MalformedHello
};

inline const RefuseCode (&EnumValuesRefuseCode())[9] {
  static const RefuseCode values[] = {
    RefuseCode::None,
    RefuseCode::ProtocolVersion,
    RefuseCode::WireFingerprint,
    RefuseCode::BuildFingerprint,
    RefuseCode::Authentication,
    RefuseCode::LinkTerms,
    RefuseCode::Backend,
    RefuseCode::Busy,
    RefuseCode::MalformedHello
  };
  return values;
}

inline const char * const *EnumNamesRefuseCode() {
  static const char * const names[10] = {
    "None",
    "ProtocolVersion",
    "WireFingerprint",
    "BuildFingerprint",
    "Authentication",
    "LinkTerms",
    "Backend",
    "Busy",
    "MalformedHello",
    nullptr
  };
  return names;
}

inline const char *EnumNameRefuseCode(RefuseCode e) {
  if (::flatbuffers::IsOutRange(e, RefuseCode::None, RefuseCode::MalformedHello)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesRefuseCode()[index];
}

enum class SurfaceOpKind : uint8_t {
  None = 0,
  InitializeDisplay = 1,
  CreateWindowSurface = 2,
  CreatePbufferSurface = 3,
  ResizeWindowSurface = 4,
  ReleaseSurface = 5,
  MakeCurrent = 6,
  ReleaseCurrent = 7,
  SetSwapInterval = 8,
  ReleaseResources = 9,
  SetWindowHandle = 10,
  InitCapabilities = 11,
  MIN = None,
  MAX = InitCapabilities
};

inline const SurfaceOpKind (&EnumValuesSurfaceOpKind())[12] {
  static const SurfaceOpKind values[] = {
    SurfaceOpKind::None,
    SurfaceOpKind::InitializeDisplay,
    SurfaceOpKind::CreateWindowSurface,
    SurfaceOpKind::CreatePbufferSurface,
    SurfaceOpKind::ResizeWindowSurface,
    SurfaceOpKind::ReleaseSurface,
    SurfaceOpKind::MakeCurrent,
    SurfaceOpKind::ReleaseCurrent,
    SurfaceOpKind::SetSwapInterval,
    SurfaceOpKind::ReleaseResources,
    SurfaceOpKind::SetWindowHandle,
    SurfaceOpKind::InitCapabilities
  };
  return values;
}

inline const char * const *EnumNamesSurfaceOpKind() {
  static const char * const names[13] = {
    "None",
    "InitializeDisplay",
    "CreateWindowSurface",
    "CreatePbufferSurface",
    "ResizeWindowSurface",
    "ReleaseSurface",
    "MakeCurrent",
    "ReleaseCurrent",
    "SetSwapInterval",
    "ReleaseResources",
    "SetWindowHandle",
    "InitCapabilities",
    nullptr
  };
  return names;
}

inline const char *EnumNameSurfaceOpKind(SurfaceOpKind e) {
  if (::flatbuffers::IsOutRange(e, SurfaceOpKind::None, SurfaceOpKind::InitCapabilities)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesSurfaceOpKind()[index];
}

enum class WindowKind : uint8_t {
  None = 0,
  AndroidNativeWindow = 1,
  X11 = 2,
  Win32Hwnd = 3,
  Surfaceless = 4,
  Pbuffer = 5,
  MetalLayer = 6,
  ServerOwned = 7,
  HostFrame = 8,
  MIN = None,
  MAX = HostFrame
};

inline const WindowKind (&EnumValuesWindowKind())[9] {
  static const WindowKind values[] = {
    WindowKind::None,
    WindowKind::AndroidNativeWindow,
    WindowKind::X11,
    WindowKind::Win32Hwnd,
    WindowKind::Surfaceless,
    WindowKind::Pbuffer,
    WindowKind::MetalLayer,
    WindowKind::ServerOwned,
    WindowKind::HostFrame
  };
  return values;
}

inline const char * const *EnumNamesWindowKind() {
  static const char * const names[10] = {
    "None",
    "AndroidNativeWindow",
    "X11",
    "Win32Hwnd",
    "Surfaceless",
    "Pbuffer",
    "MetalLayer",
    "ServerOwned",
    "HostFrame",
    nullptr
  };
  return names;
}

inline const char *EnumNameWindowKind(WindowKind e) {
  if (::flatbuffers::IsOutRange(e, WindowKind::None, WindowKind::HostFrame)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesWindowKind()[index];
}

enum class SurfaceRefusal : uint8_t {
  None = 0,
  NoServerDisplay = 1,
  NoServerWindow = 2,
  SurfaceModeMismatch = 3,
  ServerOwnedOnSetWindowHandle = 4,
  HostFrameOnSetWindowHandle = 5,
  MIN = None,
  MAX = HostFrameOnSetWindowHandle
};

inline const SurfaceRefusal (&EnumValuesSurfaceRefusal())[6] {
  static const SurfaceRefusal values[] = {
    SurfaceRefusal::None,
    SurfaceRefusal::NoServerDisplay,
    SurfaceRefusal::NoServerWindow,
    SurfaceRefusal::SurfaceModeMismatch,
    SurfaceRefusal::ServerOwnedOnSetWindowHandle,
    SurfaceRefusal::HostFrameOnSetWindowHandle
  };
  return values;
}

inline const char * const *EnumNamesSurfaceRefusal() {
  static const char * const names[7] = {
    "None",
    "NoServerDisplay",
    "NoServerWindow",
    "SurfaceModeMismatch",
    "ServerOwnedOnSetWindowHandle",
    "HostFrameOnSetWindowHandle",
    nullptr
  };
  return names;
}

inline const char *EnumNameSurfaceRefusal(SurfaceRefusal e) {
  if (::flatbuffers::IsOutRange(e, SurfaceRefusal::None, SurfaceRefusal::HostFrameOnSetWindowHandle)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesSurfaceRefusal()[index];
}

enum class AuxRequestKind : uint8_t {
  None = 0,
  FenceClientWait = 1,
  QueryResult = 2,
  ScalarGet = 3,
  MIN = None,
  MAX = ScalarGet
};

inline const AuxRequestKind (&EnumValuesAuxRequestKind())[4] {
  static const AuxRequestKind values[] = {
    AuxRequestKind::None,
    AuxRequestKind::FenceClientWait,
    AuxRequestKind::QueryResult,
    AuxRequestKind::ScalarGet
  };
  return values;
}

inline const char * const *EnumNamesAuxRequestKind() {
  static const char * const names[5] = {
    "None",
    "FenceClientWait",
    "QueryResult",
    "ScalarGet",
    nullptr
  };
  return names;
}

inline const char *EnumNameAuxRequestKind(AuxRequestKind e) {
  if (::flatbuffers::IsOutRange(e, AuxRequestKind::None, AuxRequestKind::ScalarGet)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesAuxRequestKind()[index];
}

enum class FatalCode : uint32_t {
  None = 0,
  ProtocolCorruption = 1,
  RingOverrun = 2,
  SegmentMismatch = 3,
  DeviceLost = 4,
  ServerCrashed = 5,
  AbiMismatch = 6,
  MIN = None,
  MAX = AbiMismatch
};

inline const FatalCode (&EnumValuesFatalCode())[7] {
  static const FatalCode values[] = {
    FatalCode::None,
    FatalCode::ProtocolCorruption,
    FatalCode::RingOverrun,
    FatalCode::SegmentMismatch,
    FatalCode::DeviceLost,
    FatalCode::ServerCrashed,
    FatalCode::AbiMismatch
  };
  return values;
}

inline const char * const *EnumNamesFatalCode() {
  static const char * const names[8] = {
    "None",
    "ProtocolCorruption",
    "RingOverrun",
    "SegmentMismatch",
    "DeviceLost",
    "ServerCrashed",
    "AbiMismatch",
    nullptr
  };
  return names;
}

inline const char *EnumNameFatalCode(FatalCode e) {
  if (::flatbuffers::IsOutRange(e, FatalCode::None, FatalCode::AbiMismatch)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesFatalCode()[index];
}

enum class LogLevel : uint8_t {
  Debug = 0,
  Info = 1,
  Warn = 2,
  Error = 3,
  Fatal = 4,
  MIN = Debug,
  MAX = Fatal
};

inline const LogLevel (&EnumValuesLogLevel())[5] {
  static const LogLevel values[] = {
    LogLevel::Debug,
    LogLevel::Info,
    LogLevel::Warn,
    LogLevel::Error,
    LogLevel::Fatal
  };
  return values;
}

inline const char * const *EnumNamesLogLevel() {
  static const char * const names[6] = {
    "Debug",
    "Info",
    "Warn",
    "Error",
    "Fatal",
    nullptr
  };
  return names;
}

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

enum class CtrlMsg : uint8_t {
  NONE = 0,
  Hello = 1,
  Welcome = 2,
  CapsSnapshot = 3,
  SurfaceOp = 4,
  SurfaceReply = 5,
  ResyncRequest = 6,
  ResyncDone = 7,
  AuxRequest = 8,
  Fatal = 9,
  LogLine = 10,
  Refuse = 11,
  LogFlush = 12,
  DataBind = 13,
  SurfaceProgress = 14,
  PairBind = 15,
  MIN = NONE,
  MAX = PairBind
};

inline const CtrlMsg (&EnumValuesCtrlMsg())[16] {
  static const CtrlMsg values[] = {
    CtrlMsg::NONE,
    CtrlMsg::Hello,
    CtrlMsg::Welcome,
    CtrlMsg::CapsSnapshot,
    CtrlMsg::SurfaceOp,
    CtrlMsg::SurfaceReply,
    CtrlMsg::ResyncRequest,
    CtrlMsg::ResyncDone,
    CtrlMsg::AuxRequest,
    CtrlMsg::Fatal,
    CtrlMsg::LogLine,
    CtrlMsg::Refuse,
    CtrlMsg::LogFlush,
    CtrlMsg::DataBind,
    CtrlMsg::SurfaceProgress,
    CtrlMsg::PairBind
  };
  return values;
}

inline const char * const *EnumNamesCtrlMsg() {
  static const char * const names[17] = {
    "NONE",
    "Hello",
    "Welcome",
    "CapsSnapshot",
    "SurfaceOp",
    "SurfaceReply",
    "ResyncRequest",
    "ResyncDone",
    "AuxRequest",
    "Fatal",
    "LogLine",
    "Refuse",
    "LogFlush",
    "DataBind",
    "SurfaceProgress",
    "PairBind",
    nullptr
  };
  return names;
}

inline const char *EnumNameCtrlMsg(CtrlMsg e) {
  if (::flatbuffers::IsOutRange(e, CtrlMsg::NONE, CtrlMsg::PairBind)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesCtrlMsg()[index];
}

template<typename T> struct CtrlMsgTraits {
  static const CtrlMsg enum_value = CtrlMsg::NONE;
};

template<> struct CtrlMsgTraits<MobileGL::Wire::Hello> {
  static const CtrlMsg enum_value = CtrlMsg::Hello;
};

template<> struct CtrlMsgTraits<MobileGL::Wire::Welcome> {
  static const CtrlMsg enum_value = CtrlMsg::Welcome;
};

template<> struct CtrlMsgTraits<MobileGL::Wire::CapsSnapshot> {
  static const CtrlMsg enum_value = CtrlMsg::CapsSnapshot;
};

template<> struct CtrlMsgTraits<MobileGL::Wire::SurfaceOp> {
  static const CtrlMsg enum_value = CtrlMsg::SurfaceOp;
};

template<> struct CtrlMsgTraits<MobileGL::Wire::SurfaceReply> {
  static const CtrlMsg enum_value = CtrlMsg::SurfaceReply;
};

template<> struct CtrlMsgTraits<MobileGL::Wire::ResyncRequest> {
  static const CtrlMsg enum_value = CtrlMsg::ResyncRequest;
};

template<> struct CtrlMsgTraits<MobileGL::Wire::ResyncDone> {
  static const CtrlMsg enum_value = CtrlMsg::ResyncDone;
};

template<> struct CtrlMsgTraits<MobileGL::Wire::AuxRequest> {
  static const CtrlMsg enum_value = CtrlMsg::AuxRequest;
};

template<> struct CtrlMsgTraits<MobileGL::Wire::Fatal> {
  static const CtrlMsg enum_value = CtrlMsg::Fatal;
};

template<> struct CtrlMsgTraits<MobileGL::Wire::LogLine> {
  static const CtrlMsg enum_value = CtrlMsg::LogLine;
};

template<> struct CtrlMsgTraits<MobileGL::Wire::Refuse> {
  static const CtrlMsg enum_value = CtrlMsg::Refuse;
};

template<> struct CtrlMsgTraits<MobileGL::Wire::LogFlush> {
  static const CtrlMsg enum_value = CtrlMsg::LogFlush;
};

template<> struct CtrlMsgTraits<MobileGL::Wire::DataBind> {
  static const CtrlMsg enum_value = CtrlMsg::DataBind;
};

template<> struct CtrlMsgTraits<MobileGL::Wire::SurfaceProgress> {
  static const CtrlMsg enum_value = CtrlMsg::SurfaceProgress;
};

template<> struct CtrlMsgTraits<MobileGL::Wire::PairBind> {
  static const CtrlMsg enum_value = CtrlMsg::PairBind;
};

template <bool B = false>
bool VerifyCtrlMsg(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, CtrlMsg type);
template <bool B = false>
bool VerifyCtrlMsgVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<CtrlMsg> *types);

struct SegmentRef FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SegmentRefBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_KIND = 6,
    VT_SIZEBYTES = 8,
    VT_NAME = 10
  };
  uint32_t id() const {
    return GetField<uint32_t>(VT_ID, 0);
  }
  MobileGL::Wire::SegmentKind kind() const {
    return static_cast<MobileGL::Wire::SegmentKind>(GetField<uint8_t>(VT_KIND, 0));
  }
  uint64_t sizeBytes() const {
    return GetField<uint64_t>(VT_SIZEBYTES, 0);
  }
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_ID, 4) &&
           VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
           VerifyField<uint64_t>(verifier, VT_SIZEBYTES, 8) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           verifier.EndTable();
  }
};

struct SegmentRefBuilder {
  typedef SegmentRef Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_id(uint32_t id) {
    fbb_.AddElement<uint32_t>(SegmentRef::VT_ID, id, 0);
  }
  void add_kind(MobileGL::Wire::SegmentKind kind) {
    fbb_.AddElement<uint8_t>(SegmentRef::VT_KIND, static_cast<uint8_t>(kind), 0);
  }
  void add_sizeBytes(uint64_t sizeBytes) {
    fbb_.AddElement<uint64_t>(SegmentRef::VT_SIZEBYTES, sizeBytes, 0);
  }
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(SegmentRef::VT_NAME, name);
  }
  explicit SegmentRefBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SegmentRef> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SegmentRef>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SegmentRef> CreateSegmentRef(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t id = 0,
    MobileGL::Wire::SegmentKind kind = MobileGL::Wire::SegmentKind::None,
    uint64_t sizeBytes = 0,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0) {
  SegmentRefBuilder builder_(_fbb);
  builder_.add_sizeBytes(sizeBytes);
  builder_.add_name(name);
  builder_.add_id(id);
  builder_.add_kind(kind);
  return builder_.Finish();
}

struct SegmentRef::Traits {
  using type = SegmentRef;
  static auto constexpr Create = CreateSegmentRef;
};

inline ::flatbuffers::Offset<SegmentRef> CreateSegmentRefDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t id = 0,
    MobileGL::Wire::SegmentKind kind = MobileGL::Wire::SegmentKind::None,
    uint64_t sizeBytes = 0,
    const char *name = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return MobileGL::Wire::CreateSegmentRef(
      _fbb,
      id,
      kind,
      sizeBytes,
      name__);
}

struct LinkTerms FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LinkTermsBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATAPLANE = 4,
    VT_WIREFORM = 6,
    VT_MAXREPLYBYTES = 8,
    VT_CMDWINDOWBYTES = 10,
    VT_STAGEWINDOWBYTES = 12,
    VT_EVENTWINDOWBYTES = 14,
    VT_ADOPTTIER = 16
  };
  MobileGL::Wire::DataPlane dataPlane() const {
    return static_cast<MobileGL::Wire::DataPlane>(GetField<uint8_t>(VT_DATAPLANE, 0));
  }
  MobileGL::Wire::WireForm wireForm() const {
    return static_cast<MobileGL::Wire::WireForm>(GetField<uint8_t>(VT_WIREFORM, 0));
  }
  uint64_t maxReplyBytes() const {
    return GetField<uint64_t>(VT_MAXREPLYBYTES, 0);
  }
  uint64_t cmdWindowBytes() const {
    return GetField<uint64_t>(VT_CMDWINDOWBYTES, 0);
  }
  uint64_t stageWindowBytes() const {
    return GetField<uint64_t>(VT_STAGEWINDOWBYTES, 0);
  }
  uint64_t eventWindowBytes() const {
    return GetField<uint64_t>(VT_EVENTWINDOWBYTES, 0);
  }
  uint8_t adoptTier() const {
    return GetField<uint8_t>(VT_ADOPTTIER, 2);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_DATAPLANE, 1) &&
           VerifyField<uint8_t>(verifier, VT_WIREFORM, 1) &&
           VerifyField<uint64_t>(verifier, VT_MAXREPLYBYTES, 8) &&
           VerifyField<uint64_t>(verifier, VT_CMDWINDOWBYTES, 8) &&
           VerifyField<uint64_t>(verifier, VT_STAGEWINDOWBYTES, 8) &&
           VerifyField<uint64_t>(verifier, VT_EVENTWINDOWBYTES, 8) &&
           VerifyField<uint8_t>(verifier, VT_ADOPTTIER, 1) &&
           verifier.EndTable();
  }
};

struct LinkTermsBuilder {
  typedef LinkTerms Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_dataPlane(MobileGL::Wire::DataPlane dataPlane) {
    fbb_.AddElement<uint8_t>(LinkTerms::VT_DATAPLANE, static_cast<uint8_t>(dataPlane), 0);
  }
  void add_wireForm(MobileGL::Wire::WireForm wireForm) {
    fbb_.AddElement<uint8_t>(LinkTerms::VT_WIREFORM, static_cast<uint8_t>(wireForm), 0);
  }
  void add_maxReplyBytes(uint64_t maxReplyBytes) {
    fbb_.AddElement<uint64_t>(LinkTerms::VT_MAXREPLYBYTES, maxReplyBytes, 0);
  }
  void add_cmdWindowBytes(uint64_t cmdWindowBytes) {
    fbb_.AddElement<uint64_t>(LinkTerms::VT_CMDWINDOWBYTES, cmdWindowBytes, 0);
  }
  void add_stageWindowBytes(uint64_t stageWindowBytes) {
    fbb_.AddElement<uint64_t>(LinkTerms::VT_STAGEWINDOWBYTES, stageWindowBytes, 0);
  }
  void add_eventWindowBytes(uint64_t eventWindowBytes) {
    fbb_.AddElement<uint64_t>(LinkTerms::VT_EVENTWINDOWBYTES, eventWindowBytes, 0);
  }
  void add_adoptTier(uint8_t adoptTier) {
    fbb_.AddElement<uint8_t>(LinkTerms::VT_ADOPTTIER, adoptTier, 2);
  }
  explicit LinkTermsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LinkTerms> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LinkTerms>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<LinkTerms> CreateLinkTerms(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    MobileGL::Wire::DataPlane dataPlane = MobileGL::Wire::DataPlane::SharedSegments,
    MobileGL::Wire::WireForm wireForm = MobileGL::Wire::WireForm::StructImage,
    uint64_t maxReplyBytes = 0,
    uint64_t cmdWindowBytes = 0,
    uint64_t stageWindowBytes = 0,
    uint64_t eventWindowBytes = 0,
    uint8_t adoptTier = 2) {
  LinkTermsBuilder builder_(_fbb);
  builder_.add_eventWindowBytes(eventWindowBytes);
  builder_.add_stageWindowBytes(stageWindowBytes);
  builder_.add_cmdWindowBytes(cmdWindowBytes);
  builder_.add_maxReplyBytes(maxReplyBytes);
  builder_.add_adoptTier(adoptTier);
  builder_.add_wireForm(wireForm);
  builder_.add_dataPlane(dataPlane);
  return builder_.Finish();
}

struct LinkTerms::Traits {
  using type = LinkTerms;
  static auto constexpr Create = CreateLinkTerms;
};

struct Refuse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef RefuseBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CODE = 4,
    VT_DETAIL = 6,
    VT_EXPECTED = 8,
    VT_ACTUAL = 10,
    VT_PEERVALUE = 12
  };
  MobileGL::Wire::RefuseCode code() const {
    return static_cast<MobileGL::Wire::RefuseCode>(GetField<uint32_t>(VT_CODE, 0));
  }
  const ::flatbuffers::String *detail() const {
    return GetPointer<const ::flatbuffers::String *>(VT_DETAIL);
  }
  uint64_t expected() const {
    return GetField<uint64_t>(VT_EXPECTED, 0);
  }
  uint64_t actual() const {
    return GetField<uint64_t>(VT_ACTUAL, 0);
  }
  const ::flatbuffers::String *peerValue() const {
    return GetPointer<const ::flatbuffers::String *>(VT_PEERVALUE);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_CODE, 4) &&
           VerifyOffset(verifier, VT_DETAIL) &&
           verifier.VerifyString(detail()) &&
           VerifyField<uint64_t>(verifier, VT_EXPECTED, 8) &&
           VerifyField<uint64_t>(verifier, VT_ACTUAL, 8) &&
           VerifyOffset(verifier, VT_PEERVALUE) &&
           verifier.VerifyString(peerValue()) &&
           verifier.EndTable();
  }
};

struct RefuseBuilder {
  typedef Refuse Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_code(MobileGL::Wire::RefuseCode code) {
    fbb_.AddElement<uint32_t>(Refuse::VT_CODE, static_cast<uint32_t>(code), 0);
  }
  void add_detail(::flatbuffers::Offset<::flatbuffers::String> detail) {
    fbb_.AddOffset(Refuse::VT_DETAIL, detail);
  }
  void add_expected(uint64_t expected) {
    fbb_.AddElement<uint64_t>(Refuse::VT_EXPECTED, expected, 0);
  }
  void add_actual(uint64_t actual) {
    fbb_.AddElement<uint64_t>(Refuse::VT_ACTUAL, actual, 0);
  }
  void add_peerValue(::flatbuffers::Offset<::flatbuffers::String> peerValue) {
    fbb_.AddOffset(Refuse::VT_PEERVALUE, peerValue);
  }
  explicit RefuseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Refuse> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Refuse>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Refuse> CreateRefuse(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    MobileGL::Wire::RefuseCode code = MobileGL::Wire::RefuseCode::None,
    ::flatbuffers::Offset<::flatbuffers::String> detail = 0,
    uint64_t expected = 0,
    uint64_t actual = 0,
    ::flatbuffers::Offset<::flatbuffers::String> peerValue = 0) {
  RefuseBuilder builder_(_fbb);
  builder_.add_actual(actual);
  builder_.add_expected(expected);
  builder_.add_peerValue(peerValue);
  builder_.add_detail(detail);
  builder_.add_code(code);
  return builder_.Finish();
}

struct Refuse::Traits {
  using type = Refuse;
  static auto constexpr Create = CreateRefuse;
};

inline ::flatbuffers::Offset<Refuse> CreateRefuseDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    MobileGL::Wire::RefuseCode code = MobileGL::Wire::RefuseCode::None,
    const char *detail = nullptr,
    uint64_t expected = 0,
    uint64_t actual = 0,
    const char *peerValue = nullptr) {
  auto detail__ = detail ? _fbb.CreateString(detail) : 0;
  auto peerValue__ = peerValue ? _fbb.CreateString(peerValue) : 0;
  return MobileGL::Wire::CreateRefuse(
      _fbb,
      code,
      detail__,
      expected,
      actual,
      peerValue__);
}

struct LogFlush FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LogFlushBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SEQ = 4,
    VT_ACK = 6
  };
  uint64_t seq() const {
    return GetField<uint64_t>(VT_SEQ, 0);
  }
  bool ack() const {
    return GetField<uint8_t>(VT_ACK, 0) != 0;
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_SEQ, 8) &&
           VerifyField<uint8_t>(verifier, VT_ACK, 1) &&
           verifier.EndTable();
  }
};

struct LogFlushBuilder {
  typedef LogFlush Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_seq(uint64_t seq) {
    fbb_.AddElement<uint64_t>(LogFlush::VT_SEQ, seq, 0);
  }
  void add_ack(bool ack) {
    fbb_.AddElement<uint8_t>(LogFlush::VT_ACK, static_cast<uint8_t>(ack), 0);
  }
  explicit LogFlushBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LogFlush> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LogFlush>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<LogFlush> CreateLogFlush(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t seq = 0,
    bool ack = false) {
  LogFlushBuilder builder_(_fbb);
  builder_.add_seq(seq);
  builder_.add_ack(ack);
  return builder_.Finish();
}

struct LogFlush::Traits {
  using type = LogFlush;
  static auto constexpr Create = CreateLogFlush;
};

struct Hello FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef HelloBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ABIMAJOR = 4,
    VT_ABIMINOR = 6,
    VT_BUILDFINGERPRINT = 8,
    VT_BACKENDTYPE = 10,
    VT_PID = 12,
    VT_CONFIGBLOB = 14,
    VT_ABIFINGERPRINT = 16,
    VT_WIREFINGERPRINT = 18,
    VT_LINKTERMS = 20,
    VT_TOKEN = 22,
    VT_DIALMODE = 24
  };
  uint32_t abiMajor() const {
    return GetField<uint32_t>(VT_ABIMAJOR, 0);
  }
  uint32_t abiMinor() const {
    return GetField<uint32_t>(VT_ABIMINOR, 0);
  }
  const ::flatbuffers::String *buildFingerprint() const {
    return GetPointer<const ::flatbuffers::String *>(VT_BUILDFINGERPRINT);
  }
  uint32_t backendType() const {
    return GetField<uint32_t>(VT_BACKENDTYPE, 0);
  }
  uint32_t pid() const {
    return GetField<uint32_t>(VT_PID, 0);
  }
  const ::flatbuffers::Vector<uint8_t> *configBlob() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_CONFIGBLOB);
  }
  uint64_t abiFingerprint() const {
    return GetField<uint64_t>(VT_ABIFINGERPRINT, 0);
  }
  uint64_t wireFingerprint() const {
    return GetField<uint64_t>(VT_WIREFINGERPRINT, 0);
  }
  const MobileGL::Wire::LinkTerms *linkTerms() const {
    return GetPointer<const MobileGL::Wire::LinkTerms *>(VT_LINKTERMS);
  }
  const ::flatbuffers::String *token() const {
    return GetPointer<const ::flatbuffers::String *>(VT_TOKEN);
  }
  MobileGL::Wire::DialMode dialMode() const {
    return static_cast<MobileGL::Wire::DialMode>(GetField<uint8_t>(VT_DIALMODE, 0));
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_ABIMAJOR, 4) &&
           VerifyField<uint32_t>(verifier, VT_ABIMINOR, 4) &&
           VerifyOffset(verifier, VT_BUILDFINGERPRINT) &&
           verifier.VerifyString(buildFingerprint()) &&
           VerifyField<uint32_t>(verifier, VT_BACKENDTYPE, 4) &&
           VerifyField<uint32_t>(verifier, VT_PID, 4) &&
           VerifyOffset(verifier, VT_CONFIGBLOB) &&
           verifier.VerifyVector(configBlob()) &&
           VerifyField<uint64_t>(verifier, VT_ABIFINGERPRINT, 8) &&
           VerifyField<uint64_t>(verifier, VT_WIREFINGERPRINT, 8) &&
           VerifyOffset(verifier, VT_LINKTERMS) &&
           verifier.VerifyTable(linkTerms()) &&
           VerifyOffset(verifier, VT_TOKEN) &&
           verifier.VerifyString(token()) &&
           VerifyField<uint8_t>(verifier, VT_DIALMODE, 1) &&
           verifier.EndTable();
  }
};

struct HelloBuilder {
  typedef Hello Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_abiMajor(uint32_t abiMajor) {
    fbb_.AddElement<uint32_t>(Hello::VT_ABIMAJOR, abiMajor, 0);
  }
  void add_abiMinor(uint32_t abiMinor) {
    fbb_.AddElement<uint32_t>(Hello::VT_ABIMINOR, abiMinor, 0);
  }
  void add_buildFingerprint(::flatbuffers::Offset<::flatbuffers::String> buildFingerprint) {
    fbb_.AddOffset(Hello::VT_BUILDFINGERPRINT, buildFingerprint);
  }
  void add_backendType(uint32_t backendType) {
    fbb_.AddElement<uint32_t>(Hello::VT_BACKENDTYPE, backendType, 0);
  }
  void add_pid(uint32_t pid) {
    fbb_.AddElement<uint32_t>(Hello::VT_PID, pid, 0);
  }
  void add_configBlob(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> configBlob) {
    fbb_.AddOffset(Hello::VT_CONFIGBLOB, configBlob);
  }
  void add_abiFingerprint(uint64_t abiFingerprint) {
    fbb_.AddElement<uint64_t>(Hello::VT_ABIFINGERPRINT, abiFingerprint, 0);
  }
  void add_wireFingerprint(uint64_t wireFingerprint) {
    fbb_.AddElement<uint64_t>(Hello::VT_WIREFINGERPRINT, wireFingerprint, 0);
  }
  void add_linkTerms(::flatbuffers::Offset<MobileGL::Wire::LinkTerms> linkTerms) {
    fbb_.AddOffset(Hello::VT_LINKTERMS, linkTerms);
  }
  void add_token(::flatbuffers::Offset<::flatbuffers::String> token) {
    fbb_.AddOffset(Hello::VT_TOKEN, token);
  }
  void add_dialMode(MobileGL::Wire::DialMode dialMode) {
    fbb_.AddElement<uint8_t>(Hello::VT_DIALMODE, static_cast<uint8_t>(dialMode), 0);
  }
  explicit HelloBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Hello> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Hello>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Hello> CreateHello(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t abiMajor = 0,
    uint32_t abiMinor = 0,
    ::flatbuffers::Offset<::flatbuffers::String> buildFingerprint = 0,
    uint32_t backendType = 0,
    uint32_t pid = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> configBlob = 0,
    uint64_t abiFingerprint = 0,
    uint64_t wireFingerprint = 0,
    ::flatbuffers::Offset<MobileGL::Wire::LinkTerms> linkTerms = 0,
    ::flatbuffers::Offset<::flatbuffers::String> token = 0,
    MobileGL::Wire::DialMode dialMode = MobileGL::Wire::DialMode::No) {
  HelloBuilder builder_(_fbb);
  builder_.add_wireFingerprint(wireFingerprint);
  builder_.add_abiFingerprint(abiFingerprint);
  builder_.add_token(token);
  builder_.add_linkTerms(linkTerms);
  builder_.add_configBlob(configBlob);
  builder_.add_pid(pid);
  builder_.add_backendType(backendType);
  builder_.add_buildFingerprint(buildFingerprint);
  builder_.add_abiMinor(abiMinor);
  builder_.add_abiMajor(abiMajor);
  builder_.add_dialMode(dialMode);
  return builder_.Finish();
}

struct Hello::Traits {
  using type = Hello;
  static auto constexpr Create = CreateHello;
};

inline ::flatbuffers::Offset<Hello> CreateHelloDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t abiMajor = 0,
    uint32_t abiMinor = 0,
    const char *buildFingerprint = nullptr,
    uint32_t backendType = 0,
    uint32_t pid = 0,
    const std::vector<uint8_t> *configBlob = nullptr,
    uint64_t abiFingerprint = 0,
    uint64_t wireFingerprint = 0,
    ::flatbuffers::Offset<MobileGL::Wire::LinkTerms> linkTerms = 0,
    const char *token = nullptr,
    MobileGL::Wire::DialMode dialMode = MobileGL::Wire::DialMode::No) {
  auto buildFingerprint__ = buildFingerprint ? _fbb.CreateString(buildFingerprint) : 0;
  auto configBlob__ = configBlob ? _fbb.CreateVector<uint8_t>(*configBlob) : 0;
  auto token__ = token ? _fbb.CreateString(token) : 0;
  return MobileGL::Wire::CreateHello(
      _fbb,
      abiMajor,
      abiMinor,
      buildFingerprint__,
      backendType,
      pid,
      configBlob__,
      abiFingerprint,
      wireFingerprint,
      linkTerms,
      token__,
      dialMode);
}

struct Welcome FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef WelcomeBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ABIMAJOR = 4,
    VT_ABIMINOR = 6,
    VT_SERVERPID = 8,
    VT_CMDRING = 10,
    VT_STAGERING = 12,
    VT_REPLYPOOL = 14,
    VT_EVENTRING = 16,
    VT_BUILDFINGERPRINT = 18,
    VT_ABIFINGERPRINT = 20,
    VT_WIREFINGERPRINT = 22,
    VT_LINKTERMS = 24,
    VT_BACKENDTYPE = 26,
    VT_DATANONCE = 28
  };
  uint32_t abiMajor() const {
    return GetField<uint32_t>(VT_ABIMAJOR, 0);
  }
  uint32_t abiMinor() const {
    return GetField<uint32_t>(VT_ABIMINOR, 0);
  }
  uint32_t serverPid() const {
    return GetField<uint32_t>(VT_SERVERPID, 0);
  }
  const MobileGL::Wire::SegmentRef *cmdRing() const {
    return GetPointer<const MobileGL::Wire::SegmentRef *>(VT_CMDRING);
  }
  const MobileGL::Wire::SegmentRef *stageRing() const {
    return GetPointer<const MobileGL::Wire::SegmentRef *>(VT_STAGERING);
  }
  const MobileGL::Wire::SegmentRef *replyPool() const {
    return GetPointer<const MobileGL::Wire::SegmentRef *>(VT_REPLYPOOL);
  }
  const MobileGL::Wire::SegmentRef *eventRing() const {
    return GetPointer<const MobileGL::Wire::SegmentRef *>(VT_EVENTRING);
  }
  const ::flatbuffers::String *buildFingerprint() const {
    return GetPointer<const ::flatbuffers::String *>(VT_BUILDFINGERPRINT);
  }
  uint64_t abiFingerprint() const {
    return GetField<uint64_t>(VT_ABIFINGERPRINT, 0);
  }
  uint64_t wireFingerprint() const {
    return GetField<uint64_t>(VT_WIREFINGERPRINT, 0);
  }
  const MobileGL::Wire::LinkTerms *linkTerms() const {
    return GetPointer<const MobileGL::Wire::LinkTerms *>(VT_LINKTERMS);
  }
  uint32_t backendType() const {
    return GetField<uint32_t>(VT_BACKENDTYPE, 0);
  }
  const ::flatbuffers::Vector<uint8_t> *dataNonce() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATANONCE);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_ABIMAJOR, 4) &&
           VerifyField<uint32_t>(verifier, VT_ABIMINOR, 4) &&
           VerifyField<uint32_t>(verifier, VT_SERVERPID, 4) &&
           VerifyOffset(verifier, VT_CMDRING) &&
           verifier.VerifyTable(cmdRing()) &&
           VerifyOffset(verifier, VT_STAGERING) &&
           verifier.VerifyTable(stageRing()) &&
           VerifyOffset(verifier, VT_REPLYPOOL) &&
           verifier.VerifyTable(replyPool()) &&
           VerifyOffset(verifier, VT_EVENTRING) &&
           verifier.VerifyTable(eventRing()) &&
           VerifyOffset(verifier, VT_BUILDFINGERPRINT) &&
           verifier.VerifyString(buildFingerprint()) &&
           VerifyField<uint64_t>(verifier, VT_ABIFINGERPRINT, 8) &&
           VerifyField<uint64_t>(verifier, VT_WIREFINGERPRINT, 8) &&
           VerifyOffset(verifier, VT_LINKTERMS) &&
           verifier.VerifyTable(linkTerms()) &&
           VerifyField<uint32_t>(verifier, VT_BACKENDTYPE, 4) &&
           VerifyOffset(verifier, VT_DATANONCE) &&
           verifier.VerifyVector(dataNonce()) &&
           verifier.EndTable();
  }
};

struct WelcomeBuilder {
  typedef Welcome Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_abiMajor(uint32_t abiMajor) {
    fbb_.AddElement<uint32_t>(Welcome::VT_ABIMAJOR, abiMajor, 0);
  }
  void add_abiMinor(uint32_t abiMinor) {
    fbb_.AddElement<uint32_t>(Welcome::VT_ABIMINOR, abiMinor, 0);
  }
  void add_serverPid(uint32_t serverPid) {
    fbb_.AddElement<uint32_t>(Welcome::VT_SERVERPID, serverPid, 0);
  }
  void add_cmdRing(::flatbuffers::Offset<MobileGL::Wire::SegmentRef> cmdRing) {
    fbb_.AddOffset(Welcome::VT_CMDRING, cmdRing);
  }
  void add_stageRing(::flatbuffers::Offset<MobileGL::Wire::SegmentRef> stageRing) {
    fbb_.AddOffset(Welcome::VT_STAGERING, stageRing);
  }
  void add_replyPool(::flatbuffers::Offset<MobileGL::Wire::SegmentRef> replyPool) {
    fbb_.AddOffset(Welcome::VT_REPLYPOOL, replyPool);
  }
  void add_eventRing(::flatbuffers::Offset<MobileGL::Wire::SegmentRef> eventRing) {
    fbb_.AddOffset(Welcome::VT_EVENTRING, eventRing);
  }
  void add_buildFingerprint(::flatbuffers::Offset<::flatbuffers::String> buildFingerprint) {
    fbb_.AddOffset(Welcome::VT_BUILDFINGERPRINT, buildFingerprint);
  }
  void add_abiFingerprint(uint64_t abiFingerprint) {
    fbb_.AddElement<uint64_t>(Welcome::VT_ABIFINGERPRINT, abiFingerprint, 0);
  }
  void add_wireFingerprint(uint64_t wireFingerprint) {
    fbb_.AddElement<uint64_t>(Welcome::VT_WIREFINGERPRINT, wireFingerprint, 0);
  }
  void add_linkTerms(::flatbuffers::Offset<MobileGL::Wire::LinkTerms> linkTerms) {
    fbb_.AddOffset(Welcome::VT_LINKTERMS, linkTerms);
  }
  void add_backendType(uint32_t backendType) {
    fbb_.AddElement<uint32_t>(Welcome::VT_BACKENDTYPE, backendType, 0);
  }
  void add_dataNonce(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> dataNonce) {
    fbb_.AddOffset(Welcome::VT_DATANONCE, dataNonce);
  }
  explicit WelcomeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Welcome> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Welcome>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Welcome> CreateWelcome(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t abiMajor = 0,
    uint32_t abiMinor = 0,
    uint32_t serverPid = 0,
    ::flatbuffers::Offset<MobileGL::Wire::SegmentRef> cmdRing = 0,
    ::flatbuffers::Offset<MobileGL::Wire::SegmentRef> stageRing = 0,
    ::flatbuffers::Offset<MobileGL::Wire::SegmentRef> replyPool = 0,
    ::flatbuffers::Offset<MobileGL::Wire::SegmentRef> eventRing = 0,
    ::flatbuffers::Offset<::flatbuffers::String> buildFingerprint = 0,
    uint64_t abiFingerprint = 0,
    uint64_t wireFingerprint = 0,
    ::flatbuffers::Offset<MobileGL::Wire::LinkTerms> linkTerms = 0,
    uint32_t backendType = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> dataNonce = 0) {
  WelcomeBuilder builder_(_fbb);
  builder_.add_wireFingerprint(wireFingerprint);
  builder_.add_abiFingerprint(abiFingerprint);
  builder_.add_dataNonce(dataNonce);
  builder_.add_backendType(backendType);
  builder_.add_linkTerms(linkTerms);
  builder_.add_buildFingerprint(buildFingerprint);
  builder_.add_eventRing(eventRing);
  builder_.add_replyPool(replyPool);
  builder_.add_stageRing(stageRing);
  builder_.add_cmdRing(cmdRing);
  builder_.add_serverPid(serverPid);
  builder_.add_abiMinor(abiMinor);
  builder_.add_abiMajor(abiMajor);
  return builder_.Finish();
}

struct Welcome::Traits {
  using type = Welcome;
  static auto constexpr Create = CreateWelcome;
};

inline ::flatbuffers::Offset<Welcome> CreateWelcomeDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t abiMajor = 0,
    uint32_t abiMinor = 0,
    uint32_t serverPid = 0,
    ::flatbuffers::Offset<MobileGL::Wire::SegmentRef> cmdRing = 0,
    ::flatbuffers::Offset<MobileGL::Wire::SegmentRef> stageRing = 0,
    ::flatbuffers::Offset<MobileGL::Wire::SegmentRef> replyPool = 0,
    ::flatbuffers::Offset<MobileGL::Wire::SegmentRef> eventRing = 0,
    const char *buildFingerprint = nullptr,
    uint64_t abiFingerprint = 0,
    uint64_t wireFingerprint = 0,
    ::flatbuffers::Offset<MobileGL::Wire::LinkTerms> linkTerms = 0,
    uint32_t backendType = 0,
    const std::vector<uint8_t> *dataNonce = nullptr) {
  auto buildFingerprint__ = buildFingerprint ? _fbb.CreateString(buildFingerprint) : 0;
  auto dataNonce__ = dataNonce ? _fbb.CreateVector<uint8_t>(*dataNonce) : 0;
  return MobileGL::Wire::CreateWelcome(
      _fbb,
      abiMajor,
      abiMinor,
      serverPid,
      cmdRing,
      stageRing,
      replyPool,
      eventRing,
      buildFingerprint__,
      abiFingerprint,
      wireFingerprint,
      linkTerms,
      backendType,
      dataNonce__);
}

struct DataBind FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DataBindBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NONCE = 4
  };
  const ::flatbuffers::Vector<uint8_t> *nonce() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_NONCE);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NONCE) &&
           verifier.VerifyVector(nonce()) &&
           verifier.EndTable();
  }
};

struct DataBindBuilder {
  typedef DataBind Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_nonce(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> nonce) {
    fbb_.AddOffset(DataBind::VT_NONCE, nonce);
  }
  explicit DataBindBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DataBind> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DataBind>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<DataBind> CreateDataBind(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> nonce = 0) {
  DataBindBuilder builder_(_fbb);
  builder_.add_nonce(nonce);
  return builder_.Finish();
}

struct DataBind::Traits {
  using type = DataBind;
  static auto constexpr Create = CreateDataBind;
};

inline ::flatbuffers::Offset<DataBind> CreateDataBindDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *nonce = nullptr) {
  auto nonce__ = nonce ? _fbb.CreateVector<uint8_t>(*nonce) : 0;
  return MobileGL::Wire::CreateDataBind(
      _fbb,
      nonce__);
}

struct PairBind FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef PairBindBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NONCE = 4,
    VT_AUX = 6
  };
  const ::flatbuffers::Vector<uint8_t> *nonce() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_NONCE);
  }
  bool aux() const {
    return GetField<uint8_t>(VT_AUX, 0) != 0;
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NONCE) &&
           verifier.VerifyVector(nonce()) &&
           VerifyField<uint8_t>(verifier, VT_AUX, 1) &&
           verifier.EndTable();
  }
};

struct PairBindBuilder {
  typedef PairBind Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_nonce(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> nonce) {
    fbb_.AddOffset(PairBind::VT_NONCE, nonce);
  }
  void add_aux(bool aux) {
    fbb_.AddElement<uint8_t>(PairBind::VT_AUX, static_cast<uint8_t>(aux), 0);
  }
  explicit PairBindBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<PairBind> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<PairBind>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<PairBind> CreatePairBind(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> nonce = 0,
    bool aux = false) {
  PairBindBuilder builder_(_fbb);
  builder_.add_nonce(nonce);
  builder_.add_aux(aux);
  return builder_.Finish();
}

struct PairBind::Traits {
  using type = PairBind;
  static auto constexpr Create = CreatePairBind;
};

inline ::flatbuffers::Offset<PairBind> CreatePairBindDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *nonce = nullptr,
    bool aux = false) {
  auto nonce__ = nonce ? _fbb.CreateVector<uint8_t>(*nonce) : 0;
  return MobileGL::Wire::CreatePairBind(
      _fbb,
      nonce__,
      aux);
}

struct CapsSnapshot FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CapsSnapshotBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DYNAMICPARAMETERS = 4,
    VT_RENDERERINFO = 6,
    VT_FORMATCAPS = 8,
    VT_EXTENSIONS = 10,
    VT_APIVERSION = 12,
    VT_CALLMASK = 22,
    VT_BACKENDTYPE = 24
  };
  const ::flatbuffers::Vector<uint8_t> *dynamicParameters() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DYNAMICPARAMETERS);
  }
  const ::flatbuffers::Vector<uint8_t> *rendererInfo() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_RENDERERINFO);
  }
  const ::flatbuffers::Vector<uint8_t> *formatCaps() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_FORMATCAPS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *extensions() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_EXTENSIONS);
  }
  const ::flatbuffers::String *apiVersion() const {
    return GetPointer<const ::flatbuffers::String *>(VT_APIVERSION);
  }
  uint64_t callMask() const {
    return GetField<uint64_t>(VT_CALLMASK, 0);
  }
  uint32_t backendType() const {
    return GetField<uint32_t>(VT_BACKENDTYPE, 0);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DYNAMICPARAMETERS) &&
           verifier.VerifyVector(dynamicParameters()) &&
           VerifyOffset(verifier, VT_RENDERERINFO) &&
           verifier.VerifyVector(rendererInfo()) &&
           VerifyOffset(verifier, VT_FORMATCAPS) &&
           verifier.VerifyVector(formatCaps()) &&
           VerifyOffset(verifier, VT_EXTENSIONS) &&
           verifier.VerifyVector(extensions()) &&
           verifier.VerifyVectorOfStrings(extensions()) &&
           VerifyOffset(verifier, VT_APIVERSION) &&
           verifier.VerifyString(apiVersion()) &&
           VerifyField<uint64_t>(verifier, VT_CALLMASK, 8) &&
           VerifyField<uint32_t>(verifier, VT_BACKENDTYPE, 4) &&
           verifier.EndTable();
  }
};

struct CapsSnapshotBuilder {
  typedef CapsSnapshot Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_dynamicParameters(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> dynamicParameters) {
    fbb_.AddOffset(CapsSnapshot::VT_DYNAMICPARAMETERS, dynamicParameters);
  }
  void add_rendererInfo(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> rendererInfo) {
    fbb_.AddOffset(CapsSnapshot::VT_RENDERERINFO, rendererInfo);
  }
  void add_formatCaps(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> formatCaps) {
    fbb_.AddOffset(CapsSnapshot::VT_FORMATCAPS, formatCaps);
  }
  void add_extensions(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> extensions) {
    fbb_.AddOffset(CapsSnapshot::VT_EXTENSIONS, extensions);
  }
  void add_apiVersion(::flatbuffers::Offset<::flatbuffers::String> apiVersion) {
    fbb_.AddOffset(CapsSnapshot::VT_APIVERSION, apiVersion);
  }
  void add_callMask(uint64_t callMask) {
    fbb_.AddElement<uint64_t>(CapsSnapshot::VT_CALLMASK, callMask, 0);
  }
  void add_backendType(uint32_t backendType) {
    fbb_.AddElement<uint32_t>(CapsSnapshot::VT_BACKENDTYPE, backendType, 0);
  }
  explicit CapsSnapshotBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CapsSnapshot> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CapsSnapshot>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<CapsSnapshot> CreateCapsSnapshot(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> dynamicParameters = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> rendererInfo = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> formatCaps = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> extensions = 0,
    ::flatbuffers::Offset<::flatbuffers::String> apiVersion = 0,
    uint64_t callMask = 0,
    uint32_t backendType = 0) {
  CapsSnapshotBuilder builder_(_fbb);
  builder_.add_callMask(callMask);
  builder_.add_backendType(backendType);
  builder_.add_apiVersion(apiVersion);
  builder_.add_extensions(extensions);
  builder_.add_formatCaps(formatCaps);
  builder_.add_rendererInfo(rendererInfo);
  builder_.add_dynamicParameters(dynamicParameters);
  return builder_.Finish();
}

struct CapsSnapshot::Traits {
  using type = CapsSnapshot;
  static auto constexpr Create = CreateCapsSnapshot;
};

inline ::flatbuffers::Offset<CapsSnapshot> CreateCapsSnapshotDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *dynamicParameters = nullptr,
    const std::vector<uint8_t> *rendererInfo = nullptr,
    const std::vector<uint8_t> *formatCaps = nullptr,
    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *extensions = nullptr,
    const char *apiVersion = nullptr,
    uint64_t callMask = 0,
    uint32_t backendType = 0) {
  auto dynamicParameters__ = dynamicParameters ? _fbb.CreateVector<uint8_t>(*dynamicParameters) : 0;
  auto rendererInfo__ = rendererInfo ? _fbb.CreateVector<uint8_t>(*rendererInfo) : 0;
  auto formatCaps__ = formatCaps ? _fbb.CreateVector<uint8_t>(*formatCaps) : 0;
  auto extensions__ = extensions ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*extensions) : 0;
  auto apiVersion__ = apiVersion ? _fbb.CreateString(apiVersion) : 0;
  return MobileGL::Wire::CreateCapsSnapshot(
      _fbb,
      dynamicParameters__,
      rendererInfo__,
      formatCaps__,
      extensions__,
      apiVersion__,
      callMask,
      backendType);
}

struct DefaultFramebufferInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DefaultFramebufferInfoBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_WIDTH = 4,
    VT_HEIGHT = 6,
    VT_COLORFORMAT = 8,
    VT_DEPTHFORMAT = 10,
    VT_STENCILFORMAT = 12
  };
  int32_t width() const {
    return GetField<int32_t>(VT_WIDTH, 0);
  }
  int32_t height() const {
    return GetField<int32_t>(VT_HEIGHT, 0);
  }
  uint32_t colorFormat() const {
    return GetField<uint32_t>(VT_COLORFORMAT, 0);
  }
  uint32_t depthFormat() const {
    return GetField<uint32_t>(VT_DEPTHFORMAT, 0);
  }
  uint32_t stencilFormat() const {
    return GetField<uint32_t>(VT_STENCILFORMAT, 0);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_WIDTH, 4) &&
           VerifyField<int32_t>(verifier, VT_HEIGHT, 4) &&
           VerifyField<uint32_t>(verifier, VT_COLORFORMAT, 4) &&
           VerifyField<uint32_t>(verifier, VT_DEPTHFORMAT, 4) &&
           VerifyField<uint32_t>(verifier, VT_STENCILFORMAT, 4) &&
           verifier.EndTable();
  }
};

struct DefaultFramebufferInfoBuilder {
  typedef DefaultFramebufferInfo Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_width(int32_t width) {
    fbb_.AddElement<int32_t>(DefaultFramebufferInfo::VT_WIDTH, width, 0);
  }
  void add_height(int32_t height) {
    fbb_.AddElement<int32_t>(DefaultFramebufferInfo::VT_HEIGHT, height, 0);
  }
  void add_colorFormat(uint32_t colorFormat) {
    fbb_.AddElement<uint32_t>(DefaultFramebufferInfo::VT_COLORFORMAT, colorFormat, 0);
  }
  void add_depthFormat(uint32_t depthFormat) {
    fbb_.AddElement<uint32_t>(DefaultFramebufferInfo::VT_DEPTHFORMAT, depthFormat, 0);
  }
  void add_stencilFormat(uint32_t stencilFormat) {
    fbb_.AddElement<uint32_t>(DefaultFramebufferInfo::VT_STENCILFORMAT, stencilFormat, 0);
  }
  explicit DefaultFramebufferInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DefaultFramebufferInfo> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DefaultFramebufferInfo>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<DefaultFramebufferInfo> CreateDefaultFramebufferInfo(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t width = 0,
    int32_t height = 0,
    uint32_t colorFormat = 0,
    uint32_t depthFormat = 0,
    uint32_t stencilFormat = 0) {
  DefaultFramebufferInfoBuilder builder_(_fbb);
  builder_.add_stencilFormat(stencilFormat);
  builder_.add_depthFormat(depthFormat);
  builder_.add_colorFormat(colorFormat);
  builder_.add_height(height);
  builder_.add_width(width);
  return builder_.Finish();
}

struct DefaultFramebufferInfo::Traits {
  using type = DefaultFramebufferInfo;
  static auto constexpr Create = CreateDefaultFramebufferInfo;
};

struct SurfaceOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SurfaceOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SEQ = 4,
    VT_KIND = 6,
    VT_DISPLAY = 8,
    VT_SURFACE = 10,
    VT_WINDOWKIND = 12,
    VT_NATIVETOKEN = 14,
    VT_WIDTH = 16,
    VT_HEIGHT = 18,
    VT_SWAPINTERVAL = 20,
    VT_READSURFACE = 22,
    VT_CONTEXT = 24
  };
  uint64_t seq() const {
    return GetField<uint64_t>(VT_SEQ, 0);
  }
  MobileGL::Wire::SurfaceOpKind kind() const {
    return static_cast<MobileGL::Wire::SurfaceOpKind>(GetField<uint8_t>(VT_KIND, 0));
  }
  uint64_t display() const {
    return GetField<uint64_t>(VT_DISPLAY, 0);
  }
  uint64_t surface() const {
    return GetField<uint64_t>(VT_SURFACE, 0);
  }
  MobileGL::Wire::WindowKind windowKind() const {
    return static_cast<MobileGL::Wire::WindowKind>(GetField<uint8_t>(VT_WINDOWKIND, 0));
  }
  uint64_t nativeToken() const {
    return GetField<uint64_t>(VT_NATIVETOKEN, 0);
  }
  int32_t width() const {
    return GetField<int32_t>(VT_WIDTH, 0);
  }
  int32_t height() const {
    return GetField<int32_t>(VT_HEIGHT, 0);
  }
  int32_t swapInterval() const {
    return GetField<int32_t>(VT_SWAPINTERVAL, 0);
  }
  uint64_t readSurface() const {
    return GetField<uint64_t>(VT_READSURFACE, 0);
  }
  uint64_t context() const {
    return GetField<uint64_t>(VT_CONTEXT, 0);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_SEQ, 8) &&
           VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
           VerifyField<uint64_t>(verifier, VT_DISPLAY, 8) &&
           VerifyField<uint64_t>(verifier, VT_SURFACE, 8) &&
           VerifyField<uint8_t>(verifier, VT_WINDOWKIND, 1) &&
           VerifyField<uint64_t>(verifier, VT_NATIVETOKEN, 8) &&
           VerifyField<int32_t>(verifier, VT_WIDTH, 4) &&
           VerifyField<int32_t>(verifier, VT_HEIGHT, 4) &&
           VerifyField<int32_t>(verifier, VT_SWAPINTERVAL, 4) &&
           VerifyField<uint64_t>(verifier, VT_READSURFACE, 8) &&
           VerifyField<uint64_t>(verifier, VT_CONTEXT, 8) &&
           verifier.EndTable();
  }
};

struct SurfaceOpBuilder {
  typedef SurfaceOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_seq(uint64_t seq) {
    fbb_.AddElement<uint64_t>(SurfaceOp::VT_SEQ, seq, 0);
  }
  void add_kind(MobileGL::Wire::SurfaceOpKind kind) {
    fbb_.AddElement<uint8_t>(SurfaceOp::VT_KIND, static_cast<uint8_t>(kind), 0);
  }
  void add_display(uint64_t display) {
    fbb_.AddElement<uint64_t>(SurfaceOp::VT_DISPLAY, display, 0);
  }
  void add_surface(uint64_t surface) {
    fbb_.AddElement<uint64_t>(SurfaceOp::VT_SURFACE, surface, 0);
  }
  void add_windowKind(MobileGL::Wire::WindowKind windowKind) {
    fbb_.AddElement<uint8_t>(SurfaceOp::VT_WINDOWKIND, static_cast<uint8_t>(windowKind), 0);
  }
  void add_nativeToken(uint64_t nativeToken) {
    fbb_.AddElement<uint64_t>(SurfaceOp::VT_NATIVETOKEN, nativeToken, 0);
  }
  void add_width(int32_t width) {
    fbb_.AddElement<int32_t>(SurfaceOp::VT_WIDTH, width, 0);
  }
  void add_height(int32_t height) {
    fbb_.AddElement<int32_t>(SurfaceOp::VT_HEIGHT, height, 0);
  }
  void add_swapInterval(int32_t swapInterval) {
    fbb_.AddElement<int32_t>(SurfaceOp::VT_SWAPINTERVAL, swapInterval, 0);
  }
  void add_readSurface(uint64_t readSurface) {
    fbb_.AddElement<uint64_t>(SurfaceOp::VT_READSURFACE, readSurface, 0);
  }
  void add_context(uint64_t context) {
    fbb_.AddElement<uint64_t>(SurfaceOp::VT_CONTEXT, context, 0);
  }
  explicit SurfaceOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SurfaceOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SurfaceOp>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SurfaceOp> CreateSurfaceOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t seq = 0,
    MobileGL::Wire::SurfaceOpKind kind = MobileGL::Wire::SurfaceOpKind::None,
    uint64_t display = 0,
    uint64_t surface = 0,
    MobileGL::Wire::WindowKind windowKind = MobileGL::Wire::WindowKind::None,
    uint64_t nativeToken = 0,
    int32_t width = 0,
    int32_t height = 0,
    int32_t swapInterval = 0,
    uint64_t readSurface = 0,
    uint64_t context = 0) {
  SurfaceOpBuilder builder_(_fbb);
  builder_.add_context(context);
  builder_.add_readSurface(readSurface);
  builder_.add_nativeToken(nativeToken);
  builder_.add_surface(surface);
  builder_.add_display(display);
  builder_.add_seq(seq);
  builder_.add_swapInterval(swapInterval);
  builder_.add_height(height);
  builder_.add_width(width);
  builder_.add_windowKind(windowKind);
  builder_.add_kind(kind);
  return builder_.Finish();
}

struct SurfaceOp::Traits {
  using type = SurfaceOp;
  static auto constexpr Create = CreateSurfaceOp;
};

struct SurfaceReply FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SurfaceReplyBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SEQ = 4,
    VT_OK = 6,
    VT_EGLMAJOR = 8,
    VT_EGLMINOR = 10,
    VT_DEFAULTFB = 12,
    VT_EVENTHEAD = 14,
    VT_WIDTH = 16,
    VT_HEIGHT = 18,
    VT_REFUSAL = 20
  };
  uint64_t seq() const {
    return GetField<uint64_t>(VT_SEQ, 0);
  }
  bool ok() const {
    return GetField<uint8_t>(VT_OK, 0) != 0;
  }
  int32_t eglMajor() const {
    return GetField<int32_t>(VT_EGLMAJOR, 0);
  }
  int32_t eglMinor() const {
    return GetField<int32_t>(VT_EGLMINOR, 0);
  }
  const MobileGL::Wire::DefaultFramebufferInfo *defaultFb() const {
    return GetPointer<const MobileGL::Wire::DefaultFramebufferInfo *>(VT_DEFAULTFB);
  }
  uint64_t eventHead() const {
    return GetField<uint64_t>(VT_EVENTHEAD, 0);
  }
  int32_t width() const {
    return GetField<int32_t>(VT_WIDTH, 0);
  }
  int32_t height() const {
    return GetField<int32_t>(VT_HEIGHT, 0);
  }
  MobileGL::Wire::SurfaceRefusal refusal() const {
    return static_cast<MobileGL::Wire::SurfaceRefusal>(GetField<uint8_t>(VT_REFUSAL, 0));
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_SEQ, 8) &&
           VerifyField<uint8_t>(verifier, VT_OK, 1) &&
           VerifyField<int32_t>(verifier, VT_EGLMAJOR, 4) &&
           VerifyField<int32_t>(verifier, VT_EGLMINOR, 4) &&
           VerifyOffset(verifier, VT_DEFAULTFB) &&
           verifier.VerifyTable(defaultFb()) &&
           VerifyField<uint64_t>(verifier, VT_EVENTHEAD, 8) &&
           VerifyField<int32_t>(verifier, VT_WIDTH, 4) &&
           VerifyField<int32_t>(verifier, VT_HEIGHT, 4) &&
           VerifyField<uint8_t>(verifier, VT_REFUSAL, 1) &&
           verifier.EndTable();
  }
};

struct SurfaceReplyBuilder {
  typedef SurfaceReply Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_seq(uint64_t seq) {
    fbb_.AddElement<uint64_t>(SurfaceReply::VT_SEQ, seq, 0);
  }
  void add_ok(bool ok) {
    fbb_.AddElement<uint8_t>(SurfaceReply::VT_OK, static_cast<uint8_t>(ok), 0);
  }
  void add_eglMajor(int32_t eglMajor) {
    fbb_.AddElement<int32_t>(SurfaceReply::VT_EGLMAJOR, eglMajor, 0);
  }
  void add_eglMinor(int32_t eglMinor) {
    fbb_.AddElement<int32_t>(SurfaceReply::VT_EGLMINOR, eglMinor, 0);
  }
  void add_defaultFb(::flatbuffers::Offset<MobileGL::Wire::DefaultFramebufferInfo> defaultFb) {
    fbb_.AddOffset(SurfaceReply::VT_DEFAULTFB, defaultFb);
  }
  void add_eventHead(uint64_t eventHead) {
    fbb_.AddElement<uint64_t>(SurfaceReply::VT_EVENTHEAD, eventHead, 0);
  }
  void add_width(int32_t width) {
    fbb_.AddElement<int32_t>(SurfaceReply::VT_WIDTH, width, 0);
  }
  void add_height(int32_t height) {
    fbb_.AddElement<int32_t>(SurfaceReply::VT_HEIGHT, height, 0);
  }
  void add_refusal(MobileGL::Wire::SurfaceRefusal refusal) {
    fbb_.AddElement<uint8_t>(SurfaceReply::VT_REFUSAL, static_cast<uint8_t>(refusal), 0);
  }
  explicit SurfaceReplyBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SurfaceReply> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SurfaceReply>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SurfaceReply> CreateSurfaceReply(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t seq = 0,
    bool ok = false,
    int32_t eglMajor = 0,
    int32_t eglMinor = 0,
    ::flatbuffers::Offset<MobileGL::Wire::DefaultFramebufferInfo> defaultFb = 0,
    uint64_t eventHead = 0,
    int32_t width = 0,
    int32_t height = 0,
    MobileGL::Wire::SurfaceRefusal refusal = MobileGL::Wire::SurfaceRefusal::None) {
  SurfaceReplyBuilder builder_(_fbb);
  builder_.add_eventHead(eventHead);
  builder_.add_seq(seq);
  builder_.add_height(height);
  builder_.add_width(width);
  builder_.add_defaultFb(defaultFb);
  builder_.add_eglMinor(eglMinor);
  builder_.add_eglMajor(eglMajor);
  builder_.add_refusal(refusal);
  builder_.add_ok(ok);
  return builder_.Finish();
}

struct SurfaceReply::Traits {
  using type = SurfaceReply;
  static auto constexpr Create = CreateSurfaceReply;
};

struct ResyncRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ResyncRequestBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SERVEREPOCH = 4
  };
  uint32_t serverEpoch() const {
    return GetField<uint32_t>(VT_SERVEREPOCH, 0);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_SERVEREPOCH, 4) &&
           verifier.EndTable();
  }
};

struct ResyncRequestBuilder {
  typedef ResyncRequest Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_serverEpoch(uint32_t serverEpoch) {
    fbb_.AddElement<uint32_t>(ResyncRequest::VT_SERVEREPOCH, serverEpoch, 0);
  }
  explicit ResyncRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ResyncRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ResyncRequest>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<ResyncRequest> CreateResyncRequest(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t serverEpoch = 0) {
  ResyncRequestBuilder builder_(_fbb);
  builder_.add_serverEpoch(serverEpoch);
  return builder_.Finish();
}

struct ResyncRequest::Traits {
  using type = ResyncRequest;
  static auto constexpr Create = CreateResyncRequest;
};

struct ResyncDone FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ResyncDoneBuilder Builder;
  struct Traits;
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

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

inline ::flatbuffers::Offset<ResyncDone> CreateResyncDone(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  ResyncDoneBuilder builder_(_fbb);
  return builder_.Finish();
}

struct ResyncDone::Traits {
  using type = ResyncDone;
  static auto constexpr Create = CreateResyncDone;
};

struct AuxRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef AuxRequestBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SEQ = 4,
    VT_KIND = 6,
    VT_PAYLOAD = 8
  };
  uint64_t seq() const {
    return GetField<uint64_t>(VT_SEQ, 0);
  }
  MobileGL::Wire::AuxRequestKind kind() const {
    return static_cast<MobileGL::Wire::AuxRequestKind>(GetField<uint8_t>(VT_KIND, 0));
  }
  const ::flatbuffers::Vector<uint8_t> *payload() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_PAYLOAD);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_SEQ, 8) &&
           VerifyField<uint8_t>(verifier, VT_KIND, 1) &&
           VerifyOffset(verifier, VT_PAYLOAD) &&
           verifier.VerifyVector(payload()) &&
           verifier.EndTable();
  }
};

struct AuxRequestBuilder {
  typedef AuxRequest Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_seq(uint64_t seq) {
    fbb_.AddElement<uint64_t>(AuxRequest::VT_SEQ, seq, 0);
  }
  void add_kind(MobileGL::Wire::AuxRequestKind kind) {
    fbb_.AddElement<uint8_t>(AuxRequest::VT_KIND, static_cast<uint8_t>(kind), 0);
  }
  void add_payload(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> payload) {
    fbb_.AddOffset(AuxRequest::VT_PAYLOAD, payload);
  }
  explicit AuxRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<AuxRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<AuxRequest>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<AuxRequest> CreateAuxRequest(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t seq = 0,
    MobileGL::Wire::AuxRequestKind kind = MobileGL::Wire::AuxRequestKind::None,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> payload = 0) {
  AuxRequestBuilder builder_(_fbb);
  builder_.add_seq(seq);
  builder_.add_payload(payload);
  builder_.add_kind(kind);
  return builder_.Finish();
}

struct AuxRequest::Traits {
  using type = AuxRequest;
  static auto constexpr Create = CreateAuxRequest;
};

inline ::flatbuffers::Offset<AuxRequest> CreateAuxRequestDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t seq = 0,
    MobileGL::Wire::AuxRequestKind kind = MobileGL::Wire::AuxRequestKind::None,
    const std::vector<uint8_t> *payload = nullptr) {
  auto payload__ = payload ? _fbb.CreateVector<uint8_t>(*payload) : 0;
  return MobileGL::Wire::CreateAuxRequest(
      _fbb,
      seq,
      kind,
      payload__);
}

struct Fatal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FatalBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CODE = 4,
    VT_MESSAGE = 6,
    VT_FAMILY = 8
  };
  MobileGL::Wire::FatalCode code() const {
    return static_cast<MobileGL::Wire::FatalCode>(GetField<uint32_t>(VT_CODE, 0));
  }
  const ::flatbuffers::String *message() const {
    return GetPointer<const ::flatbuffers::String *>(VT_MESSAGE);
  }
  const ::flatbuffers::String *family() const {
    return GetPointer<const ::flatbuffers::String *>(VT_FAMILY);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_CODE, 4) &&
           VerifyOffset(verifier, VT_MESSAGE) &&
           verifier.VerifyString(message()) &&
           VerifyOffset(verifier, VT_FAMILY) &&
           verifier.VerifyString(family()) &&
           verifier.EndTable();
  }
};

struct FatalBuilder {
  typedef Fatal Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_code(MobileGL::Wire::FatalCode code) {
    fbb_.AddElement<uint32_t>(Fatal::VT_CODE, static_cast<uint32_t>(code), 0);
  }
  void add_message(::flatbuffers::Offset<::flatbuffers::String> message) {
    fbb_.AddOffset(Fatal::VT_MESSAGE, message);
  }
  void add_family(::flatbuffers::Offset<::flatbuffers::String> family) {
    fbb_.AddOffset(Fatal::VT_FAMILY, family);
  }
  explicit FatalBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Fatal> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Fatal>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Fatal> CreateFatal(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    MobileGL::Wire::FatalCode code = MobileGL::Wire::FatalCode::None,
    ::flatbuffers::Offset<::flatbuffers::String> message = 0,
    ::flatbuffers::Offset<::flatbuffers::String> family = 0) {
  FatalBuilder builder_(_fbb);
  builder_.add_family(family);
  builder_.add_message(message);
  builder_.add_code(code);
  return builder_.Finish();
}

struct Fatal::Traits {
  using type = Fatal;
  static auto constexpr Create = CreateFatal;
};

inline ::flatbuffers::Offset<Fatal> CreateFatalDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    MobileGL::Wire::FatalCode code = MobileGL::Wire::FatalCode::None,
    const char *message = nullptr,
    const char *family = nullptr) {
  auto message__ = message ? _fbb.CreateString(message) : 0;
  auto family__ = family ? _fbb.CreateString(family) : 0;
  return MobileGL::Wire::CreateFatal(
      _fbb,
      code,
      message__,
      family__);
}

struct LogLine FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LogLineBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_LEVEL = 4,
    VT_TEXT = 6
  };
  MobileGL::Wire::LogLevel level() const {
    return static_cast<MobileGL::Wire::LogLevel>(GetField<uint8_t>(VT_LEVEL, 0));
  }
  const ::flatbuffers::String *text() const {
    return GetPointer<const ::flatbuffers::String *>(VT_TEXT);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_LEVEL, 1) &&
           VerifyOffset(verifier, VT_TEXT) &&
           verifier.VerifyString(text()) &&
           verifier.EndTable();
  }
};

struct LogLineBuilder {
  typedef LogLine Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_level(MobileGL::Wire::LogLevel level) {
    fbb_.AddElement<uint8_t>(LogLine::VT_LEVEL, static_cast<uint8_t>(level), 0);
  }
  void add_text(::flatbuffers::Offset<::flatbuffers::String> text) {
    fbb_.AddOffset(LogLine::VT_TEXT, text);
  }
  explicit LogLineBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LogLine> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LogLine>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<LogLine> CreateLogLine(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    MobileGL::Wire::LogLevel level = MobileGL::Wire::LogLevel::Debug,
    ::flatbuffers::Offset<::flatbuffers::String> text = 0) {
  LogLineBuilder builder_(_fbb);
  builder_.add_text(text);
  builder_.add_level(level);
  return builder_.Finish();
}

struct LogLine::Traits {
  using type = LogLine;
  static auto constexpr Create = CreateLogLine;
};

inline ::flatbuffers::Offset<LogLine> CreateLogLineDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    MobileGL::Wire::LogLevel level = MobileGL::Wire::LogLevel::Debug,
    const char *text = nullptr) {
  auto text__ = text ? _fbb.CreateString(text) : 0;
  return MobileGL::Wire::CreateLogLine(
      _fbb,
      level,
      text__);
}

struct SurfaceProgress FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SurfaceProgressBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SEQ = 4,
    VT_ELAPSEDMS = 6
  };
  uint64_t seq() const {
    return GetField<uint64_t>(VT_SEQ, 0);
  }
  uint32_t elapsedMs() const {
    return GetField<uint32_t>(VT_ELAPSEDMS, 0);
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_SEQ, 8) &&
           VerifyField<uint32_t>(verifier, VT_ELAPSEDMS, 4) &&
           verifier.EndTable();
  }
};

struct SurfaceProgressBuilder {
  typedef SurfaceProgress Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_seq(uint64_t seq) {
    fbb_.AddElement<uint64_t>(SurfaceProgress::VT_SEQ, seq, 0);
  }
  void add_elapsedMs(uint32_t elapsedMs) {
    fbb_.AddElement<uint32_t>(SurfaceProgress::VT_ELAPSEDMS, elapsedMs, 0);
  }
  explicit SurfaceProgressBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SurfaceProgress> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SurfaceProgress>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<SurfaceProgress> CreateSurfaceProgress(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t seq = 0,
    uint32_t elapsedMs = 0) {
  SurfaceProgressBuilder builder_(_fbb);
  builder_.add_seq(seq);
  builder_.add_elapsedMs(elapsedMs);
  return builder_.Finish();
}

struct SurfaceProgress::Traits {
  using type = SurfaceProgress;
  static auto constexpr Create = CreateSurfaceProgress;
};

struct CtrlEnvelope FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CtrlEnvelopeBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_MSG_TYPE = 4,
    VT_MSG = 6
  };
  MobileGL::Wire::CtrlMsg msg_type() const {
    return static_cast<MobileGL::Wire::CtrlMsg>(GetField<uint8_t>(VT_MSG_TYPE, 0));
  }
  const void *msg() const {
    return GetPointer<const void *>(VT_MSG);
  }
  template<typename T> const T *msg_as() const;
  const MobileGL::Wire::Hello *msg_as_Hello() const {
    return msg_type() == MobileGL::Wire::CtrlMsg::Hello ? static_cast<const MobileGL::Wire::Hello *>(msg()) : nullptr;
  }
  const MobileGL::Wire::Welcome *msg_as_Welcome() const {
    return msg_type() == MobileGL::Wire::CtrlMsg::Welcome ? static_cast<const MobileGL::Wire::Welcome *>(msg()) : nullptr;
  }
  const MobileGL::Wire::CapsSnapshot *msg_as_CapsSnapshot() const {
    return msg_type() == MobileGL::Wire::CtrlMsg::CapsSnapshot ? static_cast<const MobileGL::Wire::CapsSnapshot *>(msg()) : nullptr;
  }
  const MobileGL::Wire::SurfaceOp *msg_as_SurfaceOp() const {
    return msg_type() == MobileGL::Wire::CtrlMsg::SurfaceOp ? static_cast<const MobileGL::Wire::SurfaceOp *>(msg()) : nullptr;
  }
  const MobileGL::Wire::SurfaceReply *msg_as_SurfaceReply() const {
    return msg_type() == MobileGL::Wire::CtrlMsg::SurfaceReply ? static_cast<const MobileGL::Wire::SurfaceReply *>(msg()) : nullptr;
  }
  const MobileGL::Wire::ResyncRequest *msg_as_ResyncRequest() const {
    return msg_type() == MobileGL::Wire::CtrlMsg::ResyncRequest ? static_cast<const MobileGL::Wire::ResyncRequest *>(msg()) : nullptr;
  }
  const MobileGL::Wire::ResyncDone *msg_as_ResyncDone() const {
    return msg_type() == MobileGL::Wire::CtrlMsg::ResyncDone ? static_cast<const MobileGL::Wire::ResyncDone *>(msg()) : nullptr;
  }
  const MobileGL::Wire::AuxRequest *msg_as_AuxRequest() const {
    return msg_type() == MobileGL::Wire::CtrlMsg::AuxRequest ? static_cast<const MobileGL::Wire::AuxRequest *>(msg()) : nullptr;
  }
  const MobileGL::Wire::Fatal *msg_as_Fatal() const {
    return msg_type() == MobileGL::Wire::CtrlMsg::Fatal ? static_cast<const MobileGL::Wire::Fatal *>(msg()) : nullptr;
  }
  const MobileGL::Wire::LogLine *msg_as_LogLine() const {
    return msg_type() == MobileGL::Wire::CtrlMsg::LogLine ? static_cast<const MobileGL::Wire::LogLine *>(msg()) : nullptr;
  }
  const MobileGL::Wire::Refuse *msg_as_Refuse() const {
    return msg_type() == MobileGL::Wire::CtrlMsg::Refuse ? static_cast<const MobileGL::Wire::Refuse *>(msg()) : nullptr;
  }
  const MobileGL::Wire::LogFlush *msg_as_LogFlush() const {
    return msg_type() == MobileGL::Wire::CtrlMsg::LogFlush ? static_cast<const MobileGL::Wire::LogFlush *>(msg()) : nullptr;
  }
  const MobileGL::Wire::DataBind *msg_as_DataBind() const {
    return msg_type() == MobileGL::Wire::CtrlMsg::DataBind ? static_cast<const MobileGL::Wire::DataBind *>(msg()) : nullptr;
  }
  const MobileGL::Wire::SurfaceProgress *msg_as_SurfaceProgress() const {
    return msg_type() == MobileGL::Wire::CtrlMsg::SurfaceProgress ? static_cast<const MobileGL::Wire::SurfaceProgress *>(msg()) : nullptr;
  }
  const MobileGL::Wire::PairBind *msg_as_PairBind() const {
    return msg_type() == MobileGL::Wire::CtrlMsg::PairBind ? static_cast<const MobileGL::Wire::PairBind *>(msg()) : nullptr;
  }
  template <bool B = false>
  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_MSG_TYPE, 1) &&
           VerifyOffset(verifier, VT_MSG) &&
           VerifyCtrlMsg(verifier, msg(), msg_type()) &&
           verifier.EndTable();
  }
};

template<> inline const MobileGL::Wire::Hello *CtrlEnvelope::msg_as<MobileGL::Wire::Hello>() const {
  return msg_as_Hello();
}

template<> inline const MobileGL::Wire::Welcome *CtrlEnvelope::msg_as<MobileGL::Wire::Welcome>() const {
  return msg_as_Welcome();
}

template<> inline const MobileGL::Wire::CapsSnapshot *CtrlEnvelope::msg_as<MobileGL::Wire::CapsSnapshot>() const {
  return msg_as_CapsSnapshot();
}

template<> inline const MobileGL::Wire::SurfaceOp *CtrlEnvelope::msg_as<MobileGL::Wire::SurfaceOp>() const {
  return msg_as_SurfaceOp();
}

template<> inline const MobileGL::Wire::SurfaceReply *CtrlEnvelope::msg_as<MobileGL::Wire::SurfaceReply>() const {
  return msg_as_SurfaceReply();
}

template<> inline const MobileGL::Wire::ResyncRequest *CtrlEnvelope::msg_as<MobileGL::Wire::ResyncRequest>() const {
  return msg_as_ResyncRequest();
}

template<> inline const MobileGL::Wire::ResyncDone *CtrlEnvelope::msg_as<MobileGL::Wire::ResyncDone>() const {
  return msg_as_ResyncDone();
}

template<> inline const MobileGL::Wire::AuxRequest *CtrlEnvelope::msg_as<MobileGL::Wire::AuxRequest>() const {
  return msg_as_AuxRequest();
}

template<> inline const MobileGL::Wire::Fatal *CtrlEnvelope::msg_as<MobileGL::Wire::Fatal>() const {
  return msg_as_Fatal();
}

template<> inline const MobileGL::Wire::LogLine *CtrlEnvelope::msg_as<MobileGL::Wire::LogLine>() const {
  return msg_as_LogLine();
}

template<> inline const MobileGL::Wire::Refuse *CtrlEnvelope::msg_as<MobileGL::Wire::Refuse>() const {
  return msg_as_Refuse();
}

template<> inline const MobileGL::Wire::LogFlush *CtrlEnvelope::msg_as<MobileGL::Wire::LogFlush>() const {
  return msg_as_LogFlush();
}

template<> inline const MobileGL::Wire::DataBind *CtrlEnvelope::msg_as<MobileGL::Wire::DataBind>() const {
  return msg_as_DataBind();
}

template<> inline const MobileGL::Wire::SurfaceProgress *CtrlEnvelope::msg_as<MobileGL::Wire::SurfaceProgress>() const {
  return msg_as_SurfaceProgress();
}

template<> inline const MobileGL::Wire::PairBind *CtrlEnvelope::msg_as<MobileGL::Wire::PairBind>() const {
  return msg_as_PairBind();
}

struct CtrlEnvelopeBuilder {
  typedef CtrlEnvelope Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_msg_type(MobileGL::Wire::CtrlMsg msg_type) {
    fbb_.AddElement<uint8_t>(CtrlEnvelope::VT_MSG_TYPE, static_cast<uint8_t>(msg_type), 0);
  }
  void add_msg(::flatbuffers::Offset<void> msg) {
    fbb_.AddOffset(CtrlEnvelope::VT_MSG, msg);
  }
  explicit CtrlEnvelopeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CtrlEnvelope> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CtrlEnvelope>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<CtrlEnvelope> CreateCtrlEnvelope(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    MobileGL::Wire::CtrlMsg msg_type = MobileGL::Wire::CtrlMsg::NONE,
    ::flatbuffers::Offset<void> msg = 0) {
  CtrlEnvelopeBuilder builder_(_fbb);
  builder_.add_msg(msg);
  builder_.add_msg_type(msg_type);
  return builder_.Finish();
}

struct CtrlEnvelope::Traits {
  using type = CtrlEnvelope;
  static auto constexpr Create = CreateCtrlEnvelope;
};

template <bool B>
inline bool VerifyCtrlMsg(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, CtrlMsg type) {
  switch (type) {
    case CtrlMsg::NONE: {
      return true;
    }
    case CtrlMsg::Hello: {
      auto ptr = reinterpret_cast<const MobileGL::Wire::Hello *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CtrlMsg::Welcome: {
      auto ptr = reinterpret_cast<const MobileGL::Wire::Welcome *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CtrlMsg::CapsSnapshot: {
      auto ptr = reinterpret_cast<const MobileGL::Wire::CapsSnapshot *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CtrlMsg::SurfaceOp: {
      auto ptr = reinterpret_cast<const MobileGL::Wire::SurfaceOp *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CtrlMsg::SurfaceReply: {
      auto ptr = reinterpret_cast<const MobileGL::Wire::SurfaceReply *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CtrlMsg::ResyncRequest: {
      auto ptr = reinterpret_cast<const MobileGL::Wire::ResyncRequest *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CtrlMsg::ResyncDone: {
      auto ptr = reinterpret_cast<const MobileGL::Wire::ResyncDone *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CtrlMsg::AuxRequest: {
      auto ptr = reinterpret_cast<const MobileGL::Wire::AuxRequest *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CtrlMsg::Fatal: {
      auto ptr = reinterpret_cast<const MobileGL::Wire::Fatal *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CtrlMsg::LogLine: {
      auto ptr = reinterpret_cast<const MobileGL::Wire::LogLine *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CtrlMsg::Refuse: {
      auto ptr = reinterpret_cast<const MobileGL::Wire::Refuse *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CtrlMsg::LogFlush: {
      auto ptr = reinterpret_cast<const MobileGL::Wire::LogFlush *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CtrlMsg::DataBind: {
      auto ptr = reinterpret_cast<const MobileGL::Wire::DataBind *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CtrlMsg::SurfaceProgress: {
      auto ptr = reinterpret_cast<const MobileGL::Wire::SurfaceProgress *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CtrlMsg::PairBind: {
      auto ptr = reinterpret_cast<const MobileGL::Wire::PairBind *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}

template <bool B>
inline bool VerifyCtrlMsgVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<CtrlMsg> *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 (!VerifyCtrlMsg(
        verifier,  values->Get(i), types->GetEnum<CtrlMsg>(i))) {
      return false;
    }
  }
  return true;
}

inline const MobileGL::Wire::CtrlEnvelope *GetCtrlEnvelope(const void *buf) {
  return ::flatbuffers::GetRoot<MobileGL::Wire::CtrlEnvelope>(buf);
}

inline const MobileGL::Wire::CtrlEnvelope *GetSizePrefixedCtrlEnvelope(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<MobileGL::Wire::CtrlEnvelope>(buf);
}

inline const char *CtrlEnvelopeIdentifier() {
  return "MGLC";
}

inline bool CtrlEnvelopeBufferHasIdentifier(const void *buf) {
  return ::flatbuffers::BufferHasIdentifier(
      buf, CtrlEnvelopeIdentifier());
}

inline bool SizePrefixedCtrlEnvelopeBufferHasIdentifier(const void *buf) {
  return ::flatbuffers::BufferHasIdentifier(
      buf, CtrlEnvelopeIdentifier(), true);
}

template <bool B = false>
inline bool VerifyCtrlEnvelopeBuffer(
    ::flatbuffers::VerifierTemplate<B> &verifier) {
  return verifier.template VerifyBuffer<MobileGL::Wire::CtrlEnvelope>(CtrlEnvelopeIdentifier());
}

template <bool B = false>
inline bool VerifySizePrefixedCtrlEnvelopeBuffer(
    ::flatbuffers::VerifierTemplate<B> &verifier) {
  return verifier.template VerifySizePrefixedBuffer<MobileGL::Wire::CtrlEnvelope>(CtrlEnvelopeIdentifier());
}

inline void FinishCtrlEnvelopeBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<MobileGL::Wire::CtrlEnvelope> root) {
  fbb.Finish(root, CtrlEnvelopeIdentifier());
}

inline void FinishSizePrefixedCtrlEnvelopeBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<MobileGL::Wire::CtrlEnvelope> root) {
  fbb.FinishSizePrefixed(root, CtrlEnvelopeIdentifier());
}

}  // namespace Wire
}  // namespace MobileGL

#endif  // FLATBUFFERS_GENERATED_PROTOCOL_MOBILEGL_WIRE_H_