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

#ifndef lib_2ffluxsink_2ffluxsink_2eproto_2epb_2eh
#define lib_2ffluxsink_2ffluxsink_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_2ffluxsink_2ffluxsink_2eproto

// Internal implementation detail -- do not use these members.
struct TableStruct_lib_2ffluxsink_2ffluxsink_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_lib_2ffluxsink_2ffluxsink_2eproto;
}  // extern "C"
class A2RFluxSinkProto;
struct A2RFluxSinkProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern A2RFluxSinkProtoGlobalsTypeInternal A2RFluxSinkProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull A2RFluxSinkProto_class_data_;
#else
extern const A2RFluxSinkProtoGlobalsTypeInternal A2RFluxSinkProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class AuFluxSinkProto;
struct AuFluxSinkProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern AuFluxSinkProtoGlobalsTypeInternal AuFluxSinkProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull AuFluxSinkProto_class_data_;
#else
extern const AuFluxSinkProtoGlobalsTypeInternal AuFluxSinkProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class Fl2FluxSinkProto;
struct Fl2FluxSinkProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern Fl2FluxSinkProtoGlobalsTypeInternal Fl2FluxSinkProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull Fl2FluxSinkProto_class_data_;
#else
extern const Fl2FluxSinkProtoGlobalsTypeInternal Fl2FluxSinkProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class FluxSinkProto;
struct FluxSinkProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern FluxSinkProtoGlobalsTypeInternal FluxSinkProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull FluxSinkProto_class_data_;
#else
extern const FluxSinkProtoGlobalsTypeInternal FluxSinkProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class HardwareFluxSinkProto;
struct HardwareFluxSinkProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern HardwareFluxSinkProtoGlobalsTypeInternal HardwareFluxSinkProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull HardwareFluxSinkProto_class_data_;
#else
extern const HardwareFluxSinkProtoGlobalsTypeInternal HardwareFluxSinkProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class ScpFluxSinkProto;
struct ScpFluxSinkProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ScpFluxSinkProtoGlobalsTypeInternal ScpFluxSinkProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull ScpFluxSinkProto_class_data_;
#else
extern const ScpFluxSinkProtoGlobalsTypeInternal ScpFluxSinkProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class VcdFluxSinkProto;
struct VcdFluxSinkProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern VcdFluxSinkProtoGlobalsTypeInternal VcdFluxSinkProto_globals_;
extern const ::google::protobuf::internal::ClassDataFull VcdFluxSinkProto_class_data_;
#else
extern const VcdFluxSinkProtoGlobalsTypeInternal VcdFluxSinkProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google


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


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

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

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

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

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

  inline VcdFluxSinkProto(const VcdFluxSinkProto& from) : VcdFluxSinkProto(nullptr, from) {}
  inline VcdFluxSinkProto(VcdFluxSinkProto&& from) noexcept : VcdFluxSinkProto(nullptr, ::std::move(from)) {}
  inline VcdFluxSinkProto& operator=(const VcdFluxSinkProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline VcdFluxSinkProto& operator=(VcdFluxSinkProto&& 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 VcdFluxSinkProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<VcdFluxSinkProto>(&VcdFluxSinkProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(VcdFluxSinkProto& a, VcdFluxSinkProto& b) { a.Swap(&b); }
  inline void Swap(VcdFluxSinkProto* 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(VcdFluxSinkProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] VcdFluxSinkProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<VcdFluxSinkProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const VcdFluxSinkProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const VcdFluxSinkProto& from) { VcdFluxSinkProto::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(VcdFluxSinkProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "VcdFluxSinkProto"; }

  explicit VcdFluxSinkProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  VcdFluxSinkProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const VcdFluxSinkProto& from);
  VcdFluxSinkProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, VcdFluxSinkProto&& from) noexcept
      : VcdFluxSinkProto(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 [default = "vcdfiles", json_name = "directory", (.help) = "directory to write .vcd files to"];
  [[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:VcdFluxSinkProto)
 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 VcdFluxSinkProto& 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_directory_;
    ::google::protobuf::internal::ArenaStringPtr directory_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2ffluxsink_2ffluxsink_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline ScpFluxSinkProto(const ScpFluxSinkProto& from) : ScpFluxSinkProto(nullptr, from) {}
  inline ScpFluxSinkProto(ScpFluxSinkProto&& from) noexcept : ScpFluxSinkProto(nullptr, ::std::move(from)) {}
  inline ScpFluxSinkProto& operator=(const ScpFluxSinkProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ScpFluxSinkProto& operator=(ScpFluxSinkProto&& 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 ScpFluxSinkProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<ScpFluxSinkProto>(&ScpFluxSinkProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 4;
  friend void swap(ScpFluxSinkProto& a, ScpFluxSinkProto& b) { a.Swap(&b); }
  inline void Swap(ScpFluxSinkProto* 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(ScpFluxSinkProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] ScpFluxSinkProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<ScpFluxSinkProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const ScpFluxSinkProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const ScpFluxSinkProto& from) { ScpFluxSinkProto::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(ScpFluxSinkProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "ScpFluxSinkProto"; }

  explicit ScpFluxSinkProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ScpFluxSinkProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ScpFluxSinkProto& from);
  ScpFluxSinkProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ScpFluxSinkProto&& from) noexcept
      : ScpFluxSinkProto(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 = 2,
    kAlignWithIndexFieldNumber = 3,
    kTypeByteFieldNumber = 4,
  };
  // optional string filename = 2 [default = "flux.scp", json_name = "filename", (.help) = ".scp file to write to"];
  [[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:
  // optional bool align_with_index = 3 [default = false, json_name = "alignWithIndex", (.help) = "discard data before the first index pulse"];
  [[nodiscard]] bool has_align_with_index() const;
  void clear_align_with_index() ;
  [[nodiscard]] bool align_with_index() const;
  void set_align_with_index(bool value);

  private:
  bool _internal_align_with_index() const;
  void _internal_set_align_with_index(bool value);

  public:
  // optional int32 type_byte = 4 [default = 255, json_name = "typeByte", (.help) = "set the SCP disk type byte"];
  [[nodiscard]] bool has_type_byte() const;
  void clear_type_byte() ;
  [[nodiscard]] ::int32_t type_byte() const;
  void set_type_byte(::int32_t value);

  private:
  ::int32_t _internal_type_byte() const;
  void _internal_set_type_byte(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:ScpFluxSinkProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 3,
                          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 ScpFluxSinkProto& 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_;
    bool align_with_index_;
    ::int32_t type_byte_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2ffluxsink_2ffluxsink_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline HardwareFluxSinkProto(const HardwareFluxSinkProto& from) : HardwareFluxSinkProto(nullptr, from) {}
  inline HardwareFluxSinkProto(HardwareFluxSinkProto&& from) noexcept : HardwareFluxSinkProto(nullptr, ::std::move(from)) {}
  inline HardwareFluxSinkProto& operator=(const HardwareFluxSinkProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline HardwareFluxSinkProto& operator=(HardwareFluxSinkProto&& 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 HardwareFluxSinkProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<HardwareFluxSinkProto>(&HardwareFluxSinkProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(HardwareFluxSinkProto& a, HardwareFluxSinkProto& b) { a.Swap(&b); }
  inline void Swap(HardwareFluxSinkProto* 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(HardwareFluxSinkProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

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

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

  explicit HardwareFluxSinkProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  HardwareFluxSinkProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const HardwareFluxSinkProto& from);
  HardwareFluxSinkProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, HardwareFluxSinkProto&& from) noexcept
      : HardwareFluxSinkProto(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:HardwareFluxSinkProto)
 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_2ffluxsink_2ffluxsink_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline Fl2FluxSinkProto(const Fl2FluxSinkProto& from) : Fl2FluxSinkProto(nullptr, from) {}
  inline Fl2FluxSinkProto(Fl2FluxSinkProto&& from) noexcept : Fl2FluxSinkProto(nullptr, ::std::move(from)) {}
  inline Fl2FluxSinkProto& operator=(const Fl2FluxSinkProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline Fl2FluxSinkProto& operator=(Fl2FluxSinkProto&& 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 Fl2FluxSinkProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<Fl2FluxSinkProto>(&Fl2FluxSinkProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 5;
  friend void swap(Fl2FluxSinkProto& a, Fl2FluxSinkProto& b) { a.Swap(&b); }
  inline void Swap(Fl2FluxSinkProto* 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(Fl2FluxSinkProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] Fl2FluxSinkProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<Fl2FluxSinkProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const Fl2FluxSinkProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const Fl2FluxSinkProto& from) { Fl2FluxSinkProto::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(Fl2FluxSinkProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "Fl2FluxSinkProto"; }

  explicit Fl2FluxSinkProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  Fl2FluxSinkProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Fl2FluxSinkProto& from);
  Fl2FluxSinkProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Fl2FluxSinkProto&& from) noexcept
      : Fl2FluxSinkProto(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 write to"];
  [[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:Fl2FluxSinkProto)
 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 Fl2FluxSinkProto& 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_2ffluxsink_2ffluxsink_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline AuFluxSinkProto(const AuFluxSinkProto& from) : AuFluxSinkProto(nullptr, from) {}
  inline AuFluxSinkProto(AuFluxSinkProto&& from) noexcept : AuFluxSinkProto(nullptr, ::std::move(from)) {}
  inline AuFluxSinkProto& operator=(const AuFluxSinkProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline AuFluxSinkProto& operator=(AuFluxSinkProto&& 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 AuFluxSinkProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<AuFluxSinkProto>(&AuFluxSinkProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(AuFluxSinkProto& a, AuFluxSinkProto& b) { a.Swap(&b); }
  inline void Swap(AuFluxSinkProto* 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(AuFluxSinkProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] AuFluxSinkProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<AuFluxSinkProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const AuFluxSinkProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const AuFluxSinkProto& from) { AuFluxSinkProto::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(AuFluxSinkProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "AuFluxSinkProto"; }

  explicit AuFluxSinkProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  AuFluxSinkProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const AuFluxSinkProto& from);
  AuFluxSinkProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, AuFluxSinkProto&& from) noexcept
      : AuFluxSinkProto(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,
    kIndexMarkersFieldNumber = 2,
  };
  // optional string directory = 1 [default = "aufiles", json_name = "directory", (.help) = "directory to write .au files to"];
  [[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:
  // optional bool index_markers = 2 [default = true, json_name = "indexMarkers", (.help) = "show index markers in the right-hand channel"];
  [[nodiscard]] bool has_index_markers() const;
  void clear_index_markers() ;
  [[nodiscard]] bool index_markers() const;
  void set_index_markers(bool value);

  private:
  bool _internal_index_markers() const;
  void _internal_set_index_markers(bool value);

  public:
  // @@protoc_insertion_point(class_scope:AuFluxSinkProto)
 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 AuFluxSinkProto& 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_directory_;
    ::google::protobuf::internal::ArenaStringPtr directory_;
    bool index_markers_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2ffluxsink_2ffluxsink_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline A2RFluxSinkProto(const A2RFluxSinkProto& from) : A2RFluxSinkProto(nullptr, from) {}
  inline A2RFluxSinkProto(A2RFluxSinkProto&& from) noexcept : A2RFluxSinkProto(nullptr, ::std::move(from)) {}
  inline A2RFluxSinkProto& operator=(const A2RFluxSinkProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline A2RFluxSinkProto& operator=(A2RFluxSinkProto&& 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 A2RFluxSinkProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<A2RFluxSinkProto>(&A2RFluxSinkProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(A2RFluxSinkProto& a, A2RFluxSinkProto& b) { a.Swap(&b); }
  inline void Swap(A2RFluxSinkProto* 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(A2RFluxSinkProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] A2RFluxSinkProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<A2RFluxSinkProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const A2RFluxSinkProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const A2RFluxSinkProto& from) { A2RFluxSinkProto::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(A2RFluxSinkProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "A2RFluxSinkProto"; }

  explicit A2RFluxSinkProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  A2RFluxSinkProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const A2RFluxSinkProto& from);
  A2RFluxSinkProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, A2RFluxSinkProto&& from) noexcept
      : A2RFluxSinkProto(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 write to"];
  [[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:A2RFluxSinkProto)
 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 A2RFluxSinkProto& 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_2ffluxsink_2ffluxsink_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

  inline FluxSinkProto(const FluxSinkProto& from) : FluxSinkProto(nullptr, from) {}
  inline FluxSinkProto(FluxSinkProto&& from) noexcept : FluxSinkProto(nullptr, ::std::move(from)) {}
  inline FluxSinkProto& operator=(const FluxSinkProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline FluxSinkProto& operator=(FluxSinkProto&& 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 FluxSinkProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<FluxSinkProto>(&FluxSinkProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 6;
  friend void swap(FluxSinkProto& a, FluxSinkProto& b) { a.Swap(&b); }
  inline void Swap(FluxSinkProto* 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(FluxSinkProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] FluxSinkProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return Super_::DefaultConstruct<FluxSinkProto>(arena);
  }
  using Super_::CopyFrom;
  void CopyFrom(const FluxSinkProto& from);
  using Super_::MergeFrom;
  void MergeFrom(const FluxSinkProto& from) { FluxSinkProto::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(FluxSinkProto* PROTOBUF_NONNULL other);
 private:
  static ::absl::string_view FullMessageName() { return "FluxSinkProto"; }

  explicit FluxSinkProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  FluxSinkProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const FluxSinkProto& from);
  FluxSinkProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, FluxSinkProto&& from) noexcept
      : FluxSinkProto(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,
    kAuFieldNumber = 3,
    kVcdFieldNumber = 4,
    kScpFieldNumber = 5,
    kFl2FieldNumber = 6,
    kA2RFieldNumber = 8,
    kTypeFieldNumber = 9,
  };
  // optional .HardwareFluxSinkProto drive = 2 [json_name = "drive"];
  [[nodiscard]] bool has_drive() const;
  void clear_drive() ;
  [[nodiscard]] const ::HardwareFluxSinkProto& drive() const;
  [[nodiscard]] ::HardwareFluxSinkProto* PROTOBUF_NULLABLE release_drive();
  ::HardwareFluxSinkProto* PROTOBUF_NONNULL mutable_drive();
  void set_allocated_drive(::HardwareFluxSinkProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_drive(::HardwareFluxSinkProto* PROTOBUF_NULLABLE value);
  ::HardwareFluxSinkProto* PROTOBUF_NULLABLE unsafe_arena_release_drive();

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

  public:
  // optional .AuFluxSinkProto au = 3 [json_name = "au"];
  [[nodiscard]] bool has_au() const;
  void clear_au() ;
  [[nodiscard]] const ::AuFluxSinkProto& au() const;
  [[nodiscard]] ::AuFluxSinkProto* PROTOBUF_NULLABLE release_au();
  ::AuFluxSinkProto* PROTOBUF_NONNULL mutable_au();
  void set_allocated_au(::AuFluxSinkProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_au(::AuFluxSinkProto* PROTOBUF_NULLABLE value);
  ::AuFluxSinkProto* PROTOBUF_NULLABLE unsafe_arena_release_au();

  private:
  const ::AuFluxSinkProto& _internal_au() const;
  ::AuFluxSinkProto* PROTOBUF_NONNULL _internal_mutable_au();

  public:
  // optional .VcdFluxSinkProto vcd = 4 [json_name = "vcd"];
  [[nodiscard]] bool has_vcd() const;
  void clear_vcd() ;
  [[nodiscard]] const ::VcdFluxSinkProto& vcd() const;
  [[nodiscard]] ::VcdFluxSinkProto* PROTOBUF_NULLABLE release_vcd();
  ::VcdFluxSinkProto* PROTOBUF_NONNULL mutable_vcd();
  void set_allocated_vcd(::VcdFluxSinkProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_vcd(::VcdFluxSinkProto* PROTOBUF_NULLABLE value);
  ::VcdFluxSinkProto* PROTOBUF_NULLABLE unsafe_arena_release_vcd();

  private:
  const ::VcdFluxSinkProto& _internal_vcd() const;
  ::VcdFluxSinkProto* PROTOBUF_NONNULL _internal_mutable_vcd();

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

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

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

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

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

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

  public:
  // optional .FluxSourceSinkType type = 9 [default = FLUXTYPE_NOT_SET, json_name = "type", (.help) = "flux sink 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:FluxSinkProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<3, 7,
                          7, 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 FluxSinkProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::HardwareFluxSinkProto* PROTOBUF_NULLABLE drive_;
    ::AuFluxSinkProto* PROTOBUF_NULLABLE au_;
    ::VcdFluxSinkProto* PROTOBUF_NULLABLE vcd_;
    ::ScpFluxSinkProto* PROTOBUF_NULLABLE scp_;
    ::Fl2FluxSinkProto* PROTOBUF_NULLABLE fl2_;
    ::A2RFluxSinkProto* PROTOBUF_NULLABLE a2r_;
    int type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_lib_2ffluxsink_2ffluxsink_2eproto;
};

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




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


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

// HardwareFluxSinkProto

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

// AuFluxSinkProto

// optional string directory = 1 [default = "aufiles", json_name = "directory", (.help) = "directory to write .au files to"];
inline bool AuFluxSinkProto::has_directory() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void AuFluxSinkProto::clear_directory() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.directory_.ClearToDefault(::AuFluxSinkProto::Impl_::_i_give_permission_to_break_this_code_default_directory_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& AuFluxSinkProto::directory() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:AuFluxSinkProto.directory)
  if (_impl_.directory_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_directory_.get();
  }
  return _internal_directory();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AuFluxSinkProto::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:AuFluxSinkProto.directory)
}
inline ::std::string* PROTOBUF_NONNULL AuFluxSinkProto::mutable_directory()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_directory();
  // @@protoc_insertion_point(field_mutable:AuFluxSinkProto.directory)
  return _s;
}
inline const ::std::string& AuFluxSinkProto::_internal_directory() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.directory_.Get();
}
inline void AuFluxSinkProto::_internal_set_directory(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.directory_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AuFluxSinkProto::_internal_mutable_directory() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.directory_.Mutable(::AuFluxSinkProto::Impl_::_i_give_permission_to_break_this_code_default_directory_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AuFluxSinkProto::release_directory() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:AuFluxSinkProto.directory)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  return _impl_.directory_.Release();
}
inline void AuFluxSinkProto::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());
  // @@protoc_insertion_point(field_set_allocated:AuFluxSinkProto.directory)
}

// optional bool index_markers = 2 [default = true, json_name = "indexMarkers", (.help) = "show index markers in the right-hand channel"];
inline bool AuFluxSinkProto::has_index_markers() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void AuFluxSinkProto::clear_index_markers() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.index_markers_ = true;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline bool AuFluxSinkProto::index_markers() const {
  // @@protoc_insertion_point(field_get:AuFluxSinkProto.index_markers)
  return _internal_index_markers();
}
inline void AuFluxSinkProto::set_index_markers(bool value) {
  _internal_set_index_markers(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:AuFluxSinkProto.index_markers)
}
inline bool AuFluxSinkProto::_internal_index_markers() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.index_markers_;
}
inline void AuFluxSinkProto::_internal_set_index_markers(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.index_markers_ = value;
}

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

// A2RFluxSinkProto

// optional string filename = 1 [default = "flux.a2r", json_name = "filename", (.help) = ".a2r file to write to"];
inline bool A2RFluxSinkProto::has_filename() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void A2RFluxSinkProto::clear_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.ClearToDefault(::A2RFluxSinkProto::Impl_::_i_give_permission_to_break_this_code_default_filename_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& A2RFluxSinkProto::filename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:A2RFluxSinkProto.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 A2RFluxSinkProto::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:A2RFluxSinkProto.filename)
}
inline ::std::string* PROTOBUF_NONNULL A2RFluxSinkProto::mutable_filename()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:A2RFluxSinkProto.filename)
  return _s;
}
inline const ::std::string& A2RFluxSinkProto::_internal_filename() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.filename_.Get();
}
inline void A2RFluxSinkProto::_internal_set_filename(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL A2RFluxSinkProto::_internal_mutable_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.filename_.Mutable(::A2RFluxSinkProto::Impl_::_i_give_permission_to_break_this_code_default_filename_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE A2RFluxSinkProto::release_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:A2RFluxSinkProto.filename)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  return _impl_.filename_.Release();
}
inline void A2RFluxSinkProto::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:A2RFluxSinkProto.filename)
}

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

// VcdFluxSinkProto

// optional string directory = 1 [default = "vcdfiles", json_name = "directory", (.help) = "directory to write .vcd files to"];
inline bool VcdFluxSinkProto::has_directory() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void VcdFluxSinkProto::clear_directory() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.directory_.ClearToDefault(::VcdFluxSinkProto::Impl_::_i_give_permission_to_break_this_code_default_directory_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& VcdFluxSinkProto::directory() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:VcdFluxSinkProto.directory)
  if (_impl_.directory_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_directory_.get();
  }
  return _internal_directory();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void VcdFluxSinkProto::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:VcdFluxSinkProto.directory)
}
inline ::std::string* PROTOBUF_NONNULL VcdFluxSinkProto::mutable_directory()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_directory();
  // @@protoc_insertion_point(field_mutable:VcdFluxSinkProto.directory)
  return _s;
}
inline const ::std::string& VcdFluxSinkProto::_internal_directory() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.directory_.Get();
}
inline void VcdFluxSinkProto::_internal_set_directory(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.directory_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL VcdFluxSinkProto::_internal_mutable_directory() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.directory_.Mutable(::VcdFluxSinkProto::Impl_::_i_give_permission_to_break_this_code_default_directory_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE VcdFluxSinkProto::release_directory() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:VcdFluxSinkProto.directory)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  return _impl_.directory_.Release();
}
inline void VcdFluxSinkProto::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());
  // @@protoc_insertion_point(field_set_allocated:VcdFluxSinkProto.directory)
}

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

// ScpFluxSinkProto

// optional string filename = 2 [default = "flux.scp", json_name = "filename", (.help) = ".scp file to write to"];
inline bool ScpFluxSinkProto::has_filename() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void ScpFluxSinkProto::clear_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.ClearToDefault(::ScpFluxSinkProto::Impl_::_i_give_permission_to_break_this_code_default_filename_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& ScpFluxSinkProto::filename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:ScpFluxSinkProto.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 ScpFluxSinkProto::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:ScpFluxSinkProto.filename)
}
inline ::std::string* PROTOBUF_NONNULL ScpFluxSinkProto::mutable_filename()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:ScpFluxSinkProto.filename)
  return _s;
}
inline const ::std::string& ScpFluxSinkProto::_internal_filename() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.filename_.Get();
}
inline void ScpFluxSinkProto::_internal_set_filename(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ScpFluxSinkProto::_internal_mutable_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.filename_.Mutable(::ScpFluxSinkProto::Impl_::_i_give_permission_to_break_this_code_default_filename_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ScpFluxSinkProto::release_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:ScpFluxSinkProto.filename)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  return _impl_.filename_.Release();
}
inline void ScpFluxSinkProto::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:ScpFluxSinkProto.filename)
}

// optional bool align_with_index = 3 [default = false, json_name = "alignWithIndex", (.help) = "discard data before the first index pulse"];
inline bool ScpFluxSinkProto::has_align_with_index() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void ScpFluxSinkProto::clear_align_with_index() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.align_with_index_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline bool ScpFluxSinkProto::align_with_index() const {
  // @@protoc_insertion_point(field_get:ScpFluxSinkProto.align_with_index)
  return _internal_align_with_index();
}
inline void ScpFluxSinkProto::set_align_with_index(bool value) {
  _internal_set_align_with_index(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:ScpFluxSinkProto.align_with_index)
}
inline bool ScpFluxSinkProto::_internal_align_with_index() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.align_with_index_;
}
inline void ScpFluxSinkProto::_internal_set_align_with_index(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.align_with_index_ = value;
}

// optional int32 type_byte = 4 [default = 255, json_name = "typeByte", (.help) = "set the SCP disk type byte"];
inline bool ScpFluxSinkProto::has_type_byte() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void ScpFluxSinkProto::clear_type_byte() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_byte_ = 255;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::int32_t ScpFluxSinkProto::type_byte() const {
  // @@protoc_insertion_point(field_get:ScpFluxSinkProto.type_byte)
  return _internal_type_byte();
}
inline void ScpFluxSinkProto::set_type_byte(::int32_t value) {
  _internal_set_type_byte(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:ScpFluxSinkProto.type_byte)
}
inline ::int32_t ScpFluxSinkProto::_internal_type_byte() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.type_byte_;
}
inline void ScpFluxSinkProto::_internal_set_type_byte(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_byte_ = value;
}

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

// Fl2FluxSinkProto

// optional string filename = 1 [default = "flux.fl2", json_name = "filename", (.help) = ".fl2 file to write to"];
inline bool Fl2FluxSinkProto::has_filename() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void Fl2FluxSinkProto::clear_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.ClearToDefault(::Fl2FluxSinkProto::Impl_::_i_give_permission_to_break_this_code_default_filename_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& Fl2FluxSinkProto::filename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:Fl2FluxSinkProto.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 Fl2FluxSinkProto::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:Fl2FluxSinkProto.filename)
}
inline ::std::string* PROTOBUF_NONNULL Fl2FluxSinkProto::mutable_filename()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:Fl2FluxSinkProto.filename)
  return _s;
}
inline const ::std::string& Fl2FluxSinkProto::_internal_filename() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.filename_.Get();
}
inline void Fl2FluxSinkProto::_internal_set_filename(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filename_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL Fl2FluxSinkProto::_internal_mutable_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.filename_.Mutable(::Fl2FluxSinkProto::Impl_::_i_give_permission_to_break_this_code_default_filename_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE Fl2FluxSinkProto::release_filename() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:Fl2FluxSinkProto.filename)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  return _impl_.filename_.Release();
}
inline void Fl2FluxSinkProto::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:Fl2FluxSinkProto.filename)
}

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

// FluxSinkProto

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

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

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

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::HardwareFluxSinkProto* 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 ::HardwareFluxSinkProto* PROTOBUF_NULLABLE FluxSinkProto::unsafe_arena_release_drive() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FluxSinkProto.drive)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::HardwareFluxSinkProto* temp = _impl_.drive_;
  _impl_.drive_ = nullptr;
  return temp;
}
inline ::HardwareFluxSinkProto* PROTOBUF_NONNULL FluxSinkProto::_internal_mutable_drive() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.drive_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::HardwareFluxSinkProto>(GetArena());
    _impl_.drive_ = reinterpret_cast<::HardwareFluxSinkProto*>(p);
  }
  return _impl_.drive_;
}
inline ::HardwareFluxSinkProto* PROTOBUF_NONNULL FluxSinkProto::mutable_drive()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::HardwareFluxSinkProto* _msg = _internal_mutable_drive();
  // @@protoc_insertion_point(field_mutable:FluxSinkProto.drive)
  return _msg;
}
inline void FluxSinkProto::set_allocated_drive(::HardwareFluxSinkProto* 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<::HardwareFluxSinkProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FluxSinkProto.drive)
}

// optional .A2RFluxSinkProto a2r = 8 [json_name = "a2r"];
inline bool FluxSinkProto::has_a2r() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  PROTOBUF_ASSUME(!value || _impl_.a2r_ != nullptr);
  return value;
}
inline void FluxSinkProto::clear_a2r() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.a2r_ != nullptr) _impl_.a2r_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline const ::A2RFluxSinkProto& FluxSinkProto::_internal_a2r() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::A2RFluxSinkProto* p = _impl_.a2r_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::A2RFluxSinkProto>(&::A2RFluxSinkProto_globals_);
}
inline const ::A2RFluxSinkProto& FluxSinkProto::a2r() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FluxSinkProto.a2r)
  return _internal_a2r();
}
inline void FluxSinkProto::unsafe_arena_set_allocated_a2r(
    ::A2RFluxSinkProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.a2r_);
  }
  _impl_.a2r_ = reinterpret_cast<::A2RFluxSinkProto*>(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:FluxSinkProto.a2r)
}
inline ::A2RFluxSinkProto* PROTOBUF_NULLABLE FluxSinkProto::release_a2r() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::A2RFluxSinkProto* 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 ::A2RFluxSinkProto* PROTOBUF_NULLABLE FluxSinkProto::unsafe_arena_release_a2r() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FluxSinkProto.a2r)

  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::A2RFluxSinkProto* temp = _impl_.a2r_;
  _impl_.a2r_ = nullptr;
  return temp;
}
inline ::A2RFluxSinkProto* PROTOBUF_NONNULL FluxSinkProto::_internal_mutable_a2r() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.a2r_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::A2RFluxSinkProto>(GetArena());
    _impl_.a2r_ = reinterpret_cast<::A2RFluxSinkProto*>(p);
  }
  return _impl_.a2r_;
}
inline ::A2RFluxSinkProto* PROTOBUF_NONNULL FluxSinkProto::mutable_a2r()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::A2RFluxSinkProto* _msg = _internal_mutable_a2r();
  // @@protoc_insertion_point(field_mutable:FluxSinkProto.a2r)
  return _msg;
}
inline void FluxSinkProto::set_allocated_a2r(::A2RFluxSinkProto* 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], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }

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

// optional .AuFluxSinkProto au = 3 [json_name = "au"];
inline bool FluxSinkProto::has_au() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.au_ != nullptr);
  return value;
}
inline void FluxSinkProto::clear_au() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.au_ != nullptr) _impl_.au_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::AuFluxSinkProto& FluxSinkProto::_internal_au() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::AuFluxSinkProto* p = _impl_.au_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::AuFluxSinkProto>(&::AuFluxSinkProto_globals_);
}
inline const ::AuFluxSinkProto& FluxSinkProto::au() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FluxSinkProto.au)
  return _internal_au();
}
inline void FluxSinkProto::unsafe_arena_set_allocated_au(
    ::AuFluxSinkProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.au_);
  }
  _impl_.au_ = reinterpret_cast<::AuFluxSinkProto*>(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:FluxSinkProto.au)
}
inline ::AuFluxSinkProto* PROTOBUF_NULLABLE FluxSinkProto::release_au() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::AuFluxSinkProto* released = _impl_.au_;
  _impl_.au_ = 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 ::AuFluxSinkProto* PROTOBUF_NULLABLE FluxSinkProto::unsafe_arena_release_au() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FluxSinkProto.au)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::AuFluxSinkProto* temp = _impl_.au_;
  _impl_.au_ = nullptr;
  return temp;
}
inline ::AuFluxSinkProto* PROTOBUF_NONNULL FluxSinkProto::_internal_mutable_au() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.au_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::AuFluxSinkProto>(GetArena());
    _impl_.au_ = reinterpret_cast<::AuFluxSinkProto*>(p);
  }
  return _impl_.au_;
}
inline ::AuFluxSinkProto* PROTOBUF_NONNULL FluxSinkProto::mutable_au()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::AuFluxSinkProto* _msg = _internal_mutable_au();
  // @@protoc_insertion_point(field_mutable:FluxSinkProto.au)
  return _msg;
}
inline void FluxSinkProto::set_allocated_au(::AuFluxSinkProto* 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_.au_);
  }

  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_.au_ = reinterpret_cast<::AuFluxSinkProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FluxSinkProto.au)
}

// optional .VcdFluxSinkProto vcd = 4 [json_name = "vcd"];
inline bool FluxSinkProto::has_vcd() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.vcd_ != nullptr);
  return value;
}
inline void FluxSinkProto::clear_vcd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.vcd_ != nullptr) _impl_.vcd_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::VcdFluxSinkProto& FluxSinkProto::_internal_vcd() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::VcdFluxSinkProto* p = _impl_.vcd_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::VcdFluxSinkProto>(&::VcdFluxSinkProto_globals_);
}
inline const ::VcdFluxSinkProto& FluxSinkProto::vcd() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FluxSinkProto.vcd)
  return _internal_vcd();
}
inline void FluxSinkProto::unsafe_arena_set_allocated_vcd(
    ::VcdFluxSinkProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.vcd_);
  }
  _impl_.vcd_ = reinterpret_cast<::VcdFluxSinkProto*>(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:FluxSinkProto.vcd)
}
inline ::VcdFluxSinkProto* PROTOBUF_NULLABLE FluxSinkProto::release_vcd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::VcdFluxSinkProto* released = _impl_.vcd_;
  _impl_.vcd_ = 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 ::VcdFluxSinkProto* PROTOBUF_NULLABLE FluxSinkProto::unsafe_arena_release_vcd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FluxSinkProto.vcd)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::VcdFluxSinkProto* temp = _impl_.vcd_;
  _impl_.vcd_ = nullptr;
  return temp;
}
inline ::VcdFluxSinkProto* PROTOBUF_NONNULL FluxSinkProto::_internal_mutable_vcd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.vcd_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::VcdFluxSinkProto>(GetArena());
    _impl_.vcd_ = reinterpret_cast<::VcdFluxSinkProto*>(p);
  }
  return _impl_.vcd_;
}
inline ::VcdFluxSinkProto* PROTOBUF_NONNULL FluxSinkProto::mutable_vcd()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::VcdFluxSinkProto* _msg = _internal_mutable_vcd();
  // @@protoc_insertion_point(field_mutable:FluxSinkProto.vcd)
  return _msg;
}
inline void FluxSinkProto::set_allocated_vcd(::VcdFluxSinkProto* 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_.vcd_);
  }

  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_.vcd_ = reinterpret_cast<::VcdFluxSinkProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:FluxSinkProto.vcd)
}

// optional .ScpFluxSinkProto scp = 5 [json_name = "scp"];
inline bool FluxSinkProto::has_scp() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  PROTOBUF_ASSUME(!value || _impl_.scp_ != nullptr);
  return value;
}
inline void FluxSinkProto::clear_scp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.scp_ != nullptr) _impl_.scp_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::ScpFluxSinkProto& FluxSinkProto::_internal_scp() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::ScpFluxSinkProto* p = _impl_.scp_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::ScpFluxSinkProto>(&::ScpFluxSinkProto_globals_);
}
inline const ::ScpFluxSinkProto& FluxSinkProto::scp() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FluxSinkProto.scp)
  return _internal_scp();
}
inline void FluxSinkProto::unsafe_arena_set_allocated_scp(
    ::ScpFluxSinkProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.scp_);
  }
  _impl_.scp_ = reinterpret_cast<::ScpFluxSinkProto*>(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:FluxSinkProto.scp)
}
inline ::ScpFluxSinkProto* PROTOBUF_NULLABLE FluxSinkProto::release_scp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::ScpFluxSinkProto* 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 ::ScpFluxSinkProto* PROTOBUF_NULLABLE FluxSinkProto::unsafe_arena_release_scp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FluxSinkProto.scp)

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::ScpFluxSinkProto* temp = _impl_.scp_;
  _impl_.scp_ = nullptr;
  return temp;
}
inline ::ScpFluxSinkProto* PROTOBUF_NONNULL FluxSinkProto::_internal_mutable_scp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.scp_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::ScpFluxSinkProto>(GetArena());
    _impl_.scp_ = reinterpret_cast<::ScpFluxSinkProto*>(p);
  }
  return _impl_.scp_;
}
inline ::ScpFluxSinkProto* PROTOBUF_NONNULL FluxSinkProto::mutable_scp()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::ScpFluxSinkProto* _msg = _internal_mutable_scp();
  // @@protoc_insertion_point(field_mutable:FluxSinkProto.scp)
  return _msg;
}
inline void FluxSinkProto::set_allocated_scp(::ScpFluxSinkProto* 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], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }

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

// optional .Fl2FluxSinkProto fl2 = 6 [json_name = "fl2"];
inline bool FluxSinkProto::has_fl2() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  PROTOBUF_ASSUME(!value || _impl_.fl2_ != nullptr);
  return value;
}
inline void FluxSinkProto::clear_fl2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.fl2_ != nullptr) _impl_.fl2_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::Fl2FluxSinkProto& FluxSinkProto::_internal_fl2() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::Fl2FluxSinkProto* p = _impl_.fl2_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::Fl2FluxSinkProto>(&::Fl2FluxSinkProto_globals_);
}
inline const ::Fl2FluxSinkProto& FluxSinkProto::fl2() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:FluxSinkProto.fl2)
  return _internal_fl2();
}
inline void FluxSinkProto::unsafe_arena_set_allocated_fl2(
    ::Fl2FluxSinkProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.fl2_);
  }
  _impl_.fl2_ = reinterpret_cast<::Fl2FluxSinkProto*>(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:FluxSinkProto.fl2)
}
inline ::Fl2FluxSinkProto* PROTOBUF_NULLABLE FluxSinkProto::release_fl2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::Fl2FluxSinkProto* 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 ::Fl2FluxSinkProto* PROTOBUF_NULLABLE FluxSinkProto::unsafe_arena_release_fl2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:FluxSinkProto.fl2)

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::Fl2FluxSinkProto* temp = _impl_.fl2_;
  _impl_.fl2_ = nullptr;
  return temp;
}
inline ::Fl2FluxSinkProto* PROTOBUF_NONNULL FluxSinkProto::_internal_mutable_fl2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.fl2_ == nullptr) {
    auto* p = Super_::DefaultConstruct<::Fl2FluxSinkProto>(GetArena());
    _impl_.fl2_ = reinterpret_cast<::Fl2FluxSinkProto*>(p);
  }
  return _impl_.fl2_;
}
inline ::Fl2FluxSinkProto* PROTOBUF_NONNULL FluxSinkProto::mutable_fl2()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::Fl2FluxSinkProto* _msg = _internal_mutable_fl2();
  // @@protoc_insertion_point(field_mutable:FluxSinkProto.fl2)
  return _msg;
}
inline void FluxSinkProto::set_allocated_fl2(::Fl2FluxSinkProto* 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], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }

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

#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_2ffluxsink_2ffluxsink_2eproto_2epb_2eh
