// WARNING: This file is machine generated by fidlgen.

#pragma once

#include <fidl/test.anonymous/cpp/common_types.h>
#include <fidl/test.anonymous/cpp/markers.h>
#include <lib/fidl/cpp/natural_coding_traits.h>
#include <lib/fidl/cpp/natural_types.h>

#include <cinttypes>
#include <string>

#ifdef __Fuchsia__

#include <lib/zx/channel.h>

#endif  // __Fuchsia__

namespace test_anonymous {
class TableData;

class SomeProtocolSomeMethodRequest;

class OverrideTest;

class SomeProtocolSomeMethodResponse;

class SomeProtocolSomeMethodTopResponse;

class TableMember;

class FunctionApplication;

class UnionMember;

class Expression;

class SomeProtocolSomeMethodResult;

extern "C" const fidl_type_t test_anonymous_UnionMemberTable;

class UnionMember {
 private:
  using Storage_ = std::variant<std::monostate, uint8_t>;

 public:
  // TODO: share union tag types between wire & natural.
  enum class Tag : fidl_union_tag_t {
    kUnionData = 2,  // 0x2
    kUnknown = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };
  // Create an unknown value of this union.
  UnionMember() : storage_(std::make_shared<Storage_>()) {}

  UnionMember(UnionMember&& other) noexcept
      : UnionMember(
            ::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{}) {
    *storage_ = std::move(*other.storage_);
  }
  UnionMember& operator=(UnionMember&& other) noexcept {
    if (this != &other) {
      *storage_ = std::move(*other.storage_);
    }
    return *this;
  }
  UnionMember(const UnionMember& other) noexcept
      : UnionMember(other.CloneStorage_()) {}
  UnionMember& operator=(const UnionMember& other) noexcept {
    if (this != &other) {
      storage_ = other.CloneStorage_();
    }
    return *this;
  }

  bool operator==(const UnionMember& other) const noexcept {
    return *storage_ == *other.storage_;
  }
  bool operator!=(const UnionMember& other) const noexcept {
    return *storage_ != *other.storage_;
  }

  constexpr ::test_anonymous::UnionMember::Tag Which() const {
    return UnionMember::IndexToTag(storage_->index()).value();
  }
  static UnionMember WithUnionData(uint8_t val) {
    return UnionMember(
        std::make_shared<Storage_>(std::in_place_index_t<1>{}, std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> union_data() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> union_data() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }

  UnionMember(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : storage_(std::make_shared<Storage_>()) {}

 private:
  std::shared_ptr<Storage_> storage_;
  std::shared_ptr<Storage_> CloneStorage_() const;
  friend struct ::fidl::internal::NaturalUnionCodingTraits<
      ::test_anonymous::UnionMember>;
  static constexpr auto kMembers =
      std::make_tuple(::fidl::internal::NaturalUnionMember<
                          ::fidl::internal::NaturalCodingConstraintEmpty>(),
                      ::fidl::internal::NaturalUnionMember<
                          fidl::internal::NaturalCodingConstraintEmpty>());

  explicit UnionMember(std::shared_ptr<Storage_> storage)
      : storage_(std::move(storage)) {}

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder,
                                     ::test_anonymous::UnionMember::Tag tag) {
    switch (tag) {
      case ::test_anonymous::UnionMember::Tag::kUnionData:
        return 1;
      case ::test_anonymous::UnionMember::Tag::kUnknown:
        return 0;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_anonymous::UnionMember::Tag> IndexToTag(
      size_t index) {
    switch (index) {
      case 1:
        return ::test_anonymous::UnionMember::Tag::kUnionData;
      default:
        return ::test_anonymous::UnionMember::Tag::kUnknown;
    }
  }
};

extern "C" const fidl_type_t test_anonymous_TableDataTable;

class TableData {
 private:
  struct Storage_;

 public:
  TableData(Storage_ storage) noexcept : storage_(std::move(storage)) {}
  TableData(uint8_t data) noexcept : storage_({.data = std::move(data)}) {}

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |TableData| only if all of its members are default
  // constructible.
  TableData() = default;
#pragma clang diagnostic pop

  TableData(TableData&&) noexcept = default;
  TableData& operator=(TableData&&) noexcept = default;
  TableData(const TableData& other) noexcept
      : TableData(other.CloneStorage_()) {}
  TableData& operator=(const TableData& other) noexcept {
    storage_ = other.CloneStorage_();
    return *this;
  }

  bool operator==(const TableData& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<
        ::test_anonymous::TableData, 1>::Equal(this, &other);
  }
  bool operator!=(const TableData& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<
        ::test_anonymous::TableData, 1>::Equal(this, &other);
  }

  uint8_t data() const { return storage_.data; }

  uint8_t& data() { return storage_.data; }

  TableData(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : TableData(Storage_{
            .data = {},
        }) {}

 private:
  struct Storage_ final {
    uint8_t data = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<
      ::test_anonymous::TableData, 1>;
  friend struct ::fidl::internal::MemberVisitor<::test_anonymous::TableData>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalStructMember<
          Storage_, uint8_t, fidl::internal::NaturalCodingConstraintEmpty>{
          &Storage_::data, 0});
  static constexpr auto kPadding = std::make_tuple();
};

extern "C" const fidl_type_t test_anonymous_TableMemberTable;

class TableMember {
 private:
  struct Storage_;

 public:
  TableMember(Storage_ storage) noexcept : storage_(std::move(storage)) {}
  TableMember() noexcept = default;
  TableMember(TableMember&&) noexcept = default;
  TableMember& operator=(TableMember&&) noexcept = default;
  TableMember(const TableMember& other) noexcept
      : TableMember(other.CloneStorage_()) {}
  TableMember& operator=(const TableMember& other) noexcept {
    storage_ = other.CloneStorage_();
    return *this;
  }
  bool operator==(const TableMember& other) const noexcept {
    return ::fidl::internal::NaturalTableCodingTraits<
        ::test_anonymous::TableMember>::Equal(this, &other);
  }
  bool operator!=(const TableMember& other) const noexcept {
    return !::fidl::internal::NaturalTableCodingTraits<
        ::test_anonymous::TableMember>::Equal(this, &other);
  }

  bool IsEmpty() const { return !(storage_.table_data.has_value()); }

  const std::optional<::std::vector<::test_anonymous::TableData>>& table_data()
      const {
    return storage_.table_data;
  }
  ::std::optional<::std::vector<::test_anonymous::TableData>>& table_data() {
    return storage_.table_data;
  }

  TableMember(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : TableMember(Storage_{}) {}

 private:
  struct Storage_ final {
    ::std::optional<::std::vector<::test_anonymous::TableData>> table_data{};
  };

  // TODO(https://fxbug.dev/91252): Box the storage.
  Storage_ storage_;
  Storage_ CloneStorage_() const;
  friend struct ::fidl::internal::NaturalTableCodingTraits<
      ::test_anonymous::TableMember>;
  friend struct ::fidl::internal::MemberVisitor<::test_anonymous::TableMember>;
  static constexpr auto kMembers =
      std::make_tuple(::fidl::internal::NaturalTableMember<
                      Storage_, ::std::vector<::test_anonymous::TableData>,
                      fidl::internal::NaturalCodingConstraintVector<
                          fidl::internal::NaturalCodingConstraintEmpty, 10>>{
          2, &Storage_::table_data});
};

extern "C" const fidl_type_t test_anonymous_SomeProtocolSomeMethodRequestTable;

class SomeProtocolSomeMethodRequest {
 private:
  struct Storage_;

 public:
  SomeProtocolSomeMethodRequest(Storage_ storage) noexcept
      : storage_(std::move(storage)) {}
  SomeProtocolSomeMethodRequest(
      ::test_anonymous::UnionMember union_member,
      ::test_anonymous::TableMember table_member) noexcept
      : storage_({.union_member = std::move(union_member),
                  .table_member = std::move(table_member)}) {}

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |SomeProtocolSomeMethodRequest| only if all of its
  // members are default constructible.
  SomeProtocolSomeMethodRequest() = default;
#pragma clang diagnostic pop

  SomeProtocolSomeMethodRequest(SomeProtocolSomeMethodRequest&&) noexcept =
      default;
  SomeProtocolSomeMethodRequest& operator=(
      SomeProtocolSomeMethodRequest&&) noexcept = default;
  SomeProtocolSomeMethodRequest(
      const SomeProtocolSomeMethodRequest& other) noexcept
      : SomeProtocolSomeMethodRequest(other.CloneStorage_()) {}
  SomeProtocolSomeMethodRequest& operator=(
      const SomeProtocolSomeMethodRequest& other) noexcept {
    storage_ = other.CloneStorage_();
    return *this;
  }

  bool operator==(const SomeProtocolSomeMethodRequest& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<
        ::test_anonymous::SomeProtocolSomeMethodRequest, 32>::Equal(this,
                                                                    &other);
  }
  bool operator!=(const SomeProtocolSomeMethodRequest& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<
        ::test_anonymous::SomeProtocolSomeMethodRequest, 32>::Equal(this,
                                                                    &other);
  }

  const ::test_anonymous::UnionMember& union_member() const {
    return storage_.union_member;
  }

  ::test_anonymous::UnionMember& union_member() {
    return storage_.union_member;
  }

  const ::test_anonymous::TableMember& table_member() const {
    return storage_.table_member;
  }

  ::test_anonymous::TableMember& table_member() {
    return storage_.table_member;
  }

  SomeProtocolSomeMethodRequest(
      ::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : SomeProtocolSomeMethodRequest(Storage_{
            .union_member =
                ::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{},
            .table_member =
                ::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{},
        }) {}

 private:
  struct Storage_ final {
    ::test_anonymous::UnionMember union_member;
    ::test_anonymous::TableMember table_member;
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<
      ::test_anonymous::SomeProtocolSomeMethodRequest, 32>;
  friend struct ::fidl::internal::MemberVisitor<
      ::test_anonymous::SomeProtocolSomeMethodRequest>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalStructMember<
          Storage_, ::test_anonymous::UnionMember,
          fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::union_member,
                                                        0},
      ::fidl::internal::NaturalStructMember<
          Storage_, ::test_anonymous::TableMember,
          fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::table_member,
                                                        16});
  static constexpr auto kPadding = std::make_tuple();
};

extern "C" const fidl_type_t test_anonymous_OverrideTestTable;

class OverrideTest {
 private:
  struct Storage_;

 public:
  OverrideTest(Storage_ storage) noexcept : storage_(std::move(storage)) {}
  OverrideTest(::test_anonymous::Op op,
               ::std::unique_ptr<::test_anonymous::Expression> left,
               ::std::unique_ptr<::test_anonymous::Expression> right) noexcept
      : storage_({.op = std::move(op),
                  .left = std::move(left),
                  .right = std::move(right)}) {}

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |OverrideTest| only if all of its members are default
  // constructible.
  OverrideTest() = default;
#pragma clang diagnostic pop

  OverrideTest(OverrideTest&&) noexcept = default;
  OverrideTest& operator=(OverrideTest&&) noexcept = default;
  OverrideTest(const OverrideTest& other) noexcept
      : OverrideTest(other.CloneStorage_()) {}
  OverrideTest& operator=(const OverrideTest& other) noexcept {
    storage_ = other.CloneStorage_();
    return *this;
  }

  bool operator==(const OverrideTest& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<
        ::test_anonymous::OverrideTest, 40>::Equal(this, &other);
  }
  bool operator!=(const OverrideTest& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<
        ::test_anonymous::OverrideTest, 40>::Equal(this, &other);
  }

  ::test_anonymous::Op op() const { return storage_.op; }

  ::test_anonymous::Op& op() { return storage_.op; }

  const ::std::unique_ptr<::test_anonymous::Expression>& left() const {
    return storage_.left;
  }

  ::std::unique_ptr<::test_anonymous::Expression>& left() {
    return storage_.left;
  }

  const ::std::unique_ptr<::test_anonymous::Expression>& right() const {
    return storage_.right;
  }

  ::std::unique_ptr<::test_anonymous::Expression>& right() {
    return storage_.right;
  }

  OverrideTest(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : OverrideTest(Storage_{
            .op = {},
            .left = {},
            .right = {},
        }) {}

 private:
  struct Storage_ final {
    ::test_anonymous::Op op = {};
    ::std::unique_ptr<::test_anonymous::Expression> left;
    ::std::unique_ptr<::test_anonymous::Expression> right;
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<
      ::test_anonymous::OverrideTest, 40>;
  friend struct ::fidl::internal::MemberVisitor<::test_anonymous::OverrideTest>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalStructMember<
          Storage_, ::test_anonymous::Op,
          fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::op, 0},
      ::fidl::internal::NaturalStructMember<
          Storage_, ::std::unique_ptr<::test_anonymous::Expression>,
          fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::left, 8},
      ::fidl::internal::NaturalStructMember<
          Storage_, ::std::unique_ptr<::test_anonymous::Expression>,
          fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::right, 24});
  static constexpr auto kPadding =
      std::make_tuple(::fidl::internal::NaturalStructPadding<uint64_t>{
          .offset = 0,
          .mask = 0xffffffff00000000ull,
      });
};

extern "C" const fidl_type_t test_anonymous_FunctionApplicationTable;

class FunctionApplication {
 private:
  struct Storage_;

 public:
  FunctionApplication(Storage_ storage) noexcept
      : storage_(std::move(storage)) {}
  FunctionApplication() noexcept = default;
  FunctionApplication(FunctionApplication&&) noexcept = default;
  FunctionApplication& operator=(FunctionApplication&&) noexcept = default;
  FunctionApplication(const FunctionApplication& other) noexcept
      : FunctionApplication(other.CloneStorage_()) {}
  FunctionApplication& operator=(const FunctionApplication& other) noexcept {
    storage_ = other.CloneStorage_();
    return *this;
  }
  bool operator==(const FunctionApplication& other) const noexcept {
    return ::fidl::internal::NaturalTableCodingTraits<
        ::test_anonymous::FunctionApplication>::Equal(this, &other);
  }
  bool operator!=(const FunctionApplication& other) const noexcept {
    return !::fidl::internal::NaturalTableCodingTraits<
        ::test_anonymous::FunctionApplication>::Equal(this, &other);
  }

  bool IsEmpty() const {
    return !(storage_.func.has_value() || storage_.args.has_value() ||
             storage_.flags.has_value());
  }

  const std::optional<::std::string>& func() const { return storage_.func; }
  ::std::optional<::std::string>& func() { return storage_.func; }

  const std::optional<
      ::std::vector<::std::unique_ptr<::test_anonymous::Expression>>>&
  args() const {
    return storage_.args;
  }
  ::std::optional<
      ::std::vector<::std::unique_ptr<::test_anonymous::Expression>>>&
  args() {
    return storage_.args;
  }

  const std::optional<::test_anonymous::Flags>& flags() const {
    return storage_.flags;
  }
  ::std::optional<::test_anonymous::Flags>& flags() { return storage_.flags; }

  FunctionApplication(
      ::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : FunctionApplication(Storage_{}) {}

 private:
  struct Storage_ final {
    ::std::optional<::std::string> func{};
    ::std::optional<
        ::std::vector<::std::unique_ptr<::test_anonymous::Expression>>>
        args{};
    ::std::optional<::test_anonymous::Flags> flags{};
  };

  // TODO(https://fxbug.dev/91252): Box the storage.
  Storage_ storage_;
  Storage_ CloneStorage_() const;
  friend struct ::fidl::internal::NaturalTableCodingTraits<
      ::test_anonymous::FunctionApplication>;
  friend struct ::fidl::internal::MemberVisitor<
      ::test_anonymous::FunctionApplication>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalTableMember<
          Storage_, ::std::string,
          fidl::internal::NaturalCodingConstraintString<100>>{1,
                                                              &Storage_::func},
      ::fidl::internal::NaturalTableMember<
          Storage_,
          ::std::vector<::std::unique_ptr<::test_anonymous::Expression>>,
          fidl::internal::NaturalCodingConstraintVector<
              fidl::internal::NaturalCodingConstraintEmpty, 5>>{
          3, &Storage_::args},
      ::fidl::internal::NaturalTableMember<
          Storage_, ::test_anonymous::Flags,
          fidl::internal::NaturalCodingConstraintEmpty>{4, &Storage_::flags});
};

extern "C" const fidl_type_t test_anonymous_ExpressionTable;

class Expression {
 private:
  using Storage_ =
      std::variant<std::monostate, uint64_t, ::test_anonymous::OverrideTest,
                   ::test_anonymous::FunctionApplication>;

 public:
  // TODO: share union tag types between wire & natural.
  enum class Tag : fidl_union_tag_t {
    kValue = 1,                // 0x1
    kBinOp = 2,                // 0x2
    kFunctionApplication = 3,  // 0x3
    kUnknown = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };
  // Create an unknown value of this union.
  Expression() : storage_(std::make_shared<Storage_>()) {}

  Expression(Expression&& other) noexcept
      : Expression(
            ::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{}) {
    *storage_ = std::move(*other.storage_);
  }
  Expression& operator=(Expression&& other) noexcept {
    if (this != &other) {
      *storage_ = std::move(*other.storage_);
    }
    return *this;
  }
  Expression(const Expression& other) noexcept
      : Expression(other.CloneStorage_()) {}
  Expression& operator=(const Expression& other) noexcept {
    if (this != &other) {
      storage_ = other.CloneStorage_();
    }
    return *this;
  }

  bool operator==(const Expression& other) const noexcept {
    return *storage_ == *other.storage_;
  }
  bool operator!=(const Expression& other) const noexcept {
    return *storage_ != *other.storage_;
  }

  constexpr ::test_anonymous::Expression::Tag Which() const {
    return Expression::IndexToTag(storage_->index()).value();
  }
  static Expression WithValue(uint64_t val) {
    return Expression(
        std::make_shared<Storage_>(std::in_place_index_t<1>{}, std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> value() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> value() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static Expression WithBinOp(::test_anonymous::OverrideTest val) {
    return Expression(
        std::make_shared<Storage_>(std::in_place_index_t<2>{}, std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<2, Storage_> bin_op() const {
    return ::fidl::internal::UnionMemberView<2, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<2, Storage_> bin_op() {
    return ::fidl::internal::UnionMemberView<2, Storage_>(storage_);
  }
  static Expression WithFunctionApplication(
      ::test_anonymous::FunctionApplication val) {
    return Expression(
        std::make_shared<Storage_>(std::in_place_index_t<3>{}, std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<3, Storage_> function_application()
      const {
    return ::fidl::internal::UnionMemberView<3, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<3, Storage_> function_application() {
    return ::fidl::internal::UnionMemberView<3, Storage_>(storage_);
  }

  Expression(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : storage_(std::make_shared<Storage_>()) {}

 private:
  std::shared_ptr<Storage_> storage_;
  std::shared_ptr<Storage_> CloneStorage_() const;
  friend struct ::fidl::internal::NaturalUnionCodingTraits<
      ::test_anonymous::Expression>;
  static constexpr auto kMembers =
      std::make_tuple(::fidl::internal::NaturalUnionMember<
                          ::fidl::internal::NaturalCodingConstraintEmpty>(),
                      ::fidl::internal::NaturalUnionMember<
                          fidl::internal::NaturalCodingConstraintEmpty>(),
                      ::fidl::internal::NaturalUnionMember<
                          fidl::internal::NaturalCodingConstraintEmpty>(),
                      ::fidl::internal::NaturalUnionMember<
                          fidl::internal::NaturalCodingConstraintEmpty>());

  explicit Expression(std::shared_ptr<Storage_> storage)
      : storage_(std::move(storage)) {}

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder,
                                     ::test_anonymous::Expression::Tag tag) {
    switch (tag) {
      case ::test_anonymous::Expression::Tag::kValue:
        return 1;
      case ::test_anonymous::Expression::Tag::kBinOp:
        return 2;
      case ::test_anonymous::Expression::Tag::kFunctionApplication:
        return 3;
      case ::test_anonymous::Expression::Tag::kUnknown:
        return 0;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_anonymous::Expression::Tag> IndexToTag(
      size_t index) {
    switch (index) {
      case 1:
        return ::test_anonymous::Expression::Tag::kValue;
      case 2:
        return ::test_anonymous::Expression::Tag::kBinOp;
      case 3:
        return ::test_anonymous::Expression::Tag::kFunctionApplication;
      default:
        return ::test_anonymous::Expression::Tag::kUnknown;
    }
  }
};

extern "C" const fidl_type_t
    test_anonymous_SomeProtocol_SomeMethod_ResponseTable;

class SomeProtocolSomeMethodResponse {
 private:
  struct Storage_;

 public:
  SomeProtocolSomeMethodResponse(Storage_ storage) noexcept
      : storage_(std::move(storage)) {}
  SomeProtocolSomeMethodResponse(
      ::test_anonymous::BitsMember bits_member) noexcept
      : storage_({.bits_member = std::move(bits_member)}) {}

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |SomeProtocolSomeMethodResponse| only if all of its
  // members are default constructible.
  SomeProtocolSomeMethodResponse() = default;
#pragma clang diagnostic pop

  SomeProtocolSomeMethodResponse(SomeProtocolSomeMethodResponse&&) noexcept =
      default;
  SomeProtocolSomeMethodResponse& operator=(
      SomeProtocolSomeMethodResponse&&) noexcept = default;
  SomeProtocolSomeMethodResponse(
      const SomeProtocolSomeMethodResponse& other) noexcept
      : SomeProtocolSomeMethodResponse(other.CloneStorage_()) {}
  SomeProtocolSomeMethodResponse& operator=(
      const SomeProtocolSomeMethodResponse& other) noexcept {
    storage_ = other.CloneStorage_();
    return *this;
  }

  bool operator==(const SomeProtocolSomeMethodResponse& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<
        ::test_anonymous::SomeProtocolSomeMethodResponse, 4>::Equal(this,
                                                                    &other);
  }
  bool operator!=(const SomeProtocolSomeMethodResponse& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<
        ::test_anonymous::SomeProtocolSomeMethodResponse, 4>::Equal(this,
                                                                    &other);
  }

  ::test_anonymous::BitsMember bits_member() const {
    return storage_.bits_member;
  }

  ::test_anonymous::BitsMember& bits_member() { return storage_.bits_member; }

  SomeProtocolSomeMethodResponse(
      ::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : SomeProtocolSomeMethodResponse(Storage_{
            .bits_member = {},
        }) {}

 private:
  struct Storage_ final {
    ::test_anonymous::BitsMember bits_member = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<
      ::test_anonymous::SomeProtocolSomeMethodResponse, 4>;
  friend struct ::fidl::internal::MemberVisitor<
      ::test_anonymous::SomeProtocolSomeMethodResponse>;
  static constexpr auto kMembers =
      std::make_tuple(::fidl::internal::NaturalStructMember<
                      Storage_, ::test_anonymous::BitsMember,
                      fidl::internal::NaturalCodingConstraintEmpty>{
          &Storage_::bits_member, 0});
  static constexpr auto kPadding = std::make_tuple();
};

extern "C" const fidl_type_t test_anonymous_SomeProtocol_SomeMethod_ResultTable;

class SomeProtocolSomeMethodResult {
 private:
  using Storage_ =
      std::variant<std::monostate,
                   ::test_anonymous::SomeProtocolSomeMethodResponse,
                   ::test_anonymous::SomeProtocolSomeMethodError>;

 public:
  // TODO: share union tag types between wire & natural.
  enum class Tag : fidl_union_tag_t {
    kResponse = 1,  // 0x1
    kErr = 2,       // 0x2
  };

  SomeProtocolSomeMethodResult(SomeProtocolSomeMethodResult&& other) noexcept
      : SomeProtocolSomeMethodResult(
            ::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{}) {
    *storage_ = std::move(*other.storage_);
  }
  SomeProtocolSomeMethodResult& operator=(
      SomeProtocolSomeMethodResult&& other) noexcept {
    if (this != &other) {
      *storage_ = std::move(*other.storage_);
    }
    return *this;
  }
  SomeProtocolSomeMethodResult(
      const SomeProtocolSomeMethodResult& other) noexcept
      : SomeProtocolSomeMethodResult(other.CloneStorage_()) {}
  SomeProtocolSomeMethodResult& operator=(
      const SomeProtocolSomeMethodResult& other) noexcept {
    if (this != &other) {
      storage_ = other.CloneStorage_();
    }
    return *this;
  }

  bool operator==(const SomeProtocolSomeMethodResult& other) const noexcept {
    return *storage_ == *other.storage_;
  }
  bool operator!=(const SomeProtocolSomeMethodResult& other) const noexcept {
    return *storage_ != *other.storage_;
  }

  constexpr ::test_anonymous::SomeProtocolSomeMethodResult::Tag Which() const {
    return SomeProtocolSomeMethodResult::IndexToTag(storage_->index()).value();
  }
  static SomeProtocolSomeMethodResult WithResponse(
      ::test_anonymous::SomeProtocolSomeMethodResponse val) {
    return SomeProtocolSomeMethodResult(
        std::make_shared<Storage_>(std::in_place_index_t<1>{}, std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> response() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> response() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static SomeProtocolSomeMethodResult WithErr(
      ::test_anonymous::SomeProtocolSomeMethodError val) {
    return SomeProtocolSomeMethodResult(
        std::make_shared<Storage_>(std::in_place_index_t<2>{}, std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<2, Storage_> err() const {
    return ::fidl::internal::UnionMemberView<2, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<2, Storage_> err() {
    return ::fidl::internal::UnionMemberView<2, Storage_>(storage_);
  }

  SomeProtocolSomeMethodResult(
      ::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : storage_(std::make_shared<Storage_>()) {}

 private:
  std::shared_ptr<Storage_> storage_;
  std::shared_ptr<Storage_> CloneStorage_() const;
  friend struct ::fidl::internal::NaturalUnionCodingTraits<
      ::test_anonymous::SomeProtocolSomeMethodResult>;
  static constexpr auto kMembers =
      std::make_tuple(::fidl::internal::NaturalUnionMember<
                          ::fidl::internal::NaturalCodingConstraintEmpty>(),
                      ::fidl::internal::NaturalUnionMember<
                          fidl::internal::NaturalCodingConstraintEmpty>(),
                      ::fidl::internal::NaturalUnionMember<
                          fidl::internal::NaturalCodingConstraintEmpty>());

  explicit SomeProtocolSomeMethodResult(std::shared_ptr<Storage_> storage)
      : storage_(std::move(storage)) {}

  static constexpr size_t TagToIndex(
      ::fidl::internal::NaturalDecoder* decoder,
      ::test_anonymous::SomeProtocolSomeMethodResult::Tag tag) {
    switch (tag) {
      case ::test_anonymous::SomeProtocolSomeMethodResult::Tag::kResponse:
        return 1;
      case ::test_anonymous::SomeProtocolSomeMethodResult::Tag::kErr:
        return 2;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<
      ::test_anonymous::SomeProtocolSomeMethodResult::Tag>
  IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_anonymous::SomeProtocolSomeMethodResult::Tag::kResponse;
      case 2:
        return ::test_anonymous::SomeProtocolSomeMethodResult::Tag::kErr;
      default:
        return std::nullopt;
    }
  }
};

extern "C" const fidl_type_t
    test_anonymous_SomeProtocolSomeMethodTopResponseTable;

class SomeProtocolSomeMethodTopResponse {
 private:
  struct Storage_;

 public:
  SomeProtocolSomeMethodTopResponse(Storage_ storage) noexcept
      : storage_(std::move(storage)) {}
  SomeProtocolSomeMethodTopResponse(
      ::test_anonymous::SomeProtocolSomeMethodResult result) noexcept
      : storage_({.result = std::move(result)}) {}

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  // Default constructs a |SomeProtocolSomeMethodTopResponse| only if all of its
  // members are default constructible.
  SomeProtocolSomeMethodTopResponse() = default;
#pragma clang diagnostic pop

  SomeProtocolSomeMethodTopResponse(
      SomeProtocolSomeMethodTopResponse&&) noexcept = default;
  SomeProtocolSomeMethodTopResponse& operator=(
      SomeProtocolSomeMethodTopResponse&&) noexcept = default;
  SomeProtocolSomeMethodTopResponse(
      const SomeProtocolSomeMethodTopResponse& other) noexcept
      : SomeProtocolSomeMethodTopResponse(other.CloneStorage_()) {}
  SomeProtocolSomeMethodTopResponse& operator=(
      const SomeProtocolSomeMethodTopResponse& other) noexcept {
    storage_ = other.CloneStorage_();
    return *this;
  }

  bool operator==(
      const SomeProtocolSomeMethodTopResponse& other) const noexcept {
    return ::fidl::internal::NaturalStructCodingTraits<
        ::test_anonymous::SomeProtocolSomeMethodTopResponse, 16>::Equal(this,
                                                                        &other);
  }
  bool operator!=(
      const SomeProtocolSomeMethodTopResponse& other) const noexcept {
    return !::fidl::internal::NaturalStructCodingTraits<
        ::test_anonymous::SomeProtocolSomeMethodTopResponse, 16>::Equal(this,
                                                                        &other);
  }

  const ::test_anonymous::SomeProtocolSomeMethodResult& result() const {
    return storage_.result;
  }

  ::test_anonymous::SomeProtocolSomeMethodResult& result() {
    return storage_.result;
  }

  SomeProtocolSomeMethodTopResponse(
      ::fidl::internal::DefaultConstructPossiblyInvalidObjectTag)
      : SomeProtocolSomeMethodTopResponse(Storage_{
            .result =
                ::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{},
        }) {}

 private:
  struct Storage_ final {
    ::test_anonymous::SomeProtocolSomeMethodResult result;
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<
      ::test_anonymous::SomeProtocolSomeMethodTopResponse, 16>;
  friend struct ::fidl::internal::MemberVisitor<
      ::test_anonymous::SomeProtocolSomeMethodTopResponse>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalStructMember<
          Storage_, ::test_anonymous::SomeProtocolSomeMethodResult,
          fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::result, 0});
  static constexpr auto kPadding = std::make_tuple();
};

}  // namespace test_anonymous
namespace fidl {

extern "C" const fidl_type_t test_anonymous_TableDataTable;

template <>
struct IsFidlType<::test_anonymous::TableData> : public std::true_type {};

template <>
struct ::fidl::internal::TypeTraits<::test_anonymous::TableData> final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_anonymous_TableDataTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_anonymous::TableData, ::fidl::internal::NaturalCodingConstraintEmpty>
    final : public ::fidl::internal::NaturalStructCodingTraits<
                ::test_anonymous::TableData, 1> {};

extern "C" const fidl_type_t test_anonymous_SomeProtocolSomeMethodRequestTable;

template <>
struct IsFidlType<::test_anonymous::SomeProtocolSomeMethodRequest>
    : public std::true_type {};

template <>
struct ::fidl::internal::TypeTraits<
    ::test_anonymous::SomeProtocolSomeMethodRequest>
    final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_anonymous_SomeProtocolSomeMethodRequestTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_anonymous::SomeProtocolSomeMethodRequest,
    ::fidl::internal::NaturalCodingConstraintEmpty>
    final : public ::fidl::internal::NaturalStructCodingTraits<
                ::test_anonymous::SomeProtocolSomeMethodRequest, 32> {};

extern "C" const fidl_type_t test_anonymous_OverrideTestTable;

template <>
struct IsFidlType<::test_anonymous::OverrideTest> : public std::true_type {};

template <>
struct ::fidl::internal::TypeTraits<::test_anonymous::OverrideTest> final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_anonymous_OverrideTestTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_anonymous::OverrideTest,
    ::fidl::internal::NaturalCodingConstraintEmpty>
    final : public ::fidl::internal::NaturalStructCodingTraits<
                ::test_anonymous::OverrideTest, 40> {};

extern "C" const fidl_type_t
    test_anonymous_SomeProtocol_SomeMethod_ResponseTable;

template <>
struct IsFidlType<::test_anonymous::SomeProtocolSomeMethodResponse>
    : public std::true_type {};

template <>
struct ::fidl::internal::TypeTraits<
    ::test_anonymous::SomeProtocolSomeMethodResponse>
    final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_anonymous_SomeProtocol_SomeMethod_ResponseTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_anonymous::SomeProtocolSomeMethodResponse,
    ::fidl::internal::NaturalCodingConstraintEmpty>
    final : public ::fidl::internal::NaturalStructCodingTraits<
                ::test_anonymous::SomeProtocolSomeMethodResponse, 4> {};

extern "C" const fidl_type_t
    test_anonymous_SomeProtocolSomeMethodTopResponseTable;

template <>
struct IsFidlType<::test_anonymous::SomeProtocolSomeMethodTopResponse>
    : public std::true_type {};

template <>
struct ::fidl::internal::TypeTraits<
    ::test_anonymous::SomeProtocolSomeMethodTopResponse>
    final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_anonymous_SomeProtocolSomeMethodTopResponseTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_anonymous::SomeProtocolSomeMethodTopResponse,
    ::fidl::internal::NaturalCodingConstraintEmpty>
    final : public ::fidl::internal::NaturalStructCodingTraits<
                ::test_anonymous::SomeProtocolSomeMethodTopResponse, 16> {};

extern "C" const fidl_type_t test_anonymous_TableMemberTable;

template <>
struct IsFidlType<::test_anonymous::TableMember> : public std::true_type {};

template <>
struct ::fidl::internal::TypeTraits<::test_anonymous::TableMember> final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_anonymous_TableMemberTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_anonymous::TableMember,
    ::fidl::internal::NaturalCodingConstraintEmpty>
    : public ::fidl::internal::NaturalTableCodingTraits<
          ::test_anonymous::TableMember> {};

extern "C" const fidl_type_t test_anonymous_FunctionApplicationTable;

template <>
struct IsFidlType<::test_anonymous::FunctionApplication>
    : public std::true_type {};

template <>
struct ::fidl::internal::TypeTraits<::test_anonymous::FunctionApplication>
    final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_anonymous_FunctionApplicationTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_anonymous::FunctionApplication,
    ::fidl::internal::NaturalCodingConstraintEmpty>
    : public ::fidl::internal::NaturalTableCodingTraits<
          ::test_anonymous::FunctionApplication> {};

extern "C" const fidl_type_t test_anonymous_UnionMemberTable;

template <>
struct IsFidlType<::test_anonymous::UnionMember> : public std::true_type {};
template <>
struct IsUnion<::test_anonymous::UnionMember> : public std::true_type {};

template <>
struct ::fidl::internal::TypeTraits<::test_anonymous::UnionMember> final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_anonymous_UnionMemberTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_anonymous::UnionMember,
    ::fidl::internal::NaturalCodingConstraintEmpty>
    final : public ::fidl::internal::NaturalUnionCodingTraits<
                ::test_anonymous::UnionMember> {};

extern "C" const fidl_type_t test_anonymous_ExpressionTable;

template <>
struct IsFidlType<::test_anonymous::Expression> : public std::true_type {};
template <>
struct IsUnion<::test_anonymous::Expression> : public std::true_type {};

template <>
struct ::fidl::internal::TypeTraits<::test_anonymous::Expression> final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_anonymous_ExpressionTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_anonymous::Expression,
    ::fidl::internal::NaturalCodingConstraintEmpty>
    final : public ::fidl::internal::NaturalUnionCodingTraits<
                ::test_anonymous::Expression> {};

extern "C" const fidl_type_t test_anonymous_SomeProtocol_SomeMethod_ResultTable;

template <>
struct IsFidlType<::test_anonymous::SomeProtocolSomeMethodResult>
    : public std::true_type {};
template <>
struct IsUnion<::test_anonymous::SomeProtocolSomeMethodResult>
    : public std::true_type {};

template <>
struct ::fidl::internal::TypeTraits<
    ::test_anonymous::SomeProtocolSomeMethodResult>
    final {
 public:
  static constexpr const fidl_type_t* kCodingTable =
      &test_anonymous_SomeProtocol_SomeMethod_ResultTable;
};

template <>
struct internal::NaturalCodingTraits<
    ::test_anonymous::SomeProtocolSomeMethodResult,
    ::fidl::internal::NaturalCodingConstraintEmpty>
    final : public ::fidl::internal::NaturalUnionCodingTraits<
                ::test_anonymous::SomeProtocolSomeMethodResult> {};

template <>
struct internal::NaturalCodingTraits<
    ::test_anonymous::Flags, ::fidl::internal::NaturalCodingConstraintEmpty> {
  static constexpr size_t inline_size_v2 = sizeof(uint16_t);
  static constexpr bool is_memcpy_compatible = true;

  static void Encode(internal::NaturalEncoder* encoder,
                     ::test_anonymous::Flags* value, size_t offset,
                     size_t recursion_depth) {
    *encoder->template GetPtr<::test_anonymous::Flags>(offset) = *value;
  }
  static void Decode(internal::NaturalDecoder* decoder,
                     ::test_anonymous::Flags* value, size_t offset,
                     size_t recursion_depth) {
    *value = *decoder->template GetPtr<::test_anonymous::Flags>(offset);
  }
};
template <>
struct internal::NaturalCodingTraits<
    ::test_anonymous::BitsMember,
    ::fidl::internal::NaturalCodingConstraintEmpty> {
  static constexpr size_t inline_size_v2 = sizeof(uint32_t);
  static constexpr bool is_memcpy_compatible = true;

  static void Encode(internal::NaturalEncoder* encoder,
                     ::test_anonymous::BitsMember* value, size_t offset,
                     size_t recursion_depth) {
    *encoder->template GetPtr<::test_anonymous::BitsMember>(offset) = *value;
  }
  static void Decode(internal::NaturalDecoder* decoder,
                     ::test_anonymous::BitsMember* value, size_t offset,
                     size_t recursion_depth) {
    *value = *decoder->template GetPtr<::test_anonymous::BitsMember>(offset);
  }
};

template <>
struct internal::NaturalCodingTraits<
    ::test_anonymous::SomeProtocolSomeMethodError,
    ::fidl::internal::NaturalCodingConstraintEmpty> {
  static constexpr size_t inline_size_v2 = sizeof(uint32_t);
  static constexpr bool is_memcpy_compatible = true;

  static void Encode(internal::NaturalEncoder* encoder,
                     ::test_anonymous::SomeProtocolSomeMethodError* value,
                     size_t offset, size_t recursion_depth) {
    *encoder->template GetPtr<::test_anonymous::SomeProtocolSomeMethodError>(
        offset) = *value;
  }
  static void Decode(internal::NaturalDecoder* decoder,
                     ::test_anonymous::SomeProtocolSomeMethodError* value,
                     size_t offset, size_t recursion_depth) {
    *value =
        *decoder
             ->template GetPtr<::test_anonymous::SomeProtocolSomeMethodError>(
                 offset);
  }
};
template <>
struct internal::NaturalCodingTraits<
    ::test_anonymous::Op, ::fidl::internal::NaturalCodingConstraintEmpty> {
  static constexpr size_t inline_size_v2 = sizeof(uint32_t);
  static constexpr bool is_memcpy_compatible = true;

  static void Encode(internal::NaturalEncoder* encoder,
                     ::test_anonymous::Op* value, size_t offset,
                     size_t recursion_depth) {
    *encoder->template GetPtr<::test_anonymous::Op>(offset) = *value;
  }
  static void Decode(internal::NaturalDecoder* decoder,
                     ::test_anonymous::Op* value, size_t offset,
                     size_t recursion_depth) {
    *value = *decoder->template GetPtr<::test_anonymous::Op>(offset);
  }
};

}  // namespace fidl