// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: NoneOtxDiagApiCommandsPb.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_NoneOtxDiagApiCommandsPb_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_NoneOtxDiagApiCommandsPb_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3010000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3010001 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/map.h>  // IWYU pragma: export
#include <google/protobuf/map_entry.h>
#include <google/protobuf/map_field_inl.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "DiagComDataModelsPb.pb.h"
#include "ComInterfaceDataModelsPb.pb.h"
#include "BusMonitoringDataModelsPb.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_NoneOtxDiagApiCommandsPb_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_NoneOtxDiagApiCommandsPb_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[13]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_NoneOtxDiagApiCommandsPb_2eproto;
namespace OpenTestSystem {
namespace OtxDiagManager {
namespace Common {
class GetDbEcuMemOfFlashSessionPb;
class GetDbEcuMemOfFlashSessionPbDefaultTypeInternal;
extern GetDbEcuMemOfFlashSessionPbDefaultTypeInternal _GetDbEcuMemOfFlashSessionPb_default_instance_;
class GetIgnitionStatePb;
class GetIgnitionStatePbDefaultTypeInternal;
extern GetIgnitionStatePbDefaultTypeInternal _GetIgnitionStatePb_default_instance_;
class GetInterfaceFirmwareNamePb;
class GetInterfaceFirmwareNamePbDefaultTypeInternal;
extern GetInterfaceFirmwareNamePbDefaultTypeInternal _GetInterfaceFirmwareNamePb_default_instance_;
class GetInterfaceFirmwareVersionPb;
class GetInterfaceFirmwareVersionPbDefaultTypeInternal;
extern GetInterfaceFirmwareVersionPbDefaultTypeInternal _GetInterfaceFirmwareVersionPb_default_instance_;
class GetInterfaceHardwareNamePb;
class GetInterfaceHardwareNamePbDefaultTypeInternal;
extern GetInterfaceHardwareNamePbDefaultTypeInternal _GetInterfaceHardwareNamePb_default_instance_;
class GetInterfaceHardwareSerialNumberPb;
class GetInterfaceHardwareSerialNumberPbDefaultTypeInternal;
extern GetInterfaceHardwareSerialNumberPbDefaultTypeInternal _GetInterfaceHardwareSerialNumberPb_default_instance_;
class ReleaseDiagServicePb;
class ReleaseDiagServicePbDefaultTypeInternal;
extern ReleaseDiagServicePbDefaultTypeInternal _ReleaseDiagServicePb_default_instance_;
class ReleaseMonitoringPb;
class ReleaseMonitoringPbDefaultTypeInternal;
extern ReleaseMonitoringPbDefaultTypeInternal _ReleaseMonitoringPb_default_instance_;
class SetPreferredInterfacePb;
class SetPreferredInterfacePbDefaultTypeInternal;
extern SetPreferredInterfacePbDefaultTypeInternal _SetPreferredInterfacePb_default_instance_;
class StartDiagLoggingPb;
class StartDiagLoggingPbDefaultTypeInternal;
extern StartDiagLoggingPbDefaultTypeInternal _StartDiagLoggingPb_default_instance_;
class StartDiagLoggingPb_HeaderMapEntry_DoNotUse;
class StartDiagLoggingPb_HeaderMapEntry_DoNotUseDefaultTypeInternal;
extern StartDiagLoggingPb_HeaderMapEntry_DoNotUseDefaultTypeInternal _StartDiagLoggingPb_HeaderMapEntry_DoNotUse_default_instance_;
class StopDiagLoggingPb;
class StopDiagLoggingPbDefaultTypeInternal;
extern StopDiagLoggingPbDefaultTypeInternal _StopDiagLoggingPb_default_instance_;
class SwitchPduApiPb;
class SwitchPduApiPbDefaultTypeInternal;
extern SwitchPduApiPbDefaultTypeInternal _SwitchPduApiPb_default_instance_;
}  // namespace Common
}  // namespace OtxDiagManager
}  // namespace OpenTestSystem
PROTOBUF_NAMESPACE_OPEN
template<> ::OpenTestSystem::OtxDiagManager::Common::GetDbEcuMemOfFlashSessionPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetDbEcuMemOfFlashSessionPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetIgnitionStatePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetIgnitionStatePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetInterfaceFirmwareNamePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetInterfaceFirmwareNamePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetInterfaceFirmwareVersionPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetInterfaceFirmwareVersionPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetInterfaceHardwareNamePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetInterfaceHardwareNamePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetInterfaceHardwareSerialNumberPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetInterfaceHardwareSerialNumberPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::ReleaseDiagServicePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::ReleaseDiagServicePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::ReleaseMonitoringPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::ReleaseMonitoringPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::SetPreferredInterfacePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::SetPreferredInterfacePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::StartDiagLoggingPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::StartDiagLoggingPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::StartDiagLoggingPb_HeaderMapEntry_DoNotUse* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::StartDiagLoggingPb_HeaderMapEntry_DoNotUse>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::StopDiagLoggingPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::StopDiagLoggingPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::SwitchPduApiPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::SwitchPduApiPb>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace OpenTestSystem {
namespace OtxDiagManager {
namespace Common {

enum LogLevelsPb : int {
  OFF = 0,
  HEADER = 1,
  PDU = 2,
  SHORTNAMES = 3,
  ALL = 4,
  LogLevelsPb_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  LogLevelsPb_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool LogLevelsPb_IsValid(int value);
constexpr LogLevelsPb LogLevelsPb_MIN = OFF;
constexpr LogLevelsPb LogLevelsPb_MAX = ALL;
constexpr int LogLevelsPb_ARRAYSIZE = LogLevelsPb_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LogLevelsPb_descriptor();
template<typename T>
inline const std::string& LogLevelsPb_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LogLevelsPb>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LogLevelsPb_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LogLevelsPb_descriptor(), enum_t_value);
}
inline bool LogLevelsPb_Parse(
    const std::string& name, LogLevelsPb* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LogLevelsPb>(
    LogLevelsPb_descriptor(), name, value);
}
// ===================================================================

class SwitchPduApiPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.SwitchPduApiPb) */ {
 public:
  SwitchPduApiPb();
  virtual ~SwitchPduApiPb();

  SwitchPduApiPb(const SwitchPduApiPb& from);
  SwitchPduApiPb(SwitchPduApiPb&& from) noexcept
    : SwitchPduApiPb() {
    *this = ::std::move(from);
  }

  inline SwitchPduApiPb& operator=(const SwitchPduApiPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline SwitchPduApiPb& operator=(SwitchPduApiPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SwitchPduApiPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SwitchPduApiPb* internal_default_instance() {
    return reinterpret_cast<const SwitchPduApiPb*>(
               &_SwitchPduApiPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(SwitchPduApiPb& a, SwitchPduApiPb& b) {
    a.Swap(&b);
  }
  inline void Swap(SwitchPduApiPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline SwitchPduApiPb* New() const final {
    return CreateMaybeMessage<SwitchPduApiPb>(nullptr);
  }

  SwitchPduApiPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SwitchPduApiPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SwitchPduApiPb& from);
  void MergeFrom(const SwitchPduApiPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SwitchPduApiPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.SwitchPduApiPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto);
    return ::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPduApiShortnameFieldNumber = 1,
  };
  // string PduApiShortname = 1;
  void clear_pduapishortname();
  const std::string& pduapishortname() const;
  void set_pduapishortname(const std::string& value);
  void set_pduapishortname(std::string&& value);
  void set_pduapishortname(const char* value);
  void set_pduapishortname(const char* value, size_t size);
  std::string* mutable_pduapishortname();
  std::string* release_pduapishortname();
  void set_allocated_pduapishortname(std::string* pduapishortname);
  private:
  const std::string& _internal_pduapishortname() const;
  void _internal_set_pduapishortname(const std::string& value);
  std::string* _internal_mutable_pduapishortname();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.SwitchPduApiPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pduapishortname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_NoneOtxDiagApiCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class ReleaseDiagServicePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.ReleaseDiagServicePb) */ {
 public:
  ReleaseDiagServicePb();
  virtual ~ReleaseDiagServicePb();

  ReleaseDiagServicePb(const ReleaseDiagServicePb& from);
  ReleaseDiagServicePb(ReleaseDiagServicePb&& from) noexcept
    : ReleaseDiagServicePb() {
    *this = ::std::move(from);
  }

  inline ReleaseDiagServicePb& operator=(const ReleaseDiagServicePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReleaseDiagServicePb& operator=(ReleaseDiagServicePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ReleaseDiagServicePb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReleaseDiagServicePb* internal_default_instance() {
    return reinterpret_cast<const ReleaseDiagServicePb*>(
               &_ReleaseDiagServicePb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(ReleaseDiagServicePb& a, ReleaseDiagServicePb& b) {
    a.Swap(&b);
  }
  inline void Swap(ReleaseDiagServicePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ReleaseDiagServicePb* New() const final {
    return CreateMaybeMessage<ReleaseDiagServicePb>(nullptr);
  }

  ReleaseDiagServicePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ReleaseDiagServicePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ReleaseDiagServicePb& from);
  void MergeFrom(const ReleaseDiagServicePb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReleaseDiagServicePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.ReleaseDiagServicePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto);
    return ::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDiagServiceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
  bool has_diagservice() const;
  private:
  bool _internal_has_diagservice() const;
  public:
  void clear_diagservice();
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* release_diagservice();
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* mutable_diagservice();
  void set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& _internal_diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* _internal_mutable_diagservice();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.ReleaseDiagServicePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_NoneOtxDiagApiCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class ReleaseMonitoringPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.ReleaseMonitoringPb) */ {
 public:
  ReleaseMonitoringPb();
  virtual ~ReleaseMonitoringPb();

  ReleaseMonitoringPb(const ReleaseMonitoringPb& from);
  ReleaseMonitoringPb(ReleaseMonitoringPb&& from) noexcept
    : ReleaseMonitoringPb() {
    *this = ::std::move(from);
  }

  inline ReleaseMonitoringPb& operator=(const ReleaseMonitoringPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReleaseMonitoringPb& operator=(ReleaseMonitoringPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ReleaseMonitoringPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReleaseMonitoringPb* internal_default_instance() {
    return reinterpret_cast<const ReleaseMonitoringPb*>(
               &_ReleaseMonitoringPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(ReleaseMonitoringPb& a, ReleaseMonitoringPb& b) {
    a.Swap(&b);
  }
  inline void Swap(ReleaseMonitoringPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ReleaseMonitoringPb* New() const final {
    return CreateMaybeMessage<ReleaseMonitoringPb>(nullptr);
  }

  ReleaseMonitoringPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ReleaseMonitoringPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ReleaseMonitoringPb& from);
  void MergeFrom(const ReleaseMonitoringPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReleaseMonitoringPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.ReleaseMonitoringPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto);
    return ::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kBusMonitorFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DBusMonitorPb BusMonitor = 1;
  bool has_busmonitor() const;
  private:
  bool _internal_has_busmonitor() const;
  public:
  void clear_busmonitor();
  const ::OpenTestSystem::OtxDiagManager::Common::DBusMonitorPb& busmonitor() const;
  ::OpenTestSystem::OtxDiagManager::Common::DBusMonitorPb* release_busmonitor();
  ::OpenTestSystem::OtxDiagManager::Common::DBusMonitorPb* mutable_busmonitor();
  void set_allocated_busmonitor(::OpenTestSystem::OtxDiagManager::Common::DBusMonitorPb* busmonitor);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DBusMonitorPb& _internal_busmonitor() const;
  ::OpenTestSystem::OtxDiagManager::Common::DBusMonitorPb* _internal_mutable_busmonitor();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.ReleaseMonitoringPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DBusMonitorPb* busmonitor_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_NoneOtxDiagApiCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class SetPreferredInterfacePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.SetPreferredInterfacePb) */ {
 public:
  SetPreferredInterfacePb();
  virtual ~SetPreferredInterfacePb();

  SetPreferredInterfacePb(const SetPreferredInterfacePb& from);
  SetPreferredInterfacePb(SetPreferredInterfacePb&& from) noexcept
    : SetPreferredInterfacePb() {
    *this = ::std::move(from);
  }

  inline SetPreferredInterfacePb& operator=(const SetPreferredInterfacePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline SetPreferredInterfacePb& operator=(SetPreferredInterfacePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SetPreferredInterfacePb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SetPreferredInterfacePb* internal_default_instance() {
    return reinterpret_cast<const SetPreferredInterfacePb*>(
               &_SetPreferredInterfacePb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(SetPreferredInterfacePb& a, SetPreferredInterfacePb& b) {
    a.Swap(&b);
  }
  inline void Swap(SetPreferredInterfacePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline SetPreferredInterfacePb* New() const final {
    return CreateMaybeMessage<SetPreferredInterfacePb>(nullptr);
  }

  SetPreferredInterfacePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SetPreferredInterfacePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SetPreferredInterfacePb& from);
  void MergeFrom(const SetPreferredInterfacePb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SetPreferredInterfacePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.SetPreferredInterfacePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto);
    return ::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kComInterfaceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
  bool has_cominterface() const;
  private:
  bool _internal_has_cominterface() const;
  public:
  void clear_cominterface();
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* release_cominterface();
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* mutable_cominterface();
  void set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& _internal_cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* _internal_mutable_cominterface();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.SetPreferredInterfacePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_NoneOtxDiagApiCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetIgnitionStatePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetIgnitionStatePb) */ {
 public:
  GetIgnitionStatePb();
  virtual ~GetIgnitionStatePb();

  GetIgnitionStatePb(const GetIgnitionStatePb& from);
  GetIgnitionStatePb(GetIgnitionStatePb&& from) noexcept
    : GetIgnitionStatePb() {
    *this = ::std::move(from);
  }

  inline GetIgnitionStatePb& operator=(const GetIgnitionStatePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetIgnitionStatePb& operator=(GetIgnitionStatePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetIgnitionStatePb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetIgnitionStatePb* internal_default_instance() {
    return reinterpret_cast<const GetIgnitionStatePb*>(
               &_GetIgnitionStatePb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(GetIgnitionStatePb& a, GetIgnitionStatePb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetIgnitionStatePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetIgnitionStatePb* New() const final {
    return CreateMaybeMessage<GetIgnitionStatePb>(nullptr);
  }

  GetIgnitionStatePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetIgnitionStatePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetIgnitionStatePb& from);
  void MergeFrom(const GetIgnitionStatePb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetIgnitionStatePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetIgnitionStatePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto);
    return ::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kClampNameFieldNumber = 1,
  };
  // string ClampName = 1;
  void clear_clampname();
  const std::string& clampname() const;
  void set_clampname(const std::string& value);
  void set_clampname(std::string&& value);
  void set_clampname(const char* value);
  void set_clampname(const char* value, size_t size);
  std::string* mutable_clampname();
  std::string* release_clampname();
  void set_allocated_clampname(std::string* clampname);
  private:
  const std::string& _internal_clampname() const;
  void _internal_set_clampname(const std::string& value);
  std::string* _internal_mutable_clampname();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetIgnitionStatePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr clampname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_NoneOtxDiagApiCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class StartDiagLoggingPb_HeaderMapEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<StartDiagLoggingPb_HeaderMapEntry_DoNotUse, 
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    0 > {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<StartDiagLoggingPb_HeaderMapEntry_DoNotUse, 
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    0 > SuperType;
  StartDiagLoggingPb_HeaderMapEntry_DoNotUse();
  StartDiagLoggingPb_HeaderMapEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const StartDiagLoggingPb_HeaderMapEntry_DoNotUse& other);
  static const StartDiagLoggingPb_HeaderMapEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const StartDiagLoggingPb_HeaderMapEntry_DoNotUse*>(&_StartDiagLoggingPb_HeaderMapEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), s->size(), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.HeaderMapEntry.key");
 }
  static bool ValidateValue(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), s->size(), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.HeaderMapEntry.value");
 }
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto);
    return ::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto.file_level_metadata[5];
  }

  public:
};

// -------------------------------------------------------------------

class StartDiagLoggingPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb) */ {
 public:
  StartDiagLoggingPb();
  virtual ~StartDiagLoggingPb();

  StartDiagLoggingPb(const StartDiagLoggingPb& from);
  StartDiagLoggingPb(StartDiagLoggingPb&& from) noexcept
    : StartDiagLoggingPb() {
    *this = ::std::move(from);
  }

  inline StartDiagLoggingPb& operator=(const StartDiagLoggingPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline StartDiagLoggingPb& operator=(StartDiagLoggingPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const StartDiagLoggingPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StartDiagLoggingPb* internal_default_instance() {
    return reinterpret_cast<const StartDiagLoggingPb*>(
               &_StartDiagLoggingPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(StartDiagLoggingPb& a, StartDiagLoggingPb& b) {
    a.Swap(&b);
  }
  inline void Swap(StartDiagLoggingPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline StartDiagLoggingPb* New() const final {
    return CreateMaybeMessage<StartDiagLoggingPb>(nullptr);
  }

  StartDiagLoggingPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<StartDiagLoggingPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const StartDiagLoggingPb& from);
  void MergeFrom(const StartDiagLoggingPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StartDiagLoggingPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto);
    return ::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------


  // accessors -------------------------------------------------------

  enum : int {
    kHeaderMapFieldNumber = 2,
    kTestObjectNameFieldNumber = 1,
    kLogFolderFieldNumber = 5,
    kIsAsyncFieldNumber = 3,
    kLogLevelFieldNumber = 4,
  };
  // map<string, string> HeaderMap = 2;
  int headermap_size() const;
  private:
  int _internal_headermap_size() const;
  public:
  void clear_headermap();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      _internal_headermap() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      _internal_mutable_headermap();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      headermap() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      mutable_headermap();

  // string TestObjectName = 1;
  void clear_testobjectname();
  const std::string& testobjectname() const;
  void set_testobjectname(const std::string& value);
  void set_testobjectname(std::string&& value);
  void set_testobjectname(const char* value);
  void set_testobjectname(const char* value, size_t size);
  std::string* mutable_testobjectname();
  std::string* release_testobjectname();
  void set_allocated_testobjectname(std::string* testobjectname);
  private:
  const std::string& _internal_testobjectname() const;
  void _internal_set_testobjectname(const std::string& value);
  std::string* _internal_mutable_testobjectname();
  public:

  // string LogFolder = 5;
  void clear_logfolder();
  const std::string& logfolder() const;
  void set_logfolder(const std::string& value);
  void set_logfolder(std::string&& value);
  void set_logfolder(const char* value);
  void set_logfolder(const char* value, size_t size);
  std::string* mutable_logfolder();
  std::string* release_logfolder();
  void set_allocated_logfolder(std::string* logfolder);
  private:
  const std::string& _internal_logfolder() const;
  void _internal_set_logfolder(const std::string& value);
  std::string* _internal_mutable_logfolder();
  public:

  // bool IsAsync = 3;
  void clear_isasync();
  bool isasync() const;
  void set_isasync(bool value);
  private:
  bool _internal_isasync() const;
  void _internal_set_isasync(bool value);
  public:

  // .OpenTestSystem.OtxDiagManager.Common.LogLevelsPb LogLevel = 4;
  void clear_loglevel();
  ::OpenTestSystem::OtxDiagManager::Common::LogLevelsPb loglevel() const;
  void set_loglevel(::OpenTestSystem::OtxDiagManager::Common::LogLevelsPb value);
  private:
  ::OpenTestSystem::OtxDiagManager::Common::LogLevelsPb _internal_loglevel() const;
  void _internal_set_loglevel(::OpenTestSystem::OtxDiagManager::Common::LogLevelsPb value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      StartDiagLoggingPb_HeaderMapEntry_DoNotUse,
      std::string, std::string,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      0 > headermap_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr testobjectname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logfolder_;
  bool isasync_;
  int loglevel_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_NoneOtxDiagApiCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class StopDiagLoggingPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.StopDiagLoggingPb) */ {
 public:
  StopDiagLoggingPb();
  virtual ~StopDiagLoggingPb();

  StopDiagLoggingPb(const StopDiagLoggingPb& from);
  StopDiagLoggingPb(StopDiagLoggingPb&& from) noexcept
    : StopDiagLoggingPb() {
    *this = ::std::move(from);
  }

  inline StopDiagLoggingPb& operator=(const StopDiagLoggingPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline StopDiagLoggingPb& operator=(StopDiagLoggingPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const StopDiagLoggingPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StopDiagLoggingPb* internal_default_instance() {
    return reinterpret_cast<const StopDiagLoggingPb*>(
               &_StopDiagLoggingPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(StopDiagLoggingPb& a, StopDiagLoggingPb& b) {
    a.Swap(&b);
  }
  inline void Swap(StopDiagLoggingPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline StopDiagLoggingPb* New() const final {
    return CreateMaybeMessage<StopDiagLoggingPb>(nullptr);
  }

  StopDiagLoggingPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<StopDiagLoggingPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const StopDiagLoggingPb& from);
  void MergeFrom(const StopDiagLoggingPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StopDiagLoggingPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.StopDiagLoggingPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto);
    return ::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.StopDiagLoggingPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_NoneOtxDiagApiCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetDbEcuMemOfFlashSessionPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetDbEcuMemOfFlashSessionPb) */ {
 public:
  GetDbEcuMemOfFlashSessionPb();
  virtual ~GetDbEcuMemOfFlashSessionPb();

  GetDbEcuMemOfFlashSessionPb(const GetDbEcuMemOfFlashSessionPb& from);
  GetDbEcuMemOfFlashSessionPb(GetDbEcuMemOfFlashSessionPb&& from) noexcept
    : GetDbEcuMemOfFlashSessionPb() {
    *this = ::std::move(from);
  }

  inline GetDbEcuMemOfFlashSessionPb& operator=(const GetDbEcuMemOfFlashSessionPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetDbEcuMemOfFlashSessionPb& operator=(GetDbEcuMemOfFlashSessionPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetDbEcuMemOfFlashSessionPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetDbEcuMemOfFlashSessionPb* internal_default_instance() {
    return reinterpret_cast<const GetDbEcuMemOfFlashSessionPb*>(
               &_GetDbEcuMemOfFlashSessionPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(GetDbEcuMemOfFlashSessionPb& a, GetDbEcuMemOfFlashSessionPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetDbEcuMemOfFlashSessionPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetDbEcuMemOfFlashSessionPb* New() const final {
    return CreateMaybeMessage<GetDbEcuMemOfFlashSessionPb>(nullptr);
  }

  GetDbEcuMemOfFlashSessionPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetDbEcuMemOfFlashSessionPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetDbEcuMemOfFlashSessionPb& from);
  void MergeFrom(const GetDbEcuMemOfFlashSessionPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetDbEcuMemOfFlashSessionPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetDbEcuMemOfFlashSessionPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto);
    return ::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlashSessionNameFieldNumber = 1,
  };
  // string FlashSessionName = 1;
  void clear_flashsessionname();
  const std::string& flashsessionname() const;
  void set_flashsessionname(const std::string& value);
  void set_flashsessionname(std::string&& value);
  void set_flashsessionname(const char* value);
  void set_flashsessionname(const char* value, size_t size);
  std::string* mutable_flashsessionname();
  std::string* release_flashsessionname();
  void set_allocated_flashsessionname(std::string* flashsessionname);
  private:
  const std::string& _internal_flashsessionname() const;
  void _internal_set_flashsessionname(const std::string& value);
  std::string* _internal_mutable_flashsessionname();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetDbEcuMemOfFlashSessionPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr flashsessionname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_NoneOtxDiagApiCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetInterfaceFirmwareVersionPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareVersionPb) */ {
 public:
  GetInterfaceFirmwareVersionPb();
  virtual ~GetInterfaceFirmwareVersionPb();

  GetInterfaceFirmwareVersionPb(const GetInterfaceFirmwareVersionPb& from);
  GetInterfaceFirmwareVersionPb(GetInterfaceFirmwareVersionPb&& from) noexcept
    : GetInterfaceFirmwareVersionPb() {
    *this = ::std::move(from);
  }

  inline GetInterfaceFirmwareVersionPb& operator=(const GetInterfaceFirmwareVersionPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetInterfaceFirmwareVersionPb& operator=(GetInterfaceFirmwareVersionPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetInterfaceFirmwareVersionPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetInterfaceFirmwareVersionPb* internal_default_instance() {
    return reinterpret_cast<const GetInterfaceFirmwareVersionPb*>(
               &_GetInterfaceFirmwareVersionPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(GetInterfaceFirmwareVersionPb& a, GetInterfaceFirmwareVersionPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetInterfaceFirmwareVersionPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetInterfaceFirmwareVersionPb* New() const final {
    return CreateMaybeMessage<GetInterfaceFirmwareVersionPb>(nullptr);
  }

  GetInterfaceFirmwareVersionPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetInterfaceFirmwareVersionPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetInterfaceFirmwareVersionPb& from);
  void MergeFrom(const GetInterfaceFirmwareVersionPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetInterfaceFirmwareVersionPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareVersionPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto);
    return ::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kInterfaceShortNameFieldNumber = 1,
  };
  // string InterfaceShortName = 1;
  void clear_interfaceshortname();
  const std::string& interfaceshortname() const;
  void set_interfaceshortname(const std::string& value);
  void set_interfaceshortname(std::string&& value);
  void set_interfaceshortname(const char* value);
  void set_interfaceshortname(const char* value, size_t size);
  std::string* mutable_interfaceshortname();
  std::string* release_interfaceshortname();
  void set_allocated_interfaceshortname(std::string* interfaceshortname);
  private:
  const std::string& _internal_interfaceshortname() const;
  void _internal_set_interfaceshortname(const std::string& value);
  std::string* _internal_mutable_interfaceshortname();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareVersionPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr interfaceshortname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_NoneOtxDiagApiCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetInterfaceFirmwareNamePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareNamePb) */ {
 public:
  GetInterfaceFirmwareNamePb();
  virtual ~GetInterfaceFirmwareNamePb();

  GetInterfaceFirmwareNamePb(const GetInterfaceFirmwareNamePb& from);
  GetInterfaceFirmwareNamePb(GetInterfaceFirmwareNamePb&& from) noexcept
    : GetInterfaceFirmwareNamePb() {
    *this = ::std::move(from);
  }

  inline GetInterfaceFirmwareNamePb& operator=(const GetInterfaceFirmwareNamePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetInterfaceFirmwareNamePb& operator=(GetInterfaceFirmwareNamePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetInterfaceFirmwareNamePb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetInterfaceFirmwareNamePb* internal_default_instance() {
    return reinterpret_cast<const GetInterfaceFirmwareNamePb*>(
               &_GetInterfaceFirmwareNamePb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(GetInterfaceFirmwareNamePb& a, GetInterfaceFirmwareNamePb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetInterfaceFirmwareNamePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetInterfaceFirmwareNamePb* New() const final {
    return CreateMaybeMessage<GetInterfaceFirmwareNamePb>(nullptr);
  }

  GetInterfaceFirmwareNamePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetInterfaceFirmwareNamePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetInterfaceFirmwareNamePb& from);
  void MergeFrom(const GetInterfaceFirmwareNamePb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetInterfaceFirmwareNamePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareNamePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto);
    return ::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kInterfaceShortNameFieldNumber = 1,
  };
  // string InterfaceShortName = 1;
  void clear_interfaceshortname();
  const std::string& interfaceshortname() const;
  void set_interfaceshortname(const std::string& value);
  void set_interfaceshortname(std::string&& value);
  void set_interfaceshortname(const char* value);
  void set_interfaceshortname(const char* value, size_t size);
  std::string* mutable_interfaceshortname();
  std::string* release_interfaceshortname();
  void set_allocated_interfaceshortname(std::string* interfaceshortname);
  private:
  const std::string& _internal_interfaceshortname() const;
  void _internal_set_interfaceshortname(const std::string& value);
  std::string* _internal_mutable_interfaceshortname();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareNamePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr interfaceshortname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_NoneOtxDiagApiCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetInterfaceHardwareNamePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareNamePb) */ {
 public:
  GetInterfaceHardwareNamePb();
  virtual ~GetInterfaceHardwareNamePb();

  GetInterfaceHardwareNamePb(const GetInterfaceHardwareNamePb& from);
  GetInterfaceHardwareNamePb(GetInterfaceHardwareNamePb&& from) noexcept
    : GetInterfaceHardwareNamePb() {
    *this = ::std::move(from);
  }

  inline GetInterfaceHardwareNamePb& operator=(const GetInterfaceHardwareNamePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetInterfaceHardwareNamePb& operator=(GetInterfaceHardwareNamePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetInterfaceHardwareNamePb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetInterfaceHardwareNamePb* internal_default_instance() {
    return reinterpret_cast<const GetInterfaceHardwareNamePb*>(
               &_GetInterfaceHardwareNamePb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(GetInterfaceHardwareNamePb& a, GetInterfaceHardwareNamePb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetInterfaceHardwareNamePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetInterfaceHardwareNamePb* New() const final {
    return CreateMaybeMessage<GetInterfaceHardwareNamePb>(nullptr);
  }

  GetInterfaceHardwareNamePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetInterfaceHardwareNamePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetInterfaceHardwareNamePb& from);
  void MergeFrom(const GetInterfaceHardwareNamePb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetInterfaceHardwareNamePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareNamePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto);
    return ::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kInterfaceShortNameFieldNumber = 1,
  };
  // string InterfaceShortName = 1;
  void clear_interfaceshortname();
  const std::string& interfaceshortname() const;
  void set_interfaceshortname(const std::string& value);
  void set_interfaceshortname(std::string&& value);
  void set_interfaceshortname(const char* value);
  void set_interfaceshortname(const char* value, size_t size);
  std::string* mutable_interfaceshortname();
  std::string* release_interfaceshortname();
  void set_allocated_interfaceshortname(std::string* interfaceshortname);
  private:
  const std::string& _internal_interfaceshortname() const;
  void _internal_set_interfaceshortname(const std::string& value);
  std::string* _internal_mutable_interfaceshortname();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareNamePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr interfaceshortname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_NoneOtxDiagApiCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetInterfaceHardwareSerialNumberPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareSerialNumberPb) */ {
 public:
  GetInterfaceHardwareSerialNumberPb();
  virtual ~GetInterfaceHardwareSerialNumberPb();

  GetInterfaceHardwareSerialNumberPb(const GetInterfaceHardwareSerialNumberPb& from);
  GetInterfaceHardwareSerialNumberPb(GetInterfaceHardwareSerialNumberPb&& from) noexcept
    : GetInterfaceHardwareSerialNumberPb() {
    *this = ::std::move(from);
  }

  inline GetInterfaceHardwareSerialNumberPb& operator=(const GetInterfaceHardwareSerialNumberPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetInterfaceHardwareSerialNumberPb& operator=(GetInterfaceHardwareSerialNumberPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GetInterfaceHardwareSerialNumberPb& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GetInterfaceHardwareSerialNumberPb* internal_default_instance() {
    return reinterpret_cast<const GetInterfaceHardwareSerialNumberPb*>(
               &_GetInterfaceHardwareSerialNumberPb_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(GetInterfaceHardwareSerialNumberPb& a, GetInterfaceHardwareSerialNumberPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetInterfaceHardwareSerialNumberPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GetInterfaceHardwareSerialNumberPb* New() const final {
    return CreateMaybeMessage<GetInterfaceHardwareSerialNumberPb>(nullptr);
  }

  GetInterfaceHardwareSerialNumberPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetInterfaceHardwareSerialNumberPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetInterfaceHardwareSerialNumberPb& from);
  void MergeFrom(const GetInterfaceHardwareSerialNumberPb& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GetInterfaceHardwareSerialNumberPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareSerialNumberPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto);
    return ::descriptor_table_NoneOtxDiagApiCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kInterfaceShortNameFieldNumber = 1,
  };
  // string InterfaceShortName = 1;
  void clear_interfaceshortname();
  const std::string& interfaceshortname() const;
  void set_interfaceshortname(const std::string& value);
  void set_interfaceshortname(std::string&& value);
  void set_interfaceshortname(const char* value);
  void set_interfaceshortname(const char* value, size_t size);
  std::string* mutable_interfaceshortname();
  std::string* release_interfaceshortname();
  void set_allocated_interfaceshortname(std::string* interfaceshortname);
  private:
  const std::string& _internal_interfaceshortname() const;
  void _internal_set_interfaceshortname(const std::string& value);
  std::string* _internal_mutable_interfaceshortname();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareSerialNumberPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr interfaceshortname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_NoneOtxDiagApiCommandsPb_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// SwitchPduApiPb

// string PduApiShortname = 1;
inline void SwitchPduApiPb::clear_pduapishortname() {
  pduapishortname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& SwitchPduApiPb::pduapishortname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SwitchPduApiPb.PduApiShortname)
  return _internal_pduapishortname();
}
inline void SwitchPduApiPb::set_pduapishortname(const std::string& value) {
  _internal_set_pduapishortname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.SwitchPduApiPb.PduApiShortname)
}
inline std::string* SwitchPduApiPb::mutable_pduapishortname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.SwitchPduApiPb.PduApiShortname)
  return _internal_mutable_pduapishortname();
}
inline const std::string& SwitchPduApiPb::_internal_pduapishortname() const {
  return pduapishortname_.GetNoArena();
}
inline void SwitchPduApiPb::_internal_set_pduapishortname(const std::string& value) {
  
  pduapishortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void SwitchPduApiPb::set_pduapishortname(std::string&& value) {
  
  pduapishortname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.SwitchPduApiPb.PduApiShortname)
}
inline void SwitchPduApiPb::set_pduapishortname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  pduapishortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.SwitchPduApiPb.PduApiShortname)
}
inline void SwitchPduApiPb::set_pduapishortname(const char* value, size_t size) {
  
  pduapishortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.SwitchPduApiPb.PduApiShortname)
}
inline std::string* SwitchPduApiPb::_internal_mutable_pduapishortname() {
  
  return pduapishortname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* SwitchPduApiPb::release_pduapishortname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.SwitchPduApiPb.PduApiShortname)
  
  return pduapishortname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void SwitchPduApiPb::set_allocated_pduapishortname(std::string* pduapishortname) {
  if (pduapishortname != nullptr) {
    
  } else {
    
  }
  pduapishortname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pduapishortname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.SwitchPduApiPb.PduApiShortname)
}

// -------------------------------------------------------------------

// ReleaseDiagServicePb

// .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
inline bool ReleaseDiagServicePb::_internal_has_diagservice() const {
  return this != internal_default_instance() && diagservice_ != nullptr;
}
inline bool ReleaseDiagServicePb::has_diagservice() const {
  return _internal_has_diagservice();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& ReleaseDiagServicePb::_internal_diagservice() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* p = diagservice_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DDiagServicePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& ReleaseDiagServicePb::diagservice() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.ReleaseDiagServicePb.DiagService)
  return _internal_diagservice();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* ReleaseDiagServicePb::release_diagservice() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.ReleaseDiagServicePb.DiagService)
  
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* temp = diagservice_;
  diagservice_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* ReleaseDiagServicePb::_internal_mutable_diagservice() {
  
  if (diagservice_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb>(GetArenaNoVirtual());
    diagservice_ = p;
  }
  return diagservice_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* ReleaseDiagServicePb::mutable_diagservice() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.ReleaseDiagServicePb.DiagService)
  return _internal_mutable_diagservice();
}
inline void ReleaseDiagServicePb::set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(diagservice_);
  }
  if (diagservice) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      diagservice = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, diagservice, submessage_arena);
    }
    
  } else {
    
  }
  diagservice_ = diagservice;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.ReleaseDiagServicePb.DiagService)
}

// -------------------------------------------------------------------

// ReleaseMonitoringPb

// .OpenTestSystem.OtxDiagManager.Common.DBusMonitorPb BusMonitor = 1;
inline bool ReleaseMonitoringPb::_internal_has_busmonitor() const {
  return this != internal_default_instance() && busmonitor_ != nullptr;
}
inline bool ReleaseMonitoringPb::has_busmonitor() const {
  return _internal_has_busmonitor();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DBusMonitorPb& ReleaseMonitoringPb::_internal_busmonitor() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DBusMonitorPb* p = busmonitor_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DBusMonitorPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DBusMonitorPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DBusMonitorPb& ReleaseMonitoringPb::busmonitor() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.ReleaseMonitoringPb.BusMonitor)
  return _internal_busmonitor();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBusMonitorPb* ReleaseMonitoringPb::release_busmonitor() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.ReleaseMonitoringPb.BusMonitor)
  
  ::OpenTestSystem::OtxDiagManager::Common::DBusMonitorPb* temp = busmonitor_;
  busmonitor_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBusMonitorPb* ReleaseMonitoringPb::_internal_mutable_busmonitor() {
  
  if (busmonitor_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DBusMonitorPb>(GetArenaNoVirtual());
    busmonitor_ = p;
  }
  return busmonitor_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DBusMonitorPb* ReleaseMonitoringPb::mutable_busmonitor() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.ReleaseMonitoringPb.BusMonitor)
  return _internal_mutable_busmonitor();
}
inline void ReleaseMonitoringPb::set_allocated_busmonitor(::OpenTestSystem::OtxDiagManager::Common::DBusMonitorPb* busmonitor) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(busmonitor_);
  }
  if (busmonitor) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      busmonitor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, busmonitor, submessage_arena);
    }
    
  } else {
    
  }
  busmonitor_ = busmonitor;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.ReleaseMonitoringPb.BusMonitor)
}

// -------------------------------------------------------------------

// SetPreferredInterfacePb

// .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
inline bool SetPreferredInterfacePb::_internal_has_cominterface() const {
  return this != internal_default_instance() && cominterface_ != nullptr;
}
inline bool SetPreferredInterfacePb::has_cominterface() const {
  return _internal_has_cominterface();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& SetPreferredInterfacePb::_internal_cominterface() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* p = cominterface_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComInterfacePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& SetPreferredInterfacePb::cominterface() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SetPreferredInterfacePb.ComInterface)
  return _internal_cominterface();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* SetPreferredInterfacePb::release_cominterface() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.SetPreferredInterfacePb.ComInterface)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* temp = cominterface_;
  cominterface_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* SetPreferredInterfacePb::_internal_mutable_cominterface() {
  
  if (cominterface_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb>(GetArenaNoVirtual());
    cominterface_ = p;
  }
  return cominterface_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* SetPreferredInterfacePb::mutable_cominterface() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.SetPreferredInterfacePb.ComInterface)
  return _internal_mutable_cominterface();
}
inline void SetPreferredInterfacePb::set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(cominterface_);
  }
  if (cominterface) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      cominterface = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cominterface, submessage_arena);
    }
    
  } else {
    
  }
  cominterface_ = cominterface;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.SetPreferredInterfacePb.ComInterface)
}

// -------------------------------------------------------------------

// GetIgnitionStatePb

// string ClampName = 1;
inline void GetIgnitionStatePb::clear_clampname() {
  clampname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetIgnitionStatePb::clampname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetIgnitionStatePb.ClampName)
  return _internal_clampname();
}
inline void GetIgnitionStatePb::set_clampname(const std::string& value) {
  _internal_set_clampname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetIgnitionStatePb.ClampName)
}
inline std::string* GetIgnitionStatePb::mutable_clampname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetIgnitionStatePb.ClampName)
  return _internal_mutable_clampname();
}
inline const std::string& GetIgnitionStatePb::_internal_clampname() const {
  return clampname_.GetNoArena();
}
inline void GetIgnitionStatePb::_internal_set_clampname(const std::string& value) {
  
  clampname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetIgnitionStatePb::set_clampname(std::string&& value) {
  
  clampname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetIgnitionStatePb.ClampName)
}
inline void GetIgnitionStatePb::set_clampname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  clampname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetIgnitionStatePb.ClampName)
}
inline void GetIgnitionStatePb::set_clampname(const char* value, size_t size) {
  
  clampname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetIgnitionStatePb.ClampName)
}
inline std::string* GetIgnitionStatePb::_internal_mutable_clampname() {
  
  return clampname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetIgnitionStatePb::release_clampname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetIgnitionStatePb.ClampName)
  
  return clampname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetIgnitionStatePb::set_allocated_clampname(std::string* clampname) {
  if (clampname != nullptr) {
    
  } else {
    
  }
  clampname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), clampname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetIgnitionStatePb.ClampName)
}

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// StartDiagLoggingPb

// string TestObjectName = 1;
inline void StartDiagLoggingPb::clear_testobjectname() {
  testobjectname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& StartDiagLoggingPb::testobjectname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.TestObjectName)
  return _internal_testobjectname();
}
inline void StartDiagLoggingPb::set_testobjectname(const std::string& value) {
  _internal_set_testobjectname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.TestObjectName)
}
inline std::string* StartDiagLoggingPb::mutable_testobjectname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.TestObjectName)
  return _internal_mutable_testobjectname();
}
inline const std::string& StartDiagLoggingPb::_internal_testobjectname() const {
  return testobjectname_.GetNoArena();
}
inline void StartDiagLoggingPb::_internal_set_testobjectname(const std::string& value) {
  
  testobjectname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void StartDiagLoggingPb::set_testobjectname(std::string&& value) {
  
  testobjectname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.TestObjectName)
}
inline void StartDiagLoggingPb::set_testobjectname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  testobjectname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.TestObjectName)
}
inline void StartDiagLoggingPb::set_testobjectname(const char* value, size_t size) {
  
  testobjectname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.TestObjectName)
}
inline std::string* StartDiagLoggingPb::_internal_mutable_testobjectname() {
  
  return testobjectname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* StartDiagLoggingPb::release_testobjectname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.TestObjectName)
  
  return testobjectname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void StartDiagLoggingPb::set_allocated_testobjectname(std::string* testobjectname) {
  if (testobjectname != nullptr) {
    
  } else {
    
  }
  testobjectname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), testobjectname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.TestObjectName)
}

// map<string, string> HeaderMap = 2;
inline int StartDiagLoggingPb::_internal_headermap_size() const {
  return headermap_.size();
}
inline int StartDiagLoggingPb::headermap_size() const {
  return _internal_headermap_size();
}
inline void StartDiagLoggingPb::clear_headermap() {
  headermap_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
StartDiagLoggingPb::_internal_headermap() const {
  return headermap_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
StartDiagLoggingPb::headermap() const {
  // @@protoc_insertion_point(field_map:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.HeaderMap)
  return _internal_headermap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
StartDiagLoggingPb::_internal_mutable_headermap() {
  return headermap_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
StartDiagLoggingPb::mutable_headermap() {
  // @@protoc_insertion_point(field_mutable_map:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.HeaderMap)
  return _internal_mutable_headermap();
}

// bool IsAsync = 3;
inline void StartDiagLoggingPb::clear_isasync() {
  isasync_ = false;
}
inline bool StartDiagLoggingPb::_internal_isasync() const {
  return isasync_;
}
inline bool StartDiagLoggingPb::isasync() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.IsAsync)
  return _internal_isasync();
}
inline void StartDiagLoggingPb::_internal_set_isasync(bool value) {
  
  isasync_ = value;
}
inline void StartDiagLoggingPb::set_isasync(bool value) {
  _internal_set_isasync(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.IsAsync)
}

// .OpenTestSystem.OtxDiagManager.Common.LogLevelsPb LogLevel = 4;
inline void StartDiagLoggingPb::clear_loglevel() {
  loglevel_ = 0;
}
inline ::OpenTestSystem::OtxDiagManager::Common::LogLevelsPb StartDiagLoggingPb::_internal_loglevel() const {
  return static_cast< ::OpenTestSystem::OtxDiagManager::Common::LogLevelsPb >(loglevel_);
}
inline ::OpenTestSystem::OtxDiagManager::Common::LogLevelsPb StartDiagLoggingPb::loglevel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.LogLevel)
  return _internal_loglevel();
}
inline void StartDiagLoggingPb::_internal_set_loglevel(::OpenTestSystem::OtxDiagManager::Common::LogLevelsPb value) {
  
  loglevel_ = value;
}
inline void StartDiagLoggingPb::set_loglevel(::OpenTestSystem::OtxDiagManager::Common::LogLevelsPb value) {
  _internal_set_loglevel(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.LogLevel)
}

// string LogFolder = 5;
inline void StartDiagLoggingPb::clear_logfolder() {
  logfolder_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& StartDiagLoggingPb::logfolder() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.LogFolder)
  return _internal_logfolder();
}
inline void StartDiagLoggingPb::set_logfolder(const std::string& value) {
  _internal_set_logfolder(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.LogFolder)
}
inline std::string* StartDiagLoggingPb::mutable_logfolder() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.LogFolder)
  return _internal_mutable_logfolder();
}
inline const std::string& StartDiagLoggingPb::_internal_logfolder() const {
  return logfolder_.GetNoArena();
}
inline void StartDiagLoggingPb::_internal_set_logfolder(const std::string& value) {
  
  logfolder_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void StartDiagLoggingPb::set_logfolder(std::string&& value) {
  
  logfolder_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.LogFolder)
}
inline void StartDiagLoggingPb::set_logfolder(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  logfolder_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.LogFolder)
}
inline void StartDiagLoggingPb::set_logfolder(const char* value, size_t size) {
  
  logfolder_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.LogFolder)
}
inline std::string* StartDiagLoggingPb::_internal_mutable_logfolder() {
  
  return logfolder_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* StartDiagLoggingPb::release_logfolder() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.LogFolder)
  
  return logfolder_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void StartDiagLoggingPb::set_allocated_logfolder(std::string* logfolder) {
  if (logfolder != nullptr) {
    
  } else {
    
  }
  logfolder_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), logfolder);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.StartDiagLoggingPb.LogFolder)
}

// -------------------------------------------------------------------

// StopDiagLoggingPb

// -------------------------------------------------------------------

// GetDbEcuMemOfFlashSessionPb

// string FlashSessionName = 1;
inline void GetDbEcuMemOfFlashSessionPb::clear_flashsessionname() {
  flashsessionname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetDbEcuMemOfFlashSessionPb::flashsessionname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetDbEcuMemOfFlashSessionPb.FlashSessionName)
  return _internal_flashsessionname();
}
inline void GetDbEcuMemOfFlashSessionPb::set_flashsessionname(const std::string& value) {
  _internal_set_flashsessionname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetDbEcuMemOfFlashSessionPb.FlashSessionName)
}
inline std::string* GetDbEcuMemOfFlashSessionPb::mutable_flashsessionname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetDbEcuMemOfFlashSessionPb.FlashSessionName)
  return _internal_mutable_flashsessionname();
}
inline const std::string& GetDbEcuMemOfFlashSessionPb::_internal_flashsessionname() const {
  return flashsessionname_.GetNoArena();
}
inline void GetDbEcuMemOfFlashSessionPb::_internal_set_flashsessionname(const std::string& value) {
  
  flashsessionname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetDbEcuMemOfFlashSessionPb::set_flashsessionname(std::string&& value) {
  
  flashsessionname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetDbEcuMemOfFlashSessionPb.FlashSessionName)
}
inline void GetDbEcuMemOfFlashSessionPb::set_flashsessionname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  flashsessionname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetDbEcuMemOfFlashSessionPb.FlashSessionName)
}
inline void GetDbEcuMemOfFlashSessionPb::set_flashsessionname(const char* value, size_t size) {
  
  flashsessionname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetDbEcuMemOfFlashSessionPb.FlashSessionName)
}
inline std::string* GetDbEcuMemOfFlashSessionPb::_internal_mutable_flashsessionname() {
  
  return flashsessionname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetDbEcuMemOfFlashSessionPb::release_flashsessionname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetDbEcuMemOfFlashSessionPb.FlashSessionName)
  
  return flashsessionname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetDbEcuMemOfFlashSessionPb::set_allocated_flashsessionname(std::string* flashsessionname) {
  if (flashsessionname != nullptr) {
    
  } else {
    
  }
  flashsessionname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), flashsessionname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetDbEcuMemOfFlashSessionPb.FlashSessionName)
}

// -------------------------------------------------------------------

// GetInterfaceFirmwareVersionPb

// string InterfaceShortName = 1;
inline void GetInterfaceFirmwareVersionPb::clear_interfaceshortname() {
  interfaceshortname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetInterfaceFirmwareVersionPb::interfaceshortname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareVersionPb.InterfaceShortName)
  return _internal_interfaceshortname();
}
inline void GetInterfaceFirmwareVersionPb::set_interfaceshortname(const std::string& value) {
  _internal_set_interfaceshortname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareVersionPb.InterfaceShortName)
}
inline std::string* GetInterfaceFirmwareVersionPb::mutable_interfaceshortname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareVersionPb.InterfaceShortName)
  return _internal_mutable_interfaceshortname();
}
inline const std::string& GetInterfaceFirmwareVersionPb::_internal_interfaceshortname() const {
  return interfaceshortname_.GetNoArena();
}
inline void GetInterfaceFirmwareVersionPb::_internal_set_interfaceshortname(const std::string& value) {
  
  interfaceshortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetInterfaceFirmwareVersionPb::set_interfaceshortname(std::string&& value) {
  
  interfaceshortname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareVersionPb.InterfaceShortName)
}
inline void GetInterfaceFirmwareVersionPb::set_interfaceshortname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  interfaceshortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareVersionPb.InterfaceShortName)
}
inline void GetInterfaceFirmwareVersionPb::set_interfaceshortname(const char* value, size_t size) {
  
  interfaceshortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareVersionPb.InterfaceShortName)
}
inline std::string* GetInterfaceFirmwareVersionPb::_internal_mutable_interfaceshortname() {
  
  return interfaceshortname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetInterfaceFirmwareVersionPb::release_interfaceshortname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareVersionPb.InterfaceShortName)
  
  return interfaceshortname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetInterfaceFirmwareVersionPb::set_allocated_interfaceshortname(std::string* interfaceshortname) {
  if (interfaceshortname != nullptr) {
    
  } else {
    
  }
  interfaceshortname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), interfaceshortname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareVersionPb.InterfaceShortName)
}

// -------------------------------------------------------------------

// GetInterfaceFirmwareNamePb

// string InterfaceShortName = 1;
inline void GetInterfaceFirmwareNamePb::clear_interfaceshortname() {
  interfaceshortname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetInterfaceFirmwareNamePb::interfaceshortname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareNamePb.InterfaceShortName)
  return _internal_interfaceshortname();
}
inline void GetInterfaceFirmwareNamePb::set_interfaceshortname(const std::string& value) {
  _internal_set_interfaceshortname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareNamePb.InterfaceShortName)
}
inline std::string* GetInterfaceFirmwareNamePb::mutable_interfaceshortname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareNamePb.InterfaceShortName)
  return _internal_mutable_interfaceshortname();
}
inline const std::string& GetInterfaceFirmwareNamePb::_internal_interfaceshortname() const {
  return interfaceshortname_.GetNoArena();
}
inline void GetInterfaceFirmwareNamePb::_internal_set_interfaceshortname(const std::string& value) {
  
  interfaceshortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetInterfaceFirmwareNamePb::set_interfaceshortname(std::string&& value) {
  
  interfaceshortname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareNamePb.InterfaceShortName)
}
inline void GetInterfaceFirmwareNamePb::set_interfaceshortname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  interfaceshortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareNamePb.InterfaceShortName)
}
inline void GetInterfaceFirmwareNamePb::set_interfaceshortname(const char* value, size_t size) {
  
  interfaceshortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareNamePb.InterfaceShortName)
}
inline std::string* GetInterfaceFirmwareNamePb::_internal_mutable_interfaceshortname() {
  
  return interfaceshortname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetInterfaceFirmwareNamePb::release_interfaceshortname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareNamePb.InterfaceShortName)
  
  return interfaceshortname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetInterfaceFirmwareNamePb::set_allocated_interfaceshortname(std::string* interfaceshortname) {
  if (interfaceshortname != nullptr) {
    
  } else {
    
  }
  interfaceshortname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), interfaceshortname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetInterfaceFirmwareNamePb.InterfaceShortName)
}

// -------------------------------------------------------------------

// GetInterfaceHardwareNamePb

// string InterfaceShortName = 1;
inline void GetInterfaceHardwareNamePb::clear_interfaceshortname() {
  interfaceshortname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetInterfaceHardwareNamePb::interfaceshortname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareNamePb.InterfaceShortName)
  return _internal_interfaceshortname();
}
inline void GetInterfaceHardwareNamePb::set_interfaceshortname(const std::string& value) {
  _internal_set_interfaceshortname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareNamePb.InterfaceShortName)
}
inline std::string* GetInterfaceHardwareNamePb::mutable_interfaceshortname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareNamePb.InterfaceShortName)
  return _internal_mutable_interfaceshortname();
}
inline const std::string& GetInterfaceHardwareNamePb::_internal_interfaceshortname() const {
  return interfaceshortname_.GetNoArena();
}
inline void GetInterfaceHardwareNamePb::_internal_set_interfaceshortname(const std::string& value) {
  
  interfaceshortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetInterfaceHardwareNamePb::set_interfaceshortname(std::string&& value) {
  
  interfaceshortname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareNamePb.InterfaceShortName)
}
inline void GetInterfaceHardwareNamePb::set_interfaceshortname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  interfaceshortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareNamePb.InterfaceShortName)
}
inline void GetInterfaceHardwareNamePb::set_interfaceshortname(const char* value, size_t size) {
  
  interfaceshortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareNamePb.InterfaceShortName)
}
inline std::string* GetInterfaceHardwareNamePb::_internal_mutable_interfaceshortname() {
  
  return interfaceshortname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetInterfaceHardwareNamePb::release_interfaceshortname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareNamePb.InterfaceShortName)
  
  return interfaceshortname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetInterfaceHardwareNamePb::set_allocated_interfaceshortname(std::string* interfaceshortname) {
  if (interfaceshortname != nullptr) {
    
  } else {
    
  }
  interfaceshortname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), interfaceshortname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareNamePb.InterfaceShortName)
}

// -------------------------------------------------------------------

// GetInterfaceHardwareSerialNumberPb

// string InterfaceShortName = 1;
inline void GetInterfaceHardwareSerialNumberPb::clear_interfaceshortname() {
  interfaceshortname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetInterfaceHardwareSerialNumberPb::interfaceshortname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareSerialNumberPb.InterfaceShortName)
  return _internal_interfaceshortname();
}
inline void GetInterfaceHardwareSerialNumberPb::set_interfaceshortname(const std::string& value) {
  _internal_set_interfaceshortname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareSerialNumberPb.InterfaceShortName)
}
inline std::string* GetInterfaceHardwareSerialNumberPb::mutable_interfaceshortname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareSerialNumberPb.InterfaceShortName)
  return _internal_mutable_interfaceshortname();
}
inline const std::string& GetInterfaceHardwareSerialNumberPb::_internal_interfaceshortname() const {
  return interfaceshortname_.GetNoArena();
}
inline void GetInterfaceHardwareSerialNumberPb::_internal_set_interfaceshortname(const std::string& value) {
  
  interfaceshortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetInterfaceHardwareSerialNumberPb::set_interfaceshortname(std::string&& value) {
  
  interfaceshortname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareSerialNumberPb.InterfaceShortName)
}
inline void GetInterfaceHardwareSerialNumberPb::set_interfaceshortname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  interfaceshortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareSerialNumberPb.InterfaceShortName)
}
inline void GetInterfaceHardwareSerialNumberPb::set_interfaceshortname(const char* value, size_t size) {
  
  interfaceshortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareSerialNumberPb.InterfaceShortName)
}
inline std::string* GetInterfaceHardwareSerialNumberPb::_internal_mutable_interfaceshortname() {
  
  return interfaceshortname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetInterfaceHardwareSerialNumberPb::release_interfaceshortname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareSerialNumberPb.InterfaceShortName)
  
  return interfaceshortname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetInterfaceHardwareSerialNumberPb::set_allocated_interfaceshortname(std::string* interfaceshortname) {
  if (interfaceshortname != nullptr) {
    
  } else {
    
  }
  interfaceshortname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), interfaceshortname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetInterfaceHardwareSerialNumberPb.InterfaceShortName)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace Common
}  // namespace OtxDiagManager
}  // namespace OpenTestSystem

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::OpenTestSystem::OtxDiagManager::Common::LogLevelsPb> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::OpenTestSystem::OtxDiagManager::Common::LogLevelsPb>() {
  return ::OpenTestSystem::OtxDiagManager::Common::LogLevelsPb_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_NoneOtxDiagApiCommandsPb_2eproto
