// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: lib/fluxsource/fluxsource.proto
// Protobuf C++ Version: 7.36.0

#ifndef lib_2ffluxsource_2ffluxsource_2eproto_2epb_2eh
#define lib_2ffluxsource_2ffluxsource_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>
#include <utility>

// clang-format off
#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 7036000
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_bases.h"
#include "google/protobuf/generated_message_tctable_decl.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/generated_message_reflection.h"
#include "google/protobuf/message.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/unknown_field_set.h"
#include "lib/config/common.pb.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_lib_2ffluxsource_2ffluxsource_2eproto

// Internal implementation detail -- do not use these members.
struct TableStruct_lib_2ffluxsource_2ffluxsource_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_lib_2ffluxsource_2ffluxsource_2eproto;
}  // extern "C"
class A2rFluxSourceProto;
struct A2rFluxSourceProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern A2rFluxSourceProtoGlobalsTypeInternal A2rFluxSourceProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull A2rFluxSourceProto_class_data_;
#else
extern const A2rFluxSourceProtoGlobalsTypeInternal A2rFluxSourceProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class CwfFluxSourceProto;
struct CwfFluxSourceProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern CwfFluxSourceProtoGlobalsTypeInternal CwfFluxSourceProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull CwfFluxSourceProto_class_data_;
#else
extern const CwfFluxSourceProtoGlobalsTypeInternal CwfFluxSourceProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class DmkFluxSourceProto;
struct DmkFluxSourceProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern DmkFluxSourceProtoGlobalsTypeInternal DmkFluxSourceProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull DmkFluxSourceProto_class_data_;
#else
extern const DmkFluxSourceProtoGlobalsTypeInternal DmkFluxSourceProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class EraseFluxSourceProto;
struct EraseFluxSourceProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern EraseFluxSourceProtoGlobalsTypeInternal EraseFluxSourceProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull EraseFluxSourceProto_class_data_;
#else
extern const EraseFluxSourceProtoGlobalsTypeInternal EraseFluxSourceProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class Fl2FluxSourceProto;
struct Fl2FluxSourceProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern Fl2FluxSourceProtoGlobalsTypeInternal Fl2FluxSourceProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull Fl2FluxSourceProto_class_data_;
#else
extern const Fl2FluxSourceProtoGlobalsTypeInternal Fl2FluxSourceProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class FluxSourceProto;
struct FluxSourceProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern FluxSourceProtoGlobalsTypeInternal FluxSourceProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull FluxSourceProto_class_data_;
#else
extern const FluxSourceProtoGlobalsTypeInternal FluxSourceProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class FlxFluxSourceProto;
struct FlxFluxSourceProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern FlxFluxSourceProtoGlobalsTypeInternal FlxFluxSourceProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull FlxFluxSourceProto_class_data_;
#else
extern const FlxFluxSourceProtoGlobalsTypeInternal FlxFluxSourceProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class HardwareFluxSourceProto;
struct HardwareFluxSourceProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern HardwareFluxSourceProtoGlobalsTypeInternal HardwareFluxSourceProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull HardwareFluxSourceProto_class_data_;
#else
extern const HardwareFluxSourceProtoGlobalsTypeInternal HardwareFluxSourceProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class KryofluxFluxSourceProto;
struct KryofluxFluxSourceProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern KryofluxFluxSourceProtoGlobalsTypeInternal KryofluxFluxSourceProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull KryofluxFluxSourceProto_class_data_;
#else
extern const KryofluxFluxSourceProtoGlobalsTypeInternal KryofluxFluxSourceProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class ScpFluxSourceProto;
struct ScpFluxSourceProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ScpFluxSourceProtoGlobalsTypeInternal ScpFluxSourceProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull ScpFluxSourceProto_class_data_;
#else
extern const ScpFluxSourceProtoGlobalsTypeInternal ScpFluxSourceProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class TestPatternFluxSourceProto;
struct TestPatternFluxSourceProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern TestPatternFluxSourceProtoGlobalsTypeInternal TestPatternFluxSourceProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull TestPatternFluxSourceProto_class_data_;
#else
extern const TestPatternFluxSourceProtoGlobalsTypeInternal TestPatternFluxSourceProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google


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


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

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED TestPatternFluxSourceProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:TestPatternFluxSourceProto) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline TestPatternFluxSourceProto() : TestPatternFluxSourceProto(nullptr) {}
  ~TestPatternFluxSourceProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(TestPatternFluxSourceProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(TestPatternFluxSourceProto));
  }
#endif

  template <typename = void>
  explicit constexpr TestPatternFluxSourceProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline TestPatternFluxSourceProto(const TestPatternFluxSourceProto& from) : TestPatternFluxSourceProto(nullptr, from) {}
  inline TestPatternFluxSourceProto(TestPatternFluxSourceProto&& from) noexcept : TestPatternFluxSourceProto(nullptr, ::std::move(from)) {}
  inline TestPatternFluxSourceProto& operator=(const TestPatternFluxSourceProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline TestPatternFluxSourceProto& operator=(TestPatternFluxSourceProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const TestPatternFluxSourceProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<TestPatternFluxSourceProto>(&TestPatternFluxSourceProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(TestPatternFluxSourceProto& a, TestPatternFluxSourceProto& b) { a.Swap(&b); }
  inline void Swap(TestPatternFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TestPatternFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] TestPatternFluxSourceProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<TestPatternFluxSourceProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const TestPatternFluxSourceProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const TestPatternFluxSourceProto& from) { TestPatternFluxSourceProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(TestPatternFluxSourceProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "TestPatternFluxSourceProto"; }

  explicit TestPatternFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  TestPatternFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TestPatternFluxSourceProto& from);
  TestPatternFluxSourceProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TestPatternFluxSourceProto&& from) noexcept
      : TestPatternFluxSourceProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kIntervalUsFieldNumber = 1,
    kSequenceLengthMsFieldNumber = 2,
  };
  // optional double interval_us = 1 [default = 4, json_name = "intervalUs", (.help) = "interval between pulses"];
  [[nodiscard]] bool has_interval_us() const;
  void clear_interval_us() ;
  [[nodiscard]] double interval_us() const;
  void set_interval_us(double value);

  private:
  double _internal_interval_us() const;
  void _internal_set_interval_us(double value);

  public:
  // optional double sequence_length_ms = 2 [default = 166, json_name = "sequenceLengthMs", (.help) = "length of test sequence"];
  [[nodiscard]] bool has_sequence_length_ms() const;
  void clear_sequence_length_ms() ;
  [[nodiscard]] double sequence_length_ms() const;
  void set_sequence_length_ms(double value);

  private:
  double _internal_sequence_length_ms() const;
  void _internal_set_sequence_length_ms(double value);

  public:
  // @@protoc_insertion_point(class_scope:TestPatternFluxSourceProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<1, 2,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const TestPatternFluxSourceProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    double interval_us_;
    double sequence_length_ms_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2ffluxsource_2ffluxsource_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED ScpFluxSourceProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:ScpFluxSourceProto) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline ScpFluxSourceProto() : ScpFluxSourceProto(nullptr) {}
  ~ScpFluxSourceProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(ScpFluxSourceProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(ScpFluxSourceProto));
  }
#endif

  template <typename = void>
  explicit constexpr ScpFluxSourceProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline ScpFluxSourceProto(const ScpFluxSourceProto& from) : ScpFluxSourceProto(nullptr, from) {}
  inline ScpFluxSourceProto(ScpFluxSourceProto&& from) noexcept : ScpFluxSourceProto(nullptr, ::std::move(from)) {}
  inline ScpFluxSourceProto& operator=(const ScpFluxSourceProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ScpFluxSourceProto& operator=(ScpFluxSourceProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const ScpFluxSourceProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<ScpFluxSourceProto>(&ScpFluxSourceProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 4;
  friend void swap(ScpFluxSourceProto& a, ScpFluxSourceProto& b) { a.Swap(&b); }
  inline void Swap(ScpFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ScpFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] ScpFluxSourceProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<ScpFluxSourceProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const ScpFluxSourceProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const ScpFluxSourceProto& from) { ScpFluxSourceProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(ScpFluxSourceProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "ScpFluxSourceProto"; }

  explicit ScpFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ScpFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ScpFluxSourceProto& from);
  ScpFluxSourceProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ScpFluxSourceProto&& from) noexcept
      : ScpFluxSourceProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kFilenameFieldNumber = 1,
  };
  // optional string filename = 1 [default = "flux.scp", json_name = "filename", (.help) = ".scp file to read flux from"];
  [[nodiscard]] bool has_filename() const;
  void clear_filename() ;
  [[nodiscard]] const ::std::string& filename() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_filename(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_filename();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_filename();
  void set_allocated_filename(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_filename() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_filename(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_filename();

  public:
  // @@protoc_insertion_point(class_scope:ScpFluxSourceProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const ScpFluxSourceProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_filename_;
    ::google::protobuf::internal::ArenaStringPtr filename_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2ffluxsource_2ffluxsource_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED KryofluxFluxSourceProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:KryofluxFluxSourceProto) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline KryofluxFluxSourceProto() : KryofluxFluxSourceProto(nullptr) {}
  ~KryofluxFluxSourceProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(KryofluxFluxSourceProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(KryofluxFluxSourceProto));
  }
#endif

  template <typename = void>
  explicit constexpr KryofluxFluxSourceProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline KryofluxFluxSourceProto(const KryofluxFluxSourceProto& from) : KryofluxFluxSourceProto(nullptr, from) {}
  inline KryofluxFluxSourceProto(KryofluxFluxSourceProto&& from) noexcept : KryofluxFluxSourceProto(nullptr, ::std::move(from)) {}
  inline KryofluxFluxSourceProto& operator=(const KryofluxFluxSourceProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline KryofluxFluxSourceProto& operator=(KryofluxFluxSourceProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const KryofluxFluxSourceProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<KryofluxFluxSourceProto>(&KryofluxFluxSourceProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(KryofluxFluxSourceProto& a, KryofluxFluxSourceProto& b) { a.Swap(&b); }
  inline void Swap(KryofluxFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(KryofluxFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] KryofluxFluxSourceProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<KryofluxFluxSourceProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const KryofluxFluxSourceProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const KryofluxFluxSourceProto& from) { KryofluxFluxSourceProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(KryofluxFluxSourceProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "KryofluxFluxSourceProto"; }

  explicit KryofluxFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  KryofluxFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const KryofluxFluxSourceProto& from);
  KryofluxFluxSourceProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, KryofluxFluxSourceProto&& from) noexcept
      : KryofluxFluxSourceProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kDirectoryFieldNumber = 1,
  };
  // optional string directory = 1 [json_name = "directory", (.help) = "path to Kryoflux stream directory"];
  [[nodiscard]] bool has_directory() const;
  void clear_directory() ;
  [[nodiscard]] const ::std::string& directory() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_directory(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_directory();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_directory();
  void set_allocated_directory(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_directory() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_directory(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_directory();

  public:
  // @@protoc_insertion_point(class_scope:KryofluxFluxSourceProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const KryofluxFluxSourceProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr directory_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2ffluxsource_2ffluxsource_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED HardwareFluxSourceProto final : public ::google::protobuf::internal::ZeroFieldsBase
/* @@protoc_insertion_point(class_definition:HardwareFluxSourceProto) */ {
  using Super_ = ::google::protobuf::internal::ZeroFieldsBase;

 public:
  inline HardwareFluxSourceProto() : HardwareFluxSourceProto(nullptr) {}

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(HardwareFluxSourceProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(HardwareFluxSourceProto));
  }
#endif

  template <typename = void>
  explicit constexpr HardwareFluxSourceProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline HardwareFluxSourceProto(const HardwareFluxSourceProto& from) : HardwareFluxSourceProto(nullptr, from) {}
  inline HardwareFluxSourceProto(HardwareFluxSourceProto&& from) noexcept : HardwareFluxSourceProto(nullptr, ::std::move(from)) {}
  inline HardwareFluxSourceProto& operator=(const HardwareFluxSourceProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline HardwareFluxSourceProto& operator=(HardwareFluxSourceProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const HardwareFluxSourceProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<HardwareFluxSourceProto>(&HardwareFluxSourceProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(HardwareFluxSourceProto& a, HardwareFluxSourceProto& b) { a.Swap(&b); }
  inline void Swap(HardwareFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(HardwareFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] HardwareFluxSourceProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<HardwareFluxSourceProto>(arena);
  }
  using Super_::CopyFrom;
  inline void CopyFrom(const HardwareFluxSourceProto& from) { Super_::CopyImpl(*this, from); }
  using Super_::MergeFrom;
  void MergeFrom(const HardwareFluxSourceProto& from) { Super_::MergeImpl(*this, from); }

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
 private:
  static ::absl::string_view FullMessageName() { return "HardwareFluxSourceProto"; }

  explicit HardwareFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  HardwareFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HardwareFluxSourceProto& from);
  HardwareFluxSourceProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, HardwareFluxSourceProto&& from) noexcept
      : HardwareFluxSourceProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  // @@protoc_insertion_point(class_scope:HardwareFluxSourceProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 0,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  friend struct ::TableStruct_lib_2ffluxsource_2ffluxsource_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED FlxFluxSourceProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:FlxFluxSourceProto) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline FlxFluxSourceProto() : FlxFluxSourceProto(nullptr) {}
  ~FlxFluxSourceProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(FlxFluxSourceProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(FlxFluxSourceProto));
  }
#endif

  template <typename = void>
  explicit constexpr FlxFluxSourceProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline FlxFluxSourceProto(const FlxFluxSourceProto& from) : FlxFluxSourceProto(nullptr, from) {}
  inline FlxFluxSourceProto(FlxFluxSourceProto&& from) noexcept : FlxFluxSourceProto(nullptr, ::std::move(from)) {}
  inline FlxFluxSourceProto& operator=(const FlxFluxSourceProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline FlxFluxSourceProto& operator=(FlxFluxSourceProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const FlxFluxSourceProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<FlxFluxSourceProto>(&FlxFluxSourceProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 9;
  friend void swap(FlxFluxSourceProto& a, FlxFluxSourceProto& b) { a.Swap(&b); }
  inline void Swap(FlxFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FlxFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] FlxFluxSourceProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<FlxFluxSourceProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const FlxFluxSourceProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const FlxFluxSourceProto& from) { FlxFluxSourceProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(FlxFluxSourceProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "FlxFluxSourceProto"; }

  explicit FlxFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  FlxFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const FlxFluxSourceProto& from);
  FlxFluxSourceProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, FlxFluxSourceProto&& from) noexcept
      : FlxFluxSourceProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kDirectoryFieldNumber = 1,
  };
  // optional string directory = 1 [json_name = "directory", (.help) = "path to FLX stream directory"];
  [[nodiscard]] bool has_directory() const;
  void clear_directory() ;
  [[nodiscard]] const ::std::string& directory() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_directory(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_directory();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_directory();
  void set_allocated_directory(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_directory() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_directory(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_directory();

  public:
  // @@protoc_insertion_point(class_scope:FlxFluxSourceProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const FlxFluxSourceProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr directory_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2ffluxsource_2ffluxsource_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED Fl2FluxSourceProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:Fl2FluxSourceProto) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline Fl2FluxSourceProto() : Fl2FluxSourceProto(nullptr) {}
  ~Fl2FluxSourceProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(Fl2FluxSourceProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(Fl2FluxSourceProto));
  }
#endif

  template <typename = void>
  explicit constexpr Fl2FluxSourceProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline Fl2FluxSourceProto(const Fl2FluxSourceProto& from) : Fl2FluxSourceProto(nullptr, from) {}
  inline Fl2FluxSourceProto(Fl2FluxSourceProto&& from) noexcept : Fl2FluxSourceProto(nullptr, ::std::move(from)) {}
  inline Fl2FluxSourceProto& operator=(const Fl2FluxSourceProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline Fl2FluxSourceProto& operator=(Fl2FluxSourceProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const Fl2FluxSourceProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<Fl2FluxSourceProto>(&Fl2FluxSourceProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 8;
  friend void swap(Fl2FluxSourceProto& a, Fl2FluxSourceProto& b) { a.Swap(&b); }
  inline void Swap(Fl2FluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Fl2FluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] Fl2FluxSourceProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<Fl2FluxSourceProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const Fl2FluxSourceProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const Fl2FluxSourceProto& from) { Fl2FluxSourceProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(Fl2FluxSourceProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "Fl2FluxSourceProto"; }

  explicit Fl2FluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  Fl2FluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Fl2FluxSourceProto& from);
  Fl2FluxSourceProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Fl2FluxSourceProto&& from) noexcept
      : Fl2FluxSourceProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kFilenameFieldNumber = 1,
  };
  // optional string filename = 1 [default = "flux.fl2", json_name = "filename", (.help) = ".fl2 file to read flux from"];
  [[nodiscard]] bool has_filename() const;
  void clear_filename() ;
  [[nodiscard]] const ::std::string& filename() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_filename(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_filename();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_filename();
  void set_allocated_filename(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_filename() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_filename(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_filename();

  public:
  // @@protoc_insertion_point(class_scope:Fl2FluxSourceProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const Fl2FluxSourceProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_filename_;
    ::google::protobuf::internal::ArenaStringPtr filename_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2ffluxsource_2ffluxsource_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED EraseFluxSourceProto final : public ::google::protobuf::internal::ZeroFieldsBase
/* @@protoc_insertion_point(class_definition:EraseFluxSourceProto) */ {
  using Super_ = ::google::protobuf::internal::ZeroFieldsBase;

 public:
  inline EraseFluxSourceProto() : EraseFluxSourceProto(nullptr) {}

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(EraseFluxSourceProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(EraseFluxSourceProto));
  }
#endif

  template <typename = void>
  explicit constexpr EraseFluxSourceProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline EraseFluxSourceProto(const EraseFluxSourceProto& from) : EraseFluxSourceProto(nullptr, from) {}
  inline EraseFluxSourceProto(EraseFluxSourceProto&& from) noexcept : EraseFluxSourceProto(nullptr, ::std::move(from)) {}
  inline EraseFluxSourceProto& operator=(const EraseFluxSourceProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline EraseFluxSourceProto& operator=(EraseFluxSourceProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const EraseFluxSourceProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<EraseFluxSourceProto>(&EraseFluxSourceProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(EraseFluxSourceProto& a, EraseFluxSourceProto& b) { a.Swap(&b); }
  inline void Swap(EraseFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(EraseFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] EraseFluxSourceProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<EraseFluxSourceProto>(arena);
  }
  using Super_::CopyFrom;
  inline void CopyFrom(const EraseFluxSourceProto& from) { Super_::CopyImpl(*this, from); }
  using Super_::MergeFrom;
  void MergeFrom(const EraseFluxSourceProto& from) { Super_::MergeImpl(*this, from); }

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
 private:
  static ::absl::string_view FullMessageName() { return "EraseFluxSourceProto"; }

  explicit EraseFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  EraseFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const EraseFluxSourceProto& from);
  EraseFluxSourceProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, EraseFluxSourceProto&& from) noexcept
      : EraseFluxSourceProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  // @@protoc_insertion_point(class_scope:EraseFluxSourceProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 0,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  friend struct ::TableStruct_lib_2ffluxsource_2ffluxsource_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED DmkFluxSourceProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:DmkFluxSourceProto) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline DmkFluxSourceProto() : DmkFluxSourceProto(nullptr) {}
  ~DmkFluxSourceProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(DmkFluxSourceProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(DmkFluxSourceProto));
  }
#endif

  template <typename = void>
  explicit constexpr DmkFluxSourceProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline DmkFluxSourceProto(const DmkFluxSourceProto& from) : DmkFluxSourceProto(nullptr, from) {}
  inline DmkFluxSourceProto(DmkFluxSourceProto&& from) noexcept : DmkFluxSourceProto(nullptr, ::std::move(from)) {}
  inline DmkFluxSourceProto& operator=(const DmkFluxSourceProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline DmkFluxSourceProto& operator=(DmkFluxSourceProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const DmkFluxSourceProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<DmkFluxSourceProto>(&DmkFluxSourceProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 7;
  friend void swap(DmkFluxSourceProto& a, DmkFluxSourceProto& b) { a.Swap(&b); }
  inline void Swap(DmkFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DmkFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] DmkFluxSourceProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<DmkFluxSourceProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const DmkFluxSourceProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const DmkFluxSourceProto& from) { DmkFluxSourceProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(DmkFluxSourceProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "DmkFluxSourceProto"; }

  explicit DmkFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  DmkFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DmkFluxSourceProto& from);
  DmkFluxSourceProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, DmkFluxSourceProto&& from) noexcept
      : DmkFluxSourceProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kDirectoryFieldNumber = 1,
  };
  // optional string directory = 1 [json_name = "directory", (.help) = "path to DMK directory"];
  [[nodiscard]] bool has_directory() const;
  void clear_directory() ;
  [[nodiscard]] const ::std::string& directory() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_directory(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_directory();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_directory();
  void set_allocated_directory(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_directory() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_directory(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_directory();

  public:
  // @@protoc_insertion_point(class_scope:DmkFluxSourceProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const DmkFluxSourceProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr directory_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2ffluxsource_2ffluxsource_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED CwfFluxSourceProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:CwfFluxSourceProto) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline CwfFluxSourceProto() : CwfFluxSourceProto(nullptr) {}
  ~CwfFluxSourceProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(CwfFluxSourceProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(CwfFluxSourceProto));
  }
#endif

  template <typename = void>
  explicit constexpr CwfFluxSourceProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline CwfFluxSourceProto(const CwfFluxSourceProto& from) : CwfFluxSourceProto(nullptr, from) {}
  inline CwfFluxSourceProto(CwfFluxSourceProto&& from) noexcept : CwfFluxSourceProto(nullptr, ::std::move(from)) {}
  inline CwfFluxSourceProto& operator=(const CwfFluxSourceProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline CwfFluxSourceProto& operator=(CwfFluxSourceProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const CwfFluxSourceProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<CwfFluxSourceProto>(&CwfFluxSourceProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 6;
  friend void swap(CwfFluxSourceProto& a, CwfFluxSourceProto& b) { a.Swap(&b); }
  inline void Swap(CwfFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CwfFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] CwfFluxSourceProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<CwfFluxSourceProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const CwfFluxSourceProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const CwfFluxSourceProto& from) { CwfFluxSourceProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(CwfFluxSourceProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "CwfFluxSourceProto"; }

  explicit CwfFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  CwfFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const CwfFluxSourceProto& from);
  CwfFluxSourceProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, CwfFluxSourceProto&& from) noexcept
      : CwfFluxSourceProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kFilenameFieldNumber = 1,
  };
  // optional string filename = 1 [default = "flux.cwf", json_name = "filename", (.help) = ".cwf file to read flux from"];
  [[nodiscard]] bool has_filename() const;
  void clear_filename() ;
  [[nodiscard]] const ::std::string& filename() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_filename(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_filename();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_filename();
  void set_allocated_filename(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_filename() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_filename(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_filename();

  public:
  // @@protoc_insertion_point(class_scope:CwfFluxSourceProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const CwfFluxSourceProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_filename_;
    ::google::protobuf::internal::ArenaStringPtr filename_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2ffluxsource_2ffluxsource_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED A2rFluxSourceProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:A2rFluxSourceProto) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline A2rFluxSourceProto() : A2rFluxSourceProto(nullptr) {}
  ~A2rFluxSourceProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(A2rFluxSourceProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(A2rFluxSourceProto));
  }
#endif

  template <typename = void>
  explicit constexpr A2rFluxSourceProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline A2rFluxSourceProto(const A2rFluxSourceProto& from) : A2rFluxSourceProto(nullptr, from) {}
  inline A2rFluxSourceProto(A2rFluxSourceProto&& from) noexcept : A2rFluxSourceProto(nullptr, ::std::move(from)) {}
  inline A2rFluxSourceProto& operator=(const A2rFluxSourceProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline A2rFluxSourceProto& operator=(A2rFluxSourceProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const A2rFluxSourceProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<A2rFluxSourceProto>(&A2rFluxSourceProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 5;
  friend void swap(A2rFluxSourceProto& a, A2rFluxSourceProto& b) { a.Swap(&b); }
  inline void Swap(A2rFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(A2rFluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] A2rFluxSourceProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<A2rFluxSourceProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const A2rFluxSourceProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const A2rFluxSourceProto& from) { A2rFluxSourceProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(A2rFluxSourceProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "A2rFluxSourceProto"; }

  explicit A2rFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  A2rFluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const A2rFluxSourceProto& from);
  A2rFluxSourceProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, A2rFluxSourceProto&& from) noexcept
      : A2rFluxSourceProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kFilenameFieldNumber = 1,
  };
  // optional string filename = 1 [default = "flux.a2r", json_name = "filename", (.help) = ".a2r file to read flux from"];
  [[nodiscard]] bool has_filename() const;
  void clear_filename() ;
  [[nodiscard]] const ::std::string& filename() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_filename(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_filename();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_filename();
  void set_allocated_filename(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_filename() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_filename(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_filename();

  public:
  // @@protoc_insertion_point(class_scope:A2rFluxSourceProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const A2rFluxSourceProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_filename_;
    ::google::protobuf::internal::ArenaStringPtr filename_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2ffluxsource_2ffluxsource_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED FluxSourceProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:FluxSourceProto) */ {
  using Super_ = ::google::protobuf::Message;

 public:
  inline FluxSourceProto() : FluxSourceProto(nullptr) {}
  ~FluxSourceProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(FluxSourceProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(FluxSourceProto));
  }
#endif

  template <typename = void>
  explicit constexpr FluxSourceProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline FluxSourceProto(const FluxSourceProto& from) : FluxSourceProto(nullptr, from) {}
  inline FluxSourceProto(FluxSourceProto&& from) noexcept : FluxSourceProto(nullptr, ::std::move(from)) {}
  inline FluxSourceProto& operator=(const FluxSourceProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline FluxSourceProto& operator=(FluxSourceProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const FluxSourceProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<FluxSourceProto>(&FluxSourceProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 10;
  friend void swap(FluxSourceProto& a, FluxSourceProto& b) { a.Swap(&b); }
  inline void Swap(FluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FluxSourceProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] FluxSourceProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<FluxSourceProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const FluxSourceProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const FluxSourceProto& from) { FluxSourceProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(FluxSourceProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "FluxSourceProto"; }

  explicit FluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  FluxSourceProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const FluxSourceProto& from);
  FluxSourceProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, FluxSourceProto&& from) noexcept
      : FluxSourceProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kDriveFieldNumber = 2,
    kTestPatternFieldNumber = 3,
    kEraseFieldNumber = 4,
    kKryofluxFieldNumber = 5,
    kScpFieldNumber = 6,
    kCwfFieldNumber = 7,
    kFl2FieldNumber = 8,
    kFlxFieldNumber = 10,
    kA2RFieldNumber = 11,
    kDmkFieldNumber = 12,
    kTypeFieldNumber = 9,
  };
  // optional .HardwareFluxSourceProto drive = 2 [json_name = "drive"];
  [[nodiscard]] bool has_drive() const;
  void clear_drive() ;
  [[nodiscard]] const ::HardwareFluxSourceProto& drive() const;
  [[nodiscard]] ::HardwareFluxSourceProto* PROTOBUF_NULLABLE release_drive();
  ::HardwareFluxSourceProto* PROTOBUF_NONNULL mutable_drive();
  void set_allocated_drive(::HardwareFluxSourceProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_drive(::HardwareFluxSourceProto* PROTOBUF_NULLABLE value);
  ::HardwareFluxSourceProto* PROTOBUF_NULLABLE unsafe_arena_release_drive();

  private:
  const ::HardwareFluxSourceProto& _internal_drive() const;
  ::HardwareFluxSourceProto* PROTOBUF_NONNULL _internal_mutable_drive();

  public:
  // optional .TestPatternFluxSourceProto test_pattern = 3 [json_name = "testPattern"];
  [[nodiscard]] bool has_test_pattern() const;
  void clear_test_pattern() ;
  [[nodiscard]] const ::TestPatternFluxSourceProto& test_pattern() const;
  [[nodiscard]] ::TestPatternFluxSourceProto* PROTOBUF_NULLABLE release_test_pattern();
  ::TestPatternFluxSourceProto* PROTOBUF_NONNULL mutable_test_pattern();
  void set_allocated_test_pattern(::TestPatternFluxSourceProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_test_pattern(::TestPatternFluxSourceProto* PROTOBUF_NULLABLE value);
  ::TestPatternFluxSourceProto* PROTOBUF_NULLABLE unsafe_arena_release_test_pattern();

  private:
  const ::TestPatternFluxSourceProto& _internal_test_pattern() const;
  ::TestPatternFluxSourceProto* PROTOBUF_NONNULL _internal_mutable_test_pattern();

  public:
  // optional .EraseFluxSourceProto erase = 4 [json_name = "erase"];
  [[nodiscard]] bool has_erase() const;
  void clear_erase() ;
  [[nodiscard]] const ::EraseFluxSourceProto& erase() const;
  [[nodiscard]] ::EraseFluxSourceProto* PROTOBUF_NULLABLE release_erase();
  ::EraseFluxSourceProto* PROTOBUF_NONNULL mutable_erase();
  void set_allocated_erase(::EraseFluxSourceProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_erase(::EraseFluxSourceProto* PROTOBUF_NULLABLE value);
  ::EraseFluxSourceProto* PROTOBUF_NULLABLE unsafe_arena_release_erase();

  private:
  const ::EraseFluxSourceProto& _internal_erase() const;
  ::EraseFluxSourceProto* PROTOBUF_NONNULL _internal_mutable_erase();

  public:
  // optional .KryofluxFluxSourceProto kryoflux = 5 [json_name = "kryoflux"];
  [[nodiscard]] bool has_kryoflux() const;
  void clear_kryoflux() ;
  [[nodiscard]] const ::KryofluxFluxSourceProto& kryoflux() const;
  [[nodiscard]] ::KryofluxFluxSourceProto* PROTOBUF_NULLABLE release_kryoflux();
  ::KryofluxFluxSourceProto* PROTOBUF_NONNULL mutable_kryoflux();
  void set_allocated_kryoflux(::KryofluxFluxSourceProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_kryoflux(::KryofluxFluxSourceProto* PROTOBUF_NULLABLE value);
  ::KryofluxFluxSourceProto* PROTOBUF_NULLABLE unsafe_arena_release_kryoflux();

  private:
  const ::KryofluxFluxSourceProto& _internal_kryoflux() const;
  ::KryofluxFluxSourceProto* PROTOBUF_NONNULL _internal_mutable_kryoflux();

  public:
  // optional .ScpFluxSourceProto scp = 6 [json_name = "scp"];
  [[nodiscard]] bool has_scp() const;
  void clear_scp() ;
  [[nodiscard]] const ::ScpFluxSourceProto& scp() const;
  [[nodiscard]] ::ScpFluxSourceProto* PROTOBUF_NULLABLE release_scp();
  ::ScpFluxSourceProto* PROTOBUF_NONNULL mutable_scp();
  void set_allocated_scp(::ScpFluxSourceProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_scp(::ScpFluxSourceProto* PROTOBUF_NULLABLE value);
  ::ScpFluxSourceProto* PROTOBUF_NULLABLE unsafe_arena_release_scp();

  private:
  const ::ScpFluxSourceProto& _internal_scp() const;
  ::ScpFluxSourceProto* PROTOBUF_NONNULL _internal_mutable_scp();

  public:
  // optional .CwfFluxSourceProto cwf = 7 [json_name = "cwf"];
  [[nodiscard]] bool has_cwf() const;
  void clear_cwf() ;
  [[nodiscard]] const ::CwfFluxSourceProto& cwf() const;
  [[nodiscard]] ::CwfFluxSourceProto* PROTOBUF_NULLABLE release_cwf();
  ::CwfFluxSourceProto* PROTOBUF_NONNULL mutable_cwf();
  void set_allocated_cwf(::CwfFluxSourceProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_cwf(::CwfFluxSourceProto* PROTOBUF_NULLABLE value);
  ::CwfFluxSourceProto* PROTOBUF_NULLABLE unsafe_arena_release_cwf();

  private:
  const ::CwfFluxSourceProto& _internal_cwf() const;
  ::CwfFluxSourceProto* PROTOBUF_NONNULL _internal_mutable_cwf();

  public:
  // optional .Fl2FluxSourceProto fl2 = 8 [json_name = "fl2"];
  [[nodiscard]] bool has_fl2() const;
  void clear_fl2() ;
  [[nodiscard]] const ::Fl2FluxSourceProto& fl2() const;
  [[nodiscard]] ::Fl2FluxSourceProto* PROTOBUF_NULLABLE release_fl2();
  ::Fl2FluxSourceProto* PROTOBUF_NONNULL mutable_fl2();
  void set_allocated_fl2(::Fl2FluxSourceProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_fl2(::Fl2FluxSourceProto* PROTOBUF_NULLABLE value);
  ::Fl2FluxSourceProto* PROTOBUF_NULLABLE unsafe_arena_release_fl2();

  private:
  const ::Fl2FluxSourceProto& _internal_fl2() const;
  ::Fl2FluxSourceProto* PROTOBUF_NONNULL _internal_mutable_fl2();

  public:
  // optional .FlxFluxSourceProto flx = 10 [json_name = "flx"];
  [[nodiscard]] bool has_flx() const;
  void clear_flx() ;
  [[nodiscard]] const ::FlxFluxSourceProto& flx() const;
  [[nodiscard]] ::FlxFluxSourceProto* PROTOBUF_NULLABLE release_flx();
  ::FlxFluxSourceProto* PROTOBUF_NONNULL mutable_flx();
  void set_allocated_flx(::FlxFluxSourceProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_flx(::FlxFluxSourceProto* PROTOBUF_NULLABLE value);
  ::FlxFluxSourceProto* PROTOBUF_NULLABLE unsafe_arena_release_flx();

  private:
  const ::FlxFluxSourceProto& _internal_flx() const;
  ::FlxFluxSourceProto* PROTOBUF_NONNULL _internal_mutable_flx();

  public:
  // optional .A2rFluxSourceProto a2r = 11 [json_name = "a2r"];
  [[nodiscard]] bool has_a2r() const;
  void clear_a2r() ;
  [[nodiscard]] const ::A2rFluxSourceProto& a2r() const;
  [[nodiscard]] ::A2rFluxSourceProto* PROTOBUF_NULLABLE release_a2r();
  ::A2rFluxSourceProto* PROTOBUF_NONNULL mutable_a2r();
  void set_allocated_a2r(::A2rFluxSourceProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_a2r(::A2rFluxSourceProto* PROTOBUF_NULLABLE value);
  ::A2rFluxSourceProto* PROTOBUF_NULLABLE unsafe_arena_release_a2r();

  private:
  const ::A2rFluxSourceProto& _internal_a2r() const;
  ::A2rFluxSourceProto* PROTOBUF_NONNULL _internal_mutable_a2r();

  public:
  // optional .DmkFluxSourceProto dmk = 12 [json_name = "dmk"];
  [[nodiscard]] bool has_dmk() const;
  void clear_dmk() ;
  [[nodiscard]] const ::DmkFluxSourceProto& dmk() const;
  [[nodiscard]] ::DmkFluxSourceProto* PROTOBUF_NULLABLE release_dmk();
  ::DmkFluxSourceProto* PROTOBUF_NONNULL mutable_dmk();
  void set_allocated_dmk(::DmkFluxSourceProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_dmk(::DmkFluxSourceProto* PROTOBUF_NULLABLE value);
  ::DmkFluxSourceProto* PROTOBUF_NULLABLE unsafe_arena_release_dmk();

  private:
  const ::DmkFluxSourceProto& _internal_dmk() const;
  ::DmkFluxSourceProto* PROTOBUF_NONNULL _internal_mutable_dmk();

  public:
  // optional .FluxSourceSinkType type = 9 [default = FLUXTYPE_NOT_SET, json_name = "type", (.help) = "flux source type"];
  [[nodiscard]] bool has_type() const;
  void clear_type() ;
  [[nodiscard]] ::FluxSourceSinkType type() const;
  void set_type(::FluxSourceSinkType value);

  private:
  ::FluxSourceSinkType _internal_type() const;
  void _internal_set_type(::FluxSourceSinkType value);

  public:
  // @@protoc_insertion_point(class_scope:FluxSourceProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<4, 11,
                          11, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const FluxSourceProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::HardwareFluxSourceProto* PROTOBUF_NULLABLE drive_;
    ::TestPatternFluxSourceProto* PROTOBUF_NULLABLE test_pattern_;
    ::EraseFluxSourceProto* PROTOBUF_NULLABLE erase_;
    ::KryofluxFluxSourceProto* PROTOBUF_NULLABLE kryoflux_;
    ::ScpFluxSourceProto* PROTOBUF_NULLABLE scp_;
    ::CwfFluxSourceProto* PROTOBUF_NULLABLE cwf_;
    ::Fl2FluxSourceProto* PROTOBUF_NULLABLE fl2_;
    ::FlxFluxSourceProto* PROTOBUF_NULLABLE flx_;
    ::A2rFluxSourceProto* PROTOBUF_NULLABLE a2r_;
    ::DmkFluxSourceProto* PROTOBUF_NULLABLE dmk_;
    int type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2ffluxsource_2ffluxsource_2eproto;
};

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




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


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

// HardwareFluxSourceProto

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

// TestPatternFluxSourceProto

// optional double interval_us = 1 [default = 4, json_name = "intervalUs", (.help) = "interval between pulses"];
inline bool TestPatternFluxSourceProto::has_interval_us() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void TestPatternFluxSourceProto::clear_interval_us() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.interval_us_ = 4;
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline double TestPatternFluxSourceProto::interval_us() const {
  // @@protoc_insertion_point(field_get:TestPatternFluxSourceProto.interval_us)
  return _internal_interval_us();
}
inline void TestPatternFluxSourceProto::set_interval_us(double value) {
  _internal_set_interval_us(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:TestPatternFluxSourceProto.interval_us)
}
inline double TestPatternFluxSourceProto::_internal_interval_us() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.interval_us_;
}
inline void TestPatternFluxSourceProto::_internal_set_interval_us(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.interval_us_ = value;
}

// optional double sequence_length_ms = 2 [default = 166, json_name = "sequenceLengthMs", (.help) = "length of test sequence"];
inline bool TestPatternFluxSourceProto::has_sequence_length_ms() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void TestPatternFluxSourceProto::clear_sequence_length_ms() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.sequence_length_ms_ = 166;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline double TestPatternFluxSourceProto::sequence_length_ms() const {
  // @@protoc_insertion_point(field_get:TestPatternFluxSourceProto.sequence_length_ms)
  return _internal_sequence_length_ms();
}
inline void TestPatternFluxSourceProto::set_sequence_length_ms(double value) {
  _internal_set_sequence_length_ms(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:TestPatternFluxSourceProto.sequence_length_ms)
}
inline double TestPatternFluxSourceProto::_internal_sequence_length_ms() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.sequence_length_ms_;
}
inline void TestPatternFluxSourceProto::_internal_set_sequence_length_ms(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.sequence_length_ms_ = value;
}

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

// EraseFluxSourceProto

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

// KryofluxFluxSourceProto

// optional string directory = 1 [json_name = "directory", (.help) = "path to Kryoflux stream directory"];
inline bool KryofluxFluxSourceProto::has_directory() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void KryofluxFluxSourceProto::clear_directory() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.directory_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& KryofluxFluxSourceProto::directory() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:KryofluxFluxSourceProto.directory)
  return _internal_directory();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void KryofluxFluxSourceProto::set_directory(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.directory_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:KryofluxFluxSourceProto.directory)
}
inline ::std::string* PROTOBUF_NONNULL KryofluxFluxSourceProto::mutable_directory()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_directory();
  // @@protoc_insertion_point(field_mutable:KryofluxFluxSourceProto.directory)
  return _s;
}
inline const ::std::string& KryofluxFluxSourceProto::_internal_directory() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.directory_.Get();
}
inline void KryofluxFluxSourceProto::_internal_set_directory(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.directory_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL KryofluxFluxSourceProto::_internal_mutable_directory() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.directory_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE KryofluxFluxSourceProto::release_directory() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:KryofluxFluxSourceProto.directory)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.directory_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.directory_.Set("", GetArena());
  }
  return released;
}
inline void KryofluxFluxSourceProto::set_allocated_directory(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.directory_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.directory_.IsDefault()) {
    _impl_.directory_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:KryofluxFluxSourceProto.directory)
}

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

// ScpFluxSourceProto

// optional string filename = 1 [default = "flux.scp", json_name = "filename", (.help) = ".scp file to read flux from"];
inline bool ScpFluxSourceProto::has_filename() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void ScpFluxSourceProto::clear_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.ClearToDefault(::ScpFluxSourceProto::Impl_::_i_give_permission_to_break_this_code_default_filename_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& ScpFluxSourceProto::filename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ScpFluxSourceProto.filename)
  if (_impl_.filename_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_filename_.get();
  }
  return _internal_filename();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ScpFluxSourceProto::set_filename(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.filename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:ScpFluxSourceProto.filename)
}
inline ::std::string* PROTOBUF_NONNULL ScpFluxSourceProto::mutable_filename()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:ScpFluxSourceProto.filename)
  return _s;
}
inline const ::std::string& ScpFluxSourceProto::_internal_filename() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.filename_.Get();
}
inline void ScpFluxSourceProto::_internal_set_filename(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ScpFluxSourceProto::_internal_mutable_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.filename_.Mutable(::ScpFluxSourceProto::Impl_::_i_give_permission_to_break_this_code_default_filename_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ScpFluxSourceProto::release_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ScpFluxSourceProto.filename)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  return _impl_.filename_.Release();
}
inline void ScpFluxSourceProto::set_allocated_filename(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.filename_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:ScpFluxSourceProto.filename)
}

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

// A2rFluxSourceProto

// optional string filename = 1 [default = "flux.a2r", json_name = "filename", (.help) = ".a2r file to read flux from"];
inline bool A2rFluxSourceProto::has_filename() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void A2rFluxSourceProto::clear_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.ClearToDefault(::A2rFluxSourceProto::Impl_::_i_give_permission_to_break_this_code_default_filename_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& A2rFluxSourceProto::filename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:A2rFluxSourceProto.filename)
  if (_impl_.filename_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_filename_.get();
  }
  return _internal_filename();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void A2rFluxSourceProto::set_filename(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.filename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:A2rFluxSourceProto.filename)
}
inline ::std::string* PROTOBUF_NONNULL A2rFluxSourceProto::mutable_filename()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:A2rFluxSourceProto.filename)
  return _s;
}
inline const ::std::string& A2rFluxSourceProto::_internal_filename() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.filename_.Get();
}
inline void A2rFluxSourceProto::_internal_set_filename(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL A2rFluxSourceProto::_internal_mutable_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.filename_.Mutable(::A2rFluxSourceProto::Impl_::_i_give_permission_to_break_this_code_default_filename_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE A2rFluxSourceProto::release_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:A2rFluxSourceProto.filename)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  return _impl_.filename_.Release();
}
inline void A2rFluxSourceProto::set_allocated_filename(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.filename_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:A2rFluxSourceProto.filename)
}

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

// CwfFluxSourceProto

// optional string filename = 1 [default = "flux.cwf", json_name = "filename", (.help) = ".cwf file to read flux from"];
inline bool CwfFluxSourceProto::has_filename() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void CwfFluxSourceProto::clear_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.ClearToDefault(::CwfFluxSourceProto::Impl_::_i_give_permission_to_break_this_code_default_filename_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& CwfFluxSourceProto::filename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:CwfFluxSourceProto.filename)
  if (_impl_.filename_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_filename_.get();
  }
  return _internal_filename();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void CwfFluxSourceProto::set_filename(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.filename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:CwfFluxSourceProto.filename)
}
inline ::std::string* PROTOBUF_NONNULL CwfFluxSourceProto::mutable_filename()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:CwfFluxSourceProto.filename)
  return _s;
}
inline const ::std::string& CwfFluxSourceProto::_internal_filename() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.filename_.Get();
}
inline void CwfFluxSourceProto::_internal_set_filename(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL CwfFluxSourceProto::_internal_mutable_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.filename_.Mutable(::CwfFluxSourceProto::Impl_::_i_give_permission_to_break_this_code_default_filename_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE CwfFluxSourceProto::release_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:CwfFluxSourceProto.filename)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  return _impl_.filename_.Release();
}
inline void CwfFluxSourceProto::set_allocated_filename(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.filename_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:CwfFluxSourceProto.filename)
}

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

// DmkFluxSourceProto

// optional string directory = 1 [json_name = "directory", (.help) = "path to DMK directory"];
inline bool DmkFluxSourceProto::has_directory() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void DmkFluxSourceProto::clear_directory() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.directory_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& DmkFluxSourceProto::directory() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:DmkFluxSourceProto.directory)
  return _internal_directory();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void DmkFluxSourceProto::set_directory(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.directory_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:DmkFluxSourceProto.directory)
}
inline ::std::string* PROTOBUF_NONNULL DmkFluxSourceProto::mutable_directory()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_directory();
  // @@protoc_insertion_point(field_mutable:DmkFluxSourceProto.directory)
  return _s;
}
inline const ::std::string& DmkFluxSourceProto::_internal_directory() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.directory_.Get();
}
inline void DmkFluxSourceProto::_internal_set_directory(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.directory_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL DmkFluxSourceProto::_internal_mutable_directory() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.directory_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE DmkFluxSourceProto::release_directory() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:DmkFluxSourceProto.directory)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.directory_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.directory_.Set("", GetArena());
  }
  return released;
}
inline void DmkFluxSourceProto::set_allocated_directory(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.directory_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.directory_.IsDefault()) {
    _impl_.directory_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:DmkFluxSourceProto.directory)
}

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

// Fl2FluxSourceProto

// optional string filename = 1 [default = "flux.fl2", json_name = "filename", (.help) = ".fl2 file to read flux from"];
inline bool Fl2FluxSourceProto::has_filename() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void Fl2FluxSourceProto::clear_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.ClearToDefault(::Fl2FluxSourceProto::Impl_::_i_give_permission_to_break_this_code_default_filename_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& Fl2FluxSourceProto::filename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:Fl2FluxSourceProto.filename)
  if (_impl_.filename_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_filename_.get();
  }
  return _internal_filename();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void Fl2FluxSourceProto::set_filename(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.filename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:Fl2FluxSourceProto.filename)
}
inline ::std::string* PROTOBUF_NONNULL Fl2FluxSourceProto::mutable_filename()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:Fl2FluxSourceProto.filename)
  return _s;
}
inline const ::std::string& Fl2FluxSourceProto::_internal_filename() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.filename_.Get();
}
inline void Fl2FluxSourceProto::_internal_set_filename(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Fl2FluxSourceProto::_internal_mutable_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.filename_.Mutable(::Fl2FluxSourceProto::Impl_::_i_give_permission_to_break_this_code_default_filename_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Fl2FluxSourceProto::release_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:Fl2FluxSourceProto.filename)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  return _impl_.filename_.Release();
}
inline void Fl2FluxSourceProto::set_allocated_filename(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.filename_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:Fl2FluxSourceProto.filename)
}

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

// FlxFluxSourceProto

// optional string directory = 1 [json_name = "directory", (.help) = "path to FLX stream directory"];
inline bool FlxFluxSourceProto::has_directory() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void FlxFluxSourceProto::clear_directory() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.directory_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& FlxFluxSourceProto::directory() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FlxFluxSourceProto.directory)
  return _internal_directory();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void FlxFluxSourceProto::set_directory(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.directory_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:FlxFluxSourceProto.directory)
}
inline ::std::string* PROTOBUF_NONNULL FlxFluxSourceProto::mutable_directory()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_directory();
  // @@protoc_insertion_point(field_mutable:FlxFluxSourceProto.directory)
  return _s;
}
inline const ::std::string& FlxFluxSourceProto::_internal_directory() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.directory_.Get();
}
inline void FlxFluxSourceProto::_internal_set_directory(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.directory_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL FlxFluxSourceProto::_internal_mutable_directory() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.directory_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE FlxFluxSourceProto::release_directory() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FlxFluxSourceProto.directory)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.directory_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.directory_.Set("", GetArena());
  }
  return released;
}
inline void FlxFluxSourceProto::set_allocated_directory(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.directory_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.directory_.IsDefault()) {
    _impl_.directory_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:FlxFluxSourceProto.directory)
}

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

// FluxSourceProto

// optional .FluxSourceSinkType type = 9 [default = FLUXTYPE_NOT_SET, json_name = "type", (.help) = "flux source type"];
inline bool FluxSourceProto::has_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  return value;
}
inline void FluxSourceProto::clear_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
}
inline ::FluxSourceSinkType FluxSourceProto::type() const {
  // @@protoc_insertion_point(field_get:FluxSourceProto.type)
  return _internal_type();
}
inline void FluxSourceProto::set_type(::FluxSourceSinkType value) {
  _internal_set_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  // @@protoc_insertion_point(field_set:FluxSourceProto.type)
}
inline ::FluxSourceSinkType FluxSourceProto::_internal_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::FluxSourceSinkType>(_impl_.type_);
}
inline void FluxSourceProto::_internal_set_type(::FluxSourceSinkType value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::FluxSourceSinkType_internal_data_));
                                          _impl_.type_ = value;
}

// optional .A2rFluxSourceProto a2r = 11 [json_name = "a2r"];
inline bool FluxSourceProto::has_a2r() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  PROTOBUF_ASSUME(!value || _impl_.a2r_ != nullptr);
  return value;
}
inline void FluxSourceProto::clear_a2r() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.a2r_ != nullptr) _impl_.a2r_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
}
inline const ::A2rFluxSourceProto& FluxSourceProto::_internal_a2r() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::A2rFluxSourceProto* p = _impl_.a2r_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::A2rFluxSourceProto>(&::A2rFluxSourceProto_globals_);
}
inline const ::A2rFluxSourceProto& FluxSourceProto::a2r() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FluxSourceProto.a2r)
  return _internal_a2r();
}
inline void FluxSourceProto::unsafe_arena_set_allocated_a2r(
    ::A2rFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.a2r_);
  }
  _impl_.a2r_ = reinterpret_cast<::A2rFluxSourceProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FluxSourceProto.a2r)
}
inline ::A2rFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::release_a2r() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::A2rFluxSourceProto* released = _impl_.a2r_;
  _impl_.a2r_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::A2rFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::unsafe_arena_release_a2r() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FluxSourceProto.a2r)

  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::A2rFluxSourceProto* temp = _impl_.a2r_;
  _impl_.a2r_ = nullptr;
  return temp;
}
inline ::A2rFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::_internal_mutable_a2r() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.a2r_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::A2rFluxSourceProto>(GetArena());
    _impl_.a2r_ = reinterpret_cast<::A2rFluxSourceProto*>(p);
  }
  return _impl_.a2r_;
}
inline ::A2rFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::mutable_a2r()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::A2rFluxSourceProto* _msg = _internal_mutable_a2r();
  // @@protoc_insertion_point(field_mutable:FluxSourceProto.a2r)
  return _msg;
}
inline void FluxSourceProto::set_allocated_a2r(::A2rFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.a2r_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }

  _impl_.a2r_ = reinterpret_cast<::A2rFluxSourceProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FluxSourceProto.a2r)
}

// optional .CwfFluxSourceProto cwf = 7 [json_name = "cwf"];
inline bool FluxSourceProto::has_cwf() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  PROTOBUF_ASSUME(!value || _impl_.cwf_ != nullptr);
  return value;
}
inline void FluxSourceProto::clear_cwf() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.cwf_ != nullptr) _impl_.cwf_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline const ::CwfFluxSourceProto& FluxSourceProto::_internal_cwf() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::CwfFluxSourceProto* p = _impl_.cwf_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::CwfFluxSourceProto>(&::CwfFluxSourceProto_globals_);
}
inline const ::CwfFluxSourceProto& FluxSourceProto::cwf() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FluxSourceProto.cwf)
  return _internal_cwf();
}
inline void FluxSourceProto::unsafe_arena_set_allocated_cwf(
    ::CwfFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.cwf_);
  }
  _impl_.cwf_ = reinterpret_cast<::CwfFluxSourceProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FluxSourceProto.cwf)
}
inline ::CwfFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::release_cwf() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::CwfFluxSourceProto* released = _impl_.cwf_;
  _impl_.cwf_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::CwfFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::unsafe_arena_release_cwf() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FluxSourceProto.cwf)

  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::CwfFluxSourceProto* temp = _impl_.cwf_;
  _impl_.cwf_ = nullptr;
  return temp;
}
inline ::CwfFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::_internal_mutable_cwf() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.cwf_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::CwfFluxSourceProto>(GetArena());
    _impl_.cwf_ = reinterpret_cast<::CwfFluxSourceProto*>(p);
  }
  return _impl_.cwf_;
}
inline ::CwfFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::mutable_cwf()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::CwfFluxSourceProto* _msg = _internal_mutable_cwf();
  // @@protoc_insertion_point(field_mutable:FluxSourceProto.cwf)
  return _msg;
}
inline void FluxSourceProto::set_allocated_cwf(::CwfFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.cwf_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }

  _impl_.cwf_ = reinterpret_cast<::CwfFluxSourceProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FluxSourceProto.cwf)
}

// optional .DmkFluxSourceProto dmk = 12 [json_name = "dmk"];
inline bool FluxSourceProto::has_dmk() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  PROTOBUF_ASSUME(!value || _impl_.dmk_ != nullptr);
  return value;
}
inline void FluxSourceProto::clear_dmk() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.dmk_ != nullptr) _impl_.dmk_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
}
inline const ::DmkFluxSourceProto& FluxSourceProto::_internal_dmk() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::DmkFluxSourceProto* p = _impl_.dmk_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::DmkFluxSourceProto>(&::DmkFluxSourceProto_globals_);
}
inline const ::DmkFluxSourceProto& FluxSourceProto::dmk() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FluxSourceProto.dmk)
  return _internal_dmk();
}
inline void FluxSourceProto::unsafe_arena_set_allocated_dmk(
    ::DmkFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.dmk_);
  }
  _impl_.dmk_ = reinterpret_cast<::DmkFluxSourceProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FluxSourceProto.dmk)
}
inline ::DmkFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::release_dmk() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::DmkFluxSourceProto* released = _impl_.dmk_;
  _impl_.dmk_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::DmkFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::unsafe_arena_release_dmk() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FluxSourceProto.dmk)

  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::DmkFluxSourceProto* temp = _impl_.dmk_;
  _impl_.dmk_ = nullptr;
  return temp;
}
inline ::DmkFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::_internal_mutable_dmk() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.dmk_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::DmkFluxSourceProto>(GetArena());
    _impl_.dmk_ = reinterpret_cast<::DmkFluxSourceProto*>(p);
  }
  return _impl_.dmk_;
}
inline ::DmkFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::mutable_dmk()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::DmkFluxSourceProto* _msg = _internal_mutable_dmk();
  // @@protoc_insertion_point(field_mutable:FluxSourceProto.dmk)
  return _msg;
}
inline void FluxSourceProto::set_allocated_dmk(::DmkFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.dmk_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }

  _impl_.dmk_ = reinterpret_cast<::DmkFluxSourceProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FluxSourceProto.dmk)
}

// optional .EraseFluxSourceProto erase = 4 [json_name = "erase"];
inline bool FluxSourceProto::has_erase() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.erase_ != nullptr);
  return value;
}
inline void FluxSourceProto::clear_erase() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.erase_ != nullptr) _impl_.erase_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::EraseFluxSourceProto& FluxSourceProto::_internal_erase() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::EraseFluxSourceProto* p = _impl_.erase_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::EraseFluxSourceProto>(&::EraseFluxSourceProto_globals_);
}
inline const ::EraseFluxSourceProto& FluxSourceProto::erase() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FluxSourceProto.erase)
  return _internal_erase();
}
inline void FluxSourceProto::unsafe_arena_set_allocated_erase(
    ::EraseFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.erase_);
  }
  _impl_.erase_ = reinterpret_cast<::EraseFluxSourceProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FluxSourceProto.erase)
}
inline ::EraseFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::release_erase() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::EraseFluxSourceProto* released = _impl_.erase_;
  _impl_.erase_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::EraseFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::unsafe_arena_release_erase() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FluxSourceProto.erase)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::EraseFluxSourceProto* temp = _impl_.erase_;
  _impl_.erase_ = nullptr;
  return temp;
}
inline ::EraseFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::_internal_mutable_erase() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.erase_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::EraseFluxSourceProto>(GetArena());
    _impl_.erase_ = reinterpret_cast<::EraseFluxSourceProto*>(p);
  }
  return _impl_.erase_;
}
inline ::EraseFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::mutable_erase()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::EraseFluxSourceProto* _msg = _internal_mutable_erase();
  // @@protoc_insertion_point(field_mutable:FluxSourceProto.erase)
  return _msg;
}
inline void FluxSourceProto::set_allocated_erase(::EraseFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.erase_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }

  _impl_.erase_ = reinterpret_cast<::EraseFluxSourceProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FluxSourceProto.erase)
}

// optional .Fl2FluxSourceProto fl2 = 8 [json_name = "fl2"];
inline bool FluxSourceProto::has_fl2() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  PROTOBUF_ASSUME(!value || _impl_.fl2_ != nullptr);
  return value;
}
inline void FluxSourceProto::clear_fl2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.fl2_ != nullptr) _impl_.fl2_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline const ::Fl2FluxSourceProto& FluxSourceProto::_internal_fl2() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::Fl2FluxSourceProto* p = _impl_.fl2_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::Fl2FluxSourceProto>(&::Fl2FluxSourceProto_globals_);
}
inline const ::Fl2FluxSourceProto& FluxSourceProto::fl2() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FluxSourceProto.fl2)
  return _internal_fl2();
}
inline void FluxSourceProto::unsafe_arena_set_allocated_fl2(
    ::Fl2FluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.fl2_);
  }
  _impl_.fl2_ = reinterpret_cast<::Fl2FluxSourceProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FluxSourceProto.fl2)
}
inline ::Fl2FluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::release_fl2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::Fl2FluxSourceProto* released = _impl_.fl2_;
  _impl_.fl2_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::Fl2FluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::unsafe_arena_release_fl2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FluxSourceProto.fl2)

  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::Fl2FluxSourceProto* temp = _impl_.fl2_;
  _impl_.fl2_ = nullptr;
  return temp;
}
inline ::Fl2FluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::_internal_mutable_fl2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.fl2_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::Fl2FluxSourceProto>(GetArena());
    _impl_.fl2_ = reinterpret_cast<::Fl2FluxSourceProto*>(p);
  }
  return _impl_.fl2_;
}
inline ::Fl2FluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::mutable_fl2()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::Fl2FluxSourceProto* _msg = _internal_mutable_fl2();
  // @@protoc_insertion_point(field_mutable:FluxSourceProto.fl2)
  return _msg;
}
inline void FluxSourceProto::set_allocated_fl2(::Fl2FluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.fl2_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }

  _impl_.fl2_ = reinterpret_cast<::Fl2FluxSourceProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FluxSourceProto.fl2)
}

// optional .FlxFluxSourceProto flx = 10 [json_name = "flx"];
inline bool FluxSourceProto::has_flx() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  PROTOBUF_ASSUME(!value || _impl_.flx_ != nullptr);
  return value;
}
inline void FluxSourceProto::clear_flx() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.flx_ != nullptr) _impl_.flx_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
}
inline const ::FlxFluxSourceProto& FluxSourceProto::_internal_flx() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::FlxFluxSourceProto* p = _impl_.flx_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::FlxFluxSourceProto>(&::FlxFluxSourceProto_globals_);
}
inline const ::FlxFluxSourceProto& FluxSourceProto::flx() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FluxSourceProto.flx)
  return _internal_flx();
}
inline void FluxSourceProto::unsafe_arena_set_allocated_flx(
    ::FlxFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.flx_);
  }
  _impl_.flx_ = reinterpret_cast<::FlxFluxSourceProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FluxSourceProto.flx)
}
inline ::FlxFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::release_flx() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::FlxFluxSourceProto* released = _impl_.flx_;
  _impl_.flx_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::FlxFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::unsafe_arena_release_flx() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FluxSourceProto.flx)

  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::FlxFluxSourceProto* temp = _impl_.flx_;
  _impl_.flx_ = nullptr;
  return temp;
}
inline ::FlxFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::_internal_mutable_flx() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.flx_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::FlxFluxSourceProto>(GetArena());
    _impl_.flx_ = reinterpret_cast<::FlxFluxSourceProto*>(p);
  }
  return _impl_.flx_;
}
inline ::FlxFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::mutable_flx()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::FlxFluxSourceProto* _msg = _internal_mutable_flx();
  // @@protoc_insertion_point(field_mutable:FluxSourceProto.flx)
  return _msg;
}
inline void FluxSourceProto::set_allocated_flx(::FlxFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.flx_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }

  _impl_.flx_ = reinterpret_cast<::FlxFluxSourceProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FluxSourceProto.flx)
}

// optional .HardwareFluxSourceProto drive = 2 [json_name = "drive"];
inline bool FluxSourceProto::has_drive() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.drive_ != nullptr);
  return value;
}
inline void FluxSourceProto::clear_drive() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.drive_ != nullptr) _impl_.drive_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::HardwareFluxSourceProto& FluxSourceProto::_internal_drive() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::HardwareFluxSourceProto* p = _impl_.drive_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::HardwareFluxSourceProto>(&::HardwareFluxSourceProto_globals_);
}
inline const ::HardwareFluxSourceProto& FluxSourceProto::drive() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FluxSourceProto.drive)
  return _internal_drive();
}
inline void FluxSourceProto::unsafe_arena_set_allocated_drive(
    ::HardwareFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.drive_);
  }
  _impl_.drive_ = reinterpret_cast<::HardwareFluxSourceProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FluxSourceProto.drive)
}
inline ::HardwareFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::release_drive() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::HardwareFluxSourceProto* released = _impl_.drive_;
  _impl_.drive_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::HardwareFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::unsafe_arena_release_drive() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FluxSourceProto.drive)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::HardwareFluxSourceProto* temp = _impl_.drive_;
  _impl_.drive_ = nullptr;
  return temp;
}
inline ::HardwareFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::_internal_mutable_drive() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.drive_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::HardwareFluxSourceProto>(GetArena());
    _impl_.drive_ = reinterpret_cast<::HardwareFluxSourceProto*>(p);
  }
  return _impl_.drive_;
}
inline ::HardwareFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::mutable_drive()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::HardwareFluxSourceProto* _msg = _internal_mutable_drive();
  // @@protoc_insertion_point(field_mutable:FluxSourceProto.drive)
  return _msg;
}
inline void FluxSourceProto::set_allocated_drive(::HardwareFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.drive_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }

  _impl_.drive_ = reinterpret_cast<::HardwareFluxSourceProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FluxSourceProto.drive)
}

// optional .KryofluxFluxSourceProto kryoflux = 5 [json_name = "kryoflux"];
inline bool FluxSourceProto::has_kryoflux() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  PROTOBUF_ASSUME(!value || _impl_.kryoflux_ != nullptr);
  return value;
}
inline void FluxSourceProto::clear_kryoflux() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.kryoflux_ != nullptr) _impl_.kryoflux_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::KryofluxFluxSourceProto& FluxSourceProto::_internal_kryoflux() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::KryofluxFluxSourceProto* p = _impl_.kryoflux_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::KryofluxFluxSourceProto>(&::KryofluxFluxSourceProto_globals_);
}
inline const ::KryofluxFluxSourceProto& FluxSourceProto::kryoflux() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FluxSourceProto.kryoflux)
  return _internal_kryoflux();
}
inline void FluxSourceProto::unsafe_arena_set_allocated_kryoflux(
    ::KryofluxFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.kryoflux_);
  }
  _impl_.kryoflux_ = reinterpret_cast<::KryofluxFluxSourceProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FluxSourceProto.kryoflux)
}
inline ::KryofluxFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::release_kryoflux() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::KryofluxFluxSourceProto* released = _impl_.kryoflux_;
  _impl_.kryoflux_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::KryofluxFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::unsafe_arena_release_kryoflux() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FluxSourceProto.kryoflux)

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::KryofluxFluxSourceProto* temp = _impl_.kryoflux_;
  _impl_.kryoflux_ = nullptr;
  return temp;
}
inline ::KryofluxFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::_internal_mutable_kryoflux() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.kryoflux_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::KryofluxFluxSourceProto>(GetArena());
    _impl_.kryoflux_ = reinterpret_cast<::KryofluxFluxSourceProto*>(p);
  }
  return _impl_.kryoflux_;
}
inline ::KryofluxFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::mutable_kryoflux()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::KryofluxFluxSourceProto* _msg = _internal_mutable_kryoflux();
  // @@protoc_insertion_point(field_mutable:FluxSourceProto.kryoflux)
  return _msg;
}
inline void FluxSourceProto::set_allocated_kryoflux(::KryofluxFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.kryoflux_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }

  _impl_.kryoflux_ = reinterpret_cast<::KryofluxFluxSourceProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FluxSourceProto.kryoflux)
}

// optional .ScpFluxSourceProto scp = 6 [json_name = "scp"];
inline bool FluxSourceProto::has_scp() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  PROTOBUF_ASSUME(!value || _impl_.scp_ != nullptr);
  return value;
}
inline void FluxSourceProto::clear_scp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.scp_ != nullptr) _impl_.scp_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::ScpFluxSourceProto& FluxSourceProto::_internal_scp() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::ScpFluxSourceProto* p = _impl_.scp_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::ScpFluxSourceProto>(&::ScpFluxSourceProto_globals_);
}
inline const ::ScpFluxSourceProto& FluxSourceProto::scp() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FluxSourceProto.scp)
  return _internal_scp();
}
inline void FluxSourceProto::unsafe_arena_set_allocated_scp(
    ::ScpFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.scp_);
  }
  _impl_.scp_ = reinterpret_cast<::ScpFluxSourceProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FluxSourceProto.scp)
}
inline ::ScpFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::release_scp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::ScpFluxSourceProto* released = _impl_.scp_;
  _impl_.scp_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::ScpFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::unsafe_arena_release_scp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FluxSourceProto.scp)

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::ScpFluxSourceProto* temp = _impl_.scp_;
  _impl_.scp_ = nullptr;
  return temp;
}
inline ::ScpFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::_internal_mutable_scp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.scp_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::ScpFluxSourceProto>(GetArena());
    _impl_.scp_ = reinterpret_cast<::ScpFluxSourceProto*>(p);
  }
  return _impl_.scp_;
}
inline ::ScpFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::mutable_scp()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::ScpFluxSourceProto* _msg = _internal_mutable_scp();
  // @@protoc_insertion_point(field_mutable:FluxSourceProto.scp)
  return _msg;
}
inline void FluxSourceProto::set_allocated_scp(::ScpFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.scp_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }

  _impl_.scp_ = reinterpret_cast<::ScpFluxSourceProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FluxSourceProto.scp)
}

// optional .TestPatternFluxSourceProto test_pattern = 3 [json_name = "testPattern"];
inline bool FluxSourceProto::has_test_pattern() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.test_pattern_ != nullptr);
  return value;
}
inline void FluxSourceProto::clear_test_pattern() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.test_pattern_ != nullptr) _impl_.test_pattern_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::TestPatternFluxSourceProto& FluxSourceProto::_internal_test_pattern() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::TestPatternFluxSourceProto* p = _impl_.test_pattern_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::TestPatternFluxSourceProto>(&::TestPatternFluxSourceProto_globals_);
}
inline const ::TestPatternFluxSourceProto& FluxSourceProto::test_pattern() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FluxSourceProto.test_pattern)
  return _internal_test_pattern();
}
inline void FluxSourceProto::unsafe_arena_set_allocated_test_pattern(
    ::TestPatternFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.test_pattern_);
  }
  _impl_.test_pattern_ = reinterpret_cast<::TestPatternFluxSourceProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:FluxSourceProto.test_pattern)
}
inline ::TestPatternFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::release_test_pattern() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::TestPatternFluxSourceProto* released = _impl_.test_pattern_;
  _impl_.test_pattern_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::TestPatternFluxSourceProto* PROTOBUF_NULLABLE FluxSourceProto::unsafe_arena_release_test_pattern() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FluxSourceProto.test_pattern)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::TestPatternFluxSourceProto* temp = _impl_.test_pattern_;
  _impl_.test_pattern_ = nullptr;
  return temp;
}
inline ::TestPatternFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::_internal_mutable_test_pattern() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.test_pattern_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::TestPatternFluxSourceProto>(GetArena());
    _impl_.test_pattern_ = reinterpret_cast<::TestPatternFluxSourceProto*>(p);
  }
  return _impl_.test_pattern_;
}
inline ::TestPatternFluxSourceProto* PROTOBUF_NONNULL FluxSourceProto::mutable_test_pattern()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::TestPatternFluxSourceProto* _msg = _internal_mutable_test_pattern();
  // @@protoc_insertion_point(field_mutable:FluxSourceProto.test_pattern)
  return _msg;
}
inline void FluxSourceProto::set_allocated_test_pattern(::TestPatternFluxSourceProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.test_pattern_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }

  _impl_.test_pattern_ = reinterpret_cast<::TestPatternFluxSourceProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FluxSourceProto.test_pattern)
}

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

// @@protoc_insertion_point(namespace_scope)


// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"
// clang-format on

#endif  // lib_2ffluxsource_2ffluxsource_2eproto_2epb_2eh
