tools/fidl/fidlgen_llcpp/goldens/union_natural_types.h.golden

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

#pragma once

#include <fidl/test.union/cpp/common_types.h>
#include <fidl/test.union/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_union {

class StructWithNullableXUnion;

class TestProtocolStrictXUnionHenceResponseMayBeStackAllocatedTopResponse;

class Pizza;

class Pasta;

class TestProtocolFlexibleXUnionHenceResponseMustBeHeapAllocatedTopResponse;

class NullableUnionStruct;

class UnionSandwich;

class Empty;

class UnionWithAttributes;

class Union;

class StrictUnion;

class StrictSimpleXUnion;

class StrictFoo;

class StrictBoundedXUnion;

class ReverseOrdinalUnion;

class StrictPizzaOrPasta;

class PizzaOrPasta;

class FlexiblePizzaOrPasta;

class ExplicitPizzaOrPasta;

class OlderSimpleUnion;

class NewerSimpleUnion;

class FlexibleUnion;

class FlexibleFoo;

class FieldCollision;

class ExplicitXUnion;

class ExplicitUnion;

class ExplicitStrictFoo;

class ExplicitFoo;

class XUnionContainingEmptyStruct;

extern "C" const fidl_type_t test_union_UnionWithAttributesTable;

class UnionWithAttributes {
 private:
  using Storage_ =
      std::variant<
          std::monostate, int64_t>;

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

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

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

  constexpr ::test_union::UnionWithAttributes::Tag Which() const {
    return UnionWithAttributes::IndexToTag(storage_->index()).value();
  }
  static UnionWithAttributes WithX(int64_t val) {
    return UnionWithAttributes(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

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

  UnionWithAttributes(::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_union::UnionWithAttributes>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalUnionMember<::fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintEmpty>());

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

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

  static constexpr std::optional<::test_union::UnionWithAttributes::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::UnionWithAttributes::Tag::kX;
      default:
        return ::test_union::UnionWithAttributes::Tag::kUnknown;
    }
  }
};

extern "C" const fidl_type_t test_union_UnionTable;

class Union {
 private:
  using Storage_ =
      std::variant<
          std::monostate, int32_t, ::std::string, ::std::vector<::std::string>>;

 public:
  // TODO: share union tag types between wire & natural.
  enum class Tag : fidl_union_tag_t {
    kPrimitive = 1,                         // 0x1
    kStringNeedsConstructor = 2,            // 0x2
    kVectorStringAlsoNeedsConstructor = 3,  // 0x3
  };

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

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

  constexpr ::test_union::Union::Tag Which() const {
    return Union::IndexToTag(storage_->index()).value();
  }
  static Union WithPrimitive(int32_t val) {
    return Union(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> primitive() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> primitive() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static Union WithStringNeedsConstructor(::std::string val) {
    return Union(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<2, Storage_> string_needs_constructor() const {
    return ::fidl::internal::UnionMemberView<2, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<2, Storage_> string_needs_constructor() {
    return ::fidl::internal::UnionMemberView<2, Storage_>(storage_);
  }
  static Union WithVectorStringAlsoNeedsConstructor(::std::vector<::std::string> val) {
    return Union(std::make_shared<Storage_>(
        std::in_place_index_t<3>{},
        std::move(val)));
  }

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

  Union(::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_union::Union>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalUnionMember<::fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintString<>>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintString<>>>());

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

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_union::Union::Tag tag) {
    switch (tag) {
      case ::test_union::Union::Tag::kPrimitive:
        return 1;
      case ::test_union::Union::Tag::kStringNeedsConstructor:
        return 2;
      case ::test_union::Union::Tag::kVectorStringAlsoNeedsConstructor:
        return 3;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_union::Union::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::Union::Tag::kPrimitive;
      case 2:
        return ::test_union::Union::Tag::kStringNeedsConstructor;
      case 3:
        return ::test_union::Union::Tag::kVectorStringAlsoNeedsConstructor;
      default:
        return std::nullopt;
    }
  }
};

extern "C" const fidl_type_t test_union_StructWithNullableXUnionTable;

class StructWithNullableXUnion {
 private:
  struct Storage_;

 public:
  StructWithNullableXUnion(Storage_ storage) noexcept : storage_(std::move(storage)) {}
  StructWithNullableXUnion(::std::unique_ptr<::test_union::OlderSimpleUnion> x1) noexcept
      : storage_({.x1 = std::move(x1)}) {}

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

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

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

  const ::std::unique_ptr<::test_union::OlderSimpleUnion>&
  x1() const {
    return storage_.x1;
  }

  ::std::unique_ptr<::test_union::OlderSimpleUnion>& x1() {
    return storage_.x1;
  }

  StructWithNullableXUnion(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : StructWithNullableXUnion(Storage_{
                                                                                             .x1 = {},
                                                                                         }) {}

 private:
  struct Storage_ final {
    ::std::unique_ptr<::test_union::OlderSimpleUnion> x1;
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_union::StructWithNullableXUnion, 16>;
  friend struct ::fidl::internal::MemberVisitor<::test_union::StructWithNullableXUnion>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, ::std::unique_ptr<::test_union::OlderSimpleUnion>, fidl::internal::NaturalCodingConstraintEmpty>{
      &Storage_::x1, 0});
  static constexpr auto kPadding = std::make_tuple();
};

extern "C" const fidl_type_t test_union_StrictUnionTable;

class StrictUnion {
 private:
  using Storage_ =
      std::variant<
          std::monostate, int32_t, ::std::string, ::std::vector<::std::string>>;

 public:
  // TODO: share union tag types between wire & natural.
  enum class Tag : fidl_union_tag_t {
    kPrimitive = 1,                         // 0x1
    kStringNeedsConstructor = 2,            // 0x2
    kVectorStringAlsoNeedsConstructor = 3,  // 0x3
  };

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

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

  constexpr ::test_union::StrictUnion::Tag Which() const {
    return StrictUnion::IndexToTag(storage_->index()).value();
  }
  static StrictUnion WithPrimitive(int32_t val) {
    return StrictUnion(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> primitive() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> primitive() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static StrictUnion WithStringNeedsConstructor(::std::string val) {
    return StrictUnion(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<2, Storage_> string_needs_constructor() const {
    return ::fidl::internal::UnionMemberView<2, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<2, Storage_> string_needs_constructor() {
    return ::fidl::internal::UnionMemberView<2, Storage_>(storage_);
  }
  static StrictUnion WithVectorStringAlsoNeedsConstructor(::std::vector<::std::string> val) {
    return StrictUnion(std::make_shared<Storage_>(
        std::in_place_index_t<3>{},
        std::move(val)));
  }

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

  StrictUnion(::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_union::StrictUnion>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalUnionMember<::fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintString<>>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintString<>>>());

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

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_union::StrictUnion::Tag tag) {
    switch (tag) {
      case ::test_union::StrictUnion::Tag::kPrimitive:
        return 1;
      case ::test_union::StrictUnion::Tag::kStringNeedsConstructor:
        return 2;
      case ::test_union::StrictUnion::Tag::kVectorStringAlsoNeedsConstructor:
        return 3;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_union::StrictUnion::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::StrictUnion::Tag::kPrimitive;
      case 2:
        return ::test_union::StrictUnion::Tag::kStringNeedsConstructor;
      case 3:
        return ::test_union::StrictUnion::Tag::kVectorStringAlsoNeedsConstructor;
      default:
        return std::nullopt;
    }
  }
};

extern "C" const fidl_type_t test_union_StrictSimpleXUnionTable;

class StrictSimpleXUnion {
 private:
  using Storage_ =
      std::variant<
          std::monostate, int32_t, float, ::std::string>;

 public:
  // TODO: share union tag types between wire & natural.
  enum class Tag : fidl_union_tag_t {
    kI = 1,  // 0x1
    kF = 2,  // 0x2
    kS = 3,  // 0x3
  };

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

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

  constexpr ::test_union::StrictSimpleXUnion::Tag Which() const {
    return StrictSimpleXUnion::IndexToTag(storage_->index()).value();
  }
  static StrictSimpleXUnion WithI(int32_t val) {
    return StrictSimpleXUnion(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> i() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> i() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static StrictSimpleXUnion WithF(float val) {
    return StrictSimpleXUnion(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<2, Storage_> f() const {
    return ::fidl::internal::UnionMemberView<2, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<2, Storage_> f() {
    return ::fidl::internal::UnionMemberView<2, Storage_>(storage_);
  }
  static StrictSimpleXUnion WithS(::std::string val) {
    return StrictSimpleXUnion(std::make_shared<Storage_>(
        std::in_place_index_t<3>{},
        std::move(val)));
  }

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

  StrictSimpleXUnion(::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_union::StrictSimpleXUnion>;
  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::NaturalCodingConstraintString<>>());

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

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_union::StrictSimpleXUnion::Tag tag) {
    switch (tag) {
      case ::test_union::StrictSimpleXUnion::Tag::kI:
        return 1;
      case ::test_union::StrictSimpleXUnion::Tag::kF:
        return 2;
      case ::test_union::StrictSimpleXUnion::Tag::kS:
        return 3;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_union::StrictSimpleXUnion::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::StrictSimpleXUnion::Tag::kI;
      case 2:
        return ::test_union::StrictSimpleXUnion::Tag::kF;
      case 3:
        return ::test_union::StrictSimpleXUnion::Tag::kS;
      default:
        return std::nullopt;
    }
  }
};

extern "C" const fidl_type_t test_union_StrictFooTable;

class StrictFoo {
 private:
  using Storage_ =
      std::variant<
          std::monostate, ::std::string, int32_t>;

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

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

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

  constexpr ::test_union::StrictFoo::Tag Which() const {
    return StrictFoo::IndexToTag(storage_->index()).value();
  }
  static StrictFoo WithS(::std::string val) {
    return StrictFoo(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> s() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> s() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static StrictFoo WithI(int32_t val) {
    return StrictFoo(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
  }

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

  StrictFoo(::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_union::StrictFoo>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalUnionMember<::fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintString<>>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintEmpty>());

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

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_union::StrictFoo::Tag tag) {
    switch (tag) {
      case ::test_union::StrictFoo::Tag::kS:
        return 1;
      case ::test_union::StrictFoo::Tag::kI:
        return 2;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_union::StrictFoo::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::StrictFoo::Tag::kS;
      case 2:
        return ::test_union::StrictFoo::Tag::kI;
      default:
        return std::nullopt;
    }
  }
};

extern "C" const fidl_type_t test_union_StrictBoundedXUnionTable;

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

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

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

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

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

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

  StrictBoundedXUnion(::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_union::StrictBoundedXUnion>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalUnionMember<::fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty, 10>>());

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

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

  static constexpr std::optional<::test_union::StrictBoundedXUnion::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::StrictBoundedXUnion::Tag::kV;
      default:
        return std::nullopt;
    }
  }
};

extern "C" const fidl_type_t test_union_TestProtocolStrictXUnionHenceResponseMayBeStackAllocatedTopResponseTable;

class TestProtocolStrictXUnionHenceResponseMayBeStackAllocatedTopResponse {
 private:
  struct Storage_;

 public:
  TestProtocolStrictXUnionHenceResponseMayBeStackAllocatedTopResponse(Storage_ storage) noexcept : storage_(std::move(storage)) {}
  TestProtocolStrictXUnionHenceResponseMayBeStackAllocatedTopResponse(::test_union::StrictBoundedXUnion xu) noexcept
      : storage_({.xu = std::move(xu)}) {}

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

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

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

  const ::test_union::StrictBoundedXUnion&
  xu() const {
    return storage_.xu;
  }

  ::test_union::StrictBoundedXUnion& xu() {
    return storage_.xu;
  }

  TestProtocolStrictXUnionHenceResponseMayBeStackAllocatedTopResponse(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : TestProtocolStrictXUnionHenceResponseMayBeStackAllocatedTopResponse(Storage_{
                                                                                                                                        .xu = ::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{},
                                                                                                                                    }) {}

 private:
  struct Storage_ final {
    ::test_union::StrictBoundedXUnion xu;
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_union::TestProtocolStrictXUnionHenceResponseMayBeStackAllocatedTopResponse, 16>;
  friend struct ::fidl::internal::MemberVisitor<::test_union::TestProtocolStrictXUnionHenceResponseMayBeStackAllocatedTopResponse>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, ::test_union::StrictBoundedXUnion, fidl::internal::NaturalCodingConstraintEmpty>{
      &Storage_::xu, 0});
  static constexpr auto kPadding = std::make_tuple();
};

extern "C" const fidl_type_t test_union_ReverseOrdinalUnionTable;

class ReverseOrdinalUnion {
 private:
  using Storage_ =
      std::variant<
          std::monostate, uint32_t, uint32_t>;

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

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

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

  constexpr ::test_union::ReverseOrdinalUnion::Tag Which() const {
    return ReverseOrdinalUnion::IndexToTag(storage_->index()).value();
  }
  static ReverseOrdinalUnion WithSecond(uint32_t val) {
    return ReverseOrdinalUnion(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> second() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> second() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static ReverseOrdinalUnion WithFirst(uint32_t val) {
    return ReverseOrdinalUnion(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
  }

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

  ReverseOrdinalUnion(::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_union::ReverseOrdinalUnion>;
  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 ReverseOrdinalUnion(std::shared_ptr<Storage_> storage) : storage_(std::move(storage)) {}

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_union::ReverseOrdinalUnion::Tag tag) {
    switch (tag) {
      case ::test_union::ReverseOrdinalUnion::Tag::kSecond:
        return 1;
      case ::test_union::ReverseOrdinalUnion::Tag::kFirst:
        return 2;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_union::ReverseOrdinalUnion::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::ReverseOrdinalUnion::Tag::kSecond;
      case 2:
        return ::test_union::ReverseOrdinalUnion::Tag::kFirst;
      default:
        return std::nullopt;
    }
  }
};

extern "C" const fidl_type_t test_union_PizzaTable;

class Pizza {
 private:
  struct Storage_;

 public:
  Pizza(Storage_ storage) noexcept : storage_(std::move(storage)) {}
  Pizza(::std::vector<::std::string> toppings) noexcept
      : storage_({.toppings = std::move(toppings)}) {}

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

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

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

  const ::std::vector<::std::string>&
  toppings() const {
    return storage_.toppings;
  }

  ::std::vector<::std::string>& toppings() {
    return storage_.toppings;
  }

  Pizza(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Pizza(Storage_{
                                                                          .toppings = {},
                                                                      }) {}

 private:
  struct Storage_ final {
    ::std::vector<::std::string> toppings;
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_union::Pizza, 16>;
  friend struct ::fidl::internal::MemberVisitor<::test_union::Pizza>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::std::string>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintString<16>>>{
      &Storage_::toppings, 0});
  static constexpr auto kPadding = std::make_tuple();
};

extern "C" const fidl_type_t test_union_PastaTable;

class Pasta {
 private:
  struct Storage_;

 public:
  Pasta(Storage_ storage) noexcept : storage_(std::move(storage)) {}
  Pasta(::std::string sauce) noexcept
      : storage_({.sauce = std::move(sauce)}) {}

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

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

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

  const ::std::string&
  sauce() const {
    return storage_.sauce;
  }

  ::std::string& sauce() {
    return storage_.sauce;
  }

  Pasta(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Pasta(Storage_{
                                                                          .sauce = {},
                                                                      }) {}

 private:
  struct Storage_ final {
    ::std::string sauce;
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_union::Pasta, 16>;
  friend struct ::fidl::internal::MemberVisitor<::test_union::Pasta>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, ::std::string, fidl::internal::NaturalCodingConstraintString<16>>{
      &Storage_::sauce, 0});
  static constexpr auto kPadding = std::make_tuple();
};

extern "C" const fidl_type_t test_union_StrictPizzaOrPastaTable;

class StrictPizzaOrPasta {
 private:
  using Storage_ =
      std::variant<
          std::monostate, ::test_union::Pizza, ::test_union::Pasta>;

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

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

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

  constexpr ::test_union::StrictPizzaOrPasta::Tag Which() const {
    return StrictPizzaOrPasta::IndexToTag(storage_->index()).value();
  }
  static StrictPizzaOrPasta WithPizza(::test_union::Pizza val) {
    return StrictPizzaOrPasta(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> pizza() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> pizza() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static StrictPizzaOrPasta WithPasta(::test_union::Pasta val) {
    return StrictPizzaOrPasta(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
  }

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

  StrictPizzaOrPasta(::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_union::StrictPizzaOrPasta>;
  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 StrictPizzaOrPasta(std::shared_ptr<Storage_> storage) : storage_(std::move(storage)) {}

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_union::StrictPizzaOrPasta::Tag tag) {
    switch (tag) {
      case ::test_union::StrictPizzaOrPasta::Tag::kPizza:
        return 1;
      case ::test_union::StrictPizzaOrPasta::Tag::kPasta:
        return 2;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_union::StrictPizzaOrPasta::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::StrictPizzaOrPasta::Tag::kPizza;
      case 2:
        return ::test_union::StrictPizzaOrPasta::Tag::kPasta;
      default:
        return std::nullopt;
    }
  }
};

extern "C" const fidl_type_t test_union_PizzaOrPastaTable;

class PizzaOrPasta {
 private:
  using Storage_ =
      std::variant<
          std::monostate, ::test_union::Pizza, ::test_union::Pasta>;

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

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

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

  constexpr ::test_union::PizzaOrPasta::Tag Which() const {
    return PizzaOrPasta::IndexToTag(storage_->index()).value();
  }
  static PizzaOrPasta WithPizza(::test_union::Pizza val) {
    return PizzaOrPasta(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> pizza() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> pizza() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static PizzaOrPasta WithPasta(::test_union::Pasta val) {
    return PizzaOrPasta(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
  }

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

  PizzaOrPasta(::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_union::PizzaOrPasta>;
  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 PizzaOrPasta(std::shared_ptr<Storage_> storage) : storage_(std::move(storage)) {}

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_union::PizzaOrPasta::Tag tag) {
    switch (tag) {
      case ::test_union::PizzaOrPasta::Tag::kPizza:
        return 1;
      case ::test_union::PizzaOrPasta::Tag::kPasta:
        return 2;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_union::PizzaOrPasta::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::PizzaOrPasta::Tag::kPizza;
      case 2:
        return ::test_union::PizzaOrPasta::Tag::kPasta;
      default:
        return std::nullopt;
    }
  }
};

extern "C" const fidl_type_t test_union_FlexiblePizzaOrPastaTable;

class FlexiblePizzaOrPasta {
 private:
  using Storage_ =
      std::variant<
          std::monostate, ::test_union::Pizza, ::test_union::Pasta>;

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

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

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

  constexpr ::test_union::FlexiblePizzaOrPasta::Tag Which() const {
    return FlexiblePizzaOrPasta::IndexToTag(storage_->index()).value();
  }
  static FlexiblePizzaOrPasta WithPizza(::test_union::Pizza val) {
    return FlexiblePizzaOrPasta(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> pizza() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> pizza() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static FlexiblePizzaOrPasta WithPasta(::test_union::Pasta val) {
    return FlexiblePizzaOrPasta(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
  }

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

  FlexiblePizzaOrPasta(::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_union::FlexiblePizzaOrPasta>;
  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 FlexiblePizzaOrPasta(std::shared_ptr<Storage_> storage) : storage_(std::move(storage)) {}

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_union::FlexiblePizzaOrPasta::Tag tag) {
    switch (tag) {
      case ::test_union::FlexiblePizzaOrPasta::Tag::kPizza:
        return 1;
      case ::test_union::FlexiblePizzaOrPasta::Tag::kPasta:
        return 2;
      case ::test_union::FlexiblePizzaOrPasta::Tag::kUnknown:
        return 0;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_union::FlexiblePizzaOrPasta::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::FlexiblePizzaOrPasta::Tag::kPizza;
      case 2:
        return ::test_union::FlexiblePizzaOrPasta::Tag::kPasta;
      default:
        return ::test_union::FlexiblePizzaOrPasta::Tag::kUnknown;
    }
  }
};

extern "C" const fidl_type_t test_union_ExplicitPizzaOrPastaTable;

class ExplicitPizzaOrPasta {
 private:
  using Storage_ =
      std::variant<
          std::monostate, ::test_union::Pizza, ::test_union::Pasta>;

 public:
  // TODO: share union tag types between wire & natural.
  enum class Tag : fidl_union_tag_t {
    kPizza = 1,  // 0x1
    kPasta = 4,  // 0x4
  };

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

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

  constexpr ::test_union::ExplicitPizzaOrPasta::Tag Which() const {
    return ExplicitPizzaOrPasta::IndexToTag(storage_->index()).value();
  }
  static ExplicitPizzaOrPasta WithPizza(::test_union::Pizza val) {
    return ExplicitPizzaOrPasta(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> pizza() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> pizza() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static ExplicitPizzaOrPasta WithPasta(::test_union::Pasta val) {
    return ExplicitPizzaOrPasta(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
  }

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

  ExplicitPizzaOrPasta(::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_union::ExplicitPizzaOrPasta>;
  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 ExplicitPizzaOrPasta(std::shared_ptr<Storage_> storage) : storage_(std::move(storage)) {}

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_union::ExplicitPizzaOrPasta::Tag tag) {
    switch (tag) {
      case ::test_union::ExplicitPizzaOrPasta::Tag::kPizza:
        return 1;
      case ::test_union::ExplicitPizzaOrPasta::Tag::kPasta:
        return 2;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_union::ExplicitPizzaOrPasta::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::ExplicitPizzaOrPasta::Tag::kPizza;
      case 2:
        return ::test_union::ExplicitPizzaOrPasta::Tag::kPasta;
      default:
        return std::nullopt;
    }
  }
};

extern "C" const fidl_type_t test_union_OlderSimpleUnionTable;

class OlderSimpleUnion {
 private:
  using Storage_ =
      std::variant<
          std::monostate, int64_t, float>;

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

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

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

  constexpr ::test_union::OlderSimpleUnion::Tag Which() const {
    return OlderSimpleUnion::IndexToTag(storage_->index()).value();
  }
  static OlderSimpleUnion WithI(int64_t val) {
    return OlderSimpleUnion(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> i() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> i() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static OlderSimpleUnion WithF(float val) {
    return OlderSimpleUnion(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
  }

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

  OlderSimpleUnion(::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_union::OlderSimpleUnion>;
  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 OlderSimpleUnion(std::shared_ptr<Storage_> storage) : storage_(std::move(storage)) {}

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_union::OlderSimpleUnion::Tag tag) {
    switch (tag) {
      case ::test_union::OlderSimpleUnion::Tag::kI:
        return 1;
      case ::test_union::OlderSimpleUnion::Tag::kF:
        return 2;
      case ::test_union::OlderSimpleUnion::Tag::kUnknown:
        return 0;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_union::OlderSimpleUnion::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::OlderSimpleUnion::Tag::kI;
      case 2:
        return ::test_union::OlderSimpleUnion::Tag::kF;
      default:
        return ::test_union::OlderSimpleUnion::Tag::kUnknown;
    }
  }
};

extern "C" const fidl_type_t test_union_TestProtocolFlexibleXUnionHenceResponseMustBeHeapAllocatedTopResponseTable;

class TestProtocolFlexibleXUnionHenceResponseMustBeHeapAllocatedTopResponse {
 private:
  struct Storage_;

 public:
  TestProtocolFlexibleXUnionHenceResponseMustBeHeapAllocatedTopResponse(Storage_ storage) noexcept : storage_(std::move(storage)) {}
  TestProtocolFlexibleXUnionHenceResponseMustBeHeapAllocatedTopResponse(::test_union::OlderSimpleUnion xu) noexcept
      : storage_({.xu = std::move(xu)}) {}

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

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

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

  const ::test_union::OlderSimpleUnion&
  xu() const {
    return storage_.xu;
  }

  ::test_union::OlderSimpleUnion& xu() {
    return storage_.xu;
  }

  TestProtocolFlexibleXUnionHenceResponseMustBeHeapAllocatedTopResponse(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : TestProtocolFlexibleXUnionHenceResponseMustBeHeapAllocatedTopResponse(Storage_{
                                                                                                                                          .xu = ::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{},
                                                                                                                                      }) {}

 private:
  struct Storage_ final {
    ::test_union::OlderSimpleUnion xu;
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_union::TestProtocolFlexibleXUnionHenceResponseMustBeHeapAllocatedTopResponse, 16>;
  friend struct ::fidl::internal::MemberVisitor<::test_union::TestProtocolFlexibleXUnionHenceResponseMustBeHeapAllocatedTopResponse>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, ::test_union::OlderSimpleUnion, fidl::internal::NaturalCodingConstraintEmpty>{
      &Storage_::xu, 0});
  static constexpr auto kPadding = std::make_tuple();
};

extern "C" const fidl_type_t test_union_NullableUnionStructTable;

class NullableUnionStruct {
 private:
  struct Storage_;

 public:
  NullableUnionStruct(Storage_ storage) noexcept : storage_(std::move(storage)) {}
  NullableUnionStruct(::std::unique_ptr<::test_union::Union> the_union) noexcept
      : storage_({.the_union = std::move(the_union)}) {}

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

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

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

  const ::std::unique_ptr<::test_union::Union>&
  the_union() const {
    return storage_.the_union;
  }

  ::std::unique_ptr<::test_union::Union>& the_union() {
    return storage_.the_union;
  }

  NullableUnionStruct(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : NullableUnionStruct(Storage_{
                                                                                        .the_union = {},
                                                                                    }) {}

 private:
  struct Storage_ final {
    ::std::unique_ptr<::test_union::Union> the_union;
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_union::NullableUnionStruct, 16>;
  friend struct ::fidl::internal::MemberVisitor<::test_union::NullableUnionStruct>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, ::std::unique_ptr<::test_union::Union>, fidl::internal::NaturalCodingConstraintEmpty>{
      &Storage_::the_union, 0});
  static constexpr auto kPadding = std::make_tuple();
};

extern "C" const fidl_type_t test_union_NewerSimpleUnionTable;

class NewerSimpleUnion {
 private:
  using Storage_ =
      std::variant<
          std::monostate, int64_t, ::std::string, ::std::vector<::std::string>>;

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

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

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

  constexpr ::test_union::NewerSimpleUnion::Tag Which() const {
    return NewerSimpleUnion::IndexToTag(storage_->index()).value();
  }
  static NewerSimpleUnion WithI(int64_t val) {
    return NewerSimpleUnion(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> i() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> i() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static NewerSimpleUnion WithS(::std::string val) {
    return NewerSimpleUnion(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<2, Storage_> s() const {
    return ::fidl::internal::UnionMemberView<2, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<2, Storage_> s() {
    return ::fidl::internal::UnionMemberView<2, Storage_>(storage_);
  }
  static NewerSimpleUnion WithV(::std::vector<::std::string> val) {
    return NewerSimpleUnion(std::make_shared<Storage_>(
        std::in_place_index_t<3>{},
        std::move(val)));
  }

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

  NewerSimpleUnion(::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_union::NewerSimpleUnion>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalUnionMember<::fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintString<>>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintString<>>>());

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

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_union::NewerSimpleUnion::Tag tag) {
    switch (tag) {
      case ::test_union::NewerSimpleUnion::Tag::kI:
        return 1;
      case ::test_union::NewerSimpleUnion::Tag::kS:
        return 2;
      case ::test_union::NewerSimpleUnion::Tag::kV:
        return 3;
      case ::test_union::NewerSimpleUnion::Tag::kUnknown:
        return 0;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_union::NewerSimpleUnion::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::NewerSimpleUnion::Tag::kI;
      case 2:
        return ::test_union::NewerSimpleUnion::Tag::kS;
      case 3:
        return ::test_union::NewerSimpleUnion::Tag::kV;
      default:
        return ::test_union::NewerSimpleUnion::Tag::kUnknown;
    }
  }
};

extern "C" const fidl_type_t test_union_FlexibleUnionTable;

class FlexibleUnion {
 private:
  using Storage_ =
      std::variant<
          std::monostate, int32_t, ::std::string, ::std::vector<::std::string>>;

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

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

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

  constexpr ::test_union::FlexibleUnion::Tag Which() const {
    return FlexibleUnion::IndexToTag(storage_->index()).value();
  }
  static FlexibleUnion WithPrimitive(int32_t val) {
    return FlexibleUnion(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> primitive() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> primitive() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static FlexibleUnion WithStringNeedsConstructor(::std::string val) {
    return FlexibleUnion(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<2, Storage_> string_needs_constructor() const {
    return ::fidl::internal::UnionMemberView<2, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<2, Storage_> string_needs_constructor() {
    return ::fidl::internal::UnionMemberView<2, Storage_>(storage_);
  }
  static FlexibleUnion WithVectorStringAlsoNeedsConstructor(::std::vector<::std::string> val) {
    return FlexibleUnion(std::make_shared<Storage_>(
        std::in_place_index_t<3>{},
        std::move(val)));
  }

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

  FlexibleUnion(::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_union::FlexibleUnion>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalUnionMember<::fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintString<>>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintString<>>>());

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

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_union::FlexibleUnion::Tag tag) {
    switch (tag) {
      case ::test_union::FlexibleUnion::Tag::kPrimitive:
        return 1;
      case ::test_union::FlexibleUnion::Tag::kStringNeedsConstructor:
        return 2;
      case ::test_union::FlexibleUnion::Tag::kVectorStringAlsoNeedsConstructor:
        return 3;
      case ::test_union::FlexibleUnion::Tag::kUnknown:
        return 0;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_union::FlexibleUnion::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::FlexibleUnion::Tag::kPrimitive;
      case 2:
        return ::test_union::FlexibleUnion::Tag::kStringNeedsConstructor;
      case 3:
        return ::test_union::FlexibleUnion::Tag::kVectorStringAlsoNeedsConstructor;
      default:
        return ::test_union::FlexibleUnion::Tag::kUnknown;
    }
  }
};

extern "C" const fidl_type_t test_union_FlexibleFooTable;

class FlexibleFoo {
 private:
  using Storage_ =
      std::variant<
          std::monostate, ::std::string, int32_t>;

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

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

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

  constexpr ::test_union::FlexibleFoo::Tag Which() const {
    return FlexibleFoo::IndexToTag(storage_->index()).value();
  }
  static FlexibleFoo WithS(::std::string val) {
    return FlexibleFoo(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> s() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> s() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static FlexibleFoo WithI(int32_t val) {
    return FlexibleFoo(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
  }

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

  FlexibleFoo(::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_union::FlexibleFoo>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalUnionMember<::fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintString<>>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintEmpty>());

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

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_union::FlexibleFoo::Tag tag) {
    switch (tag) {
      case ::test_union::FlexibleFoo::Tag::kS:
        return 1;
      case ::test_union::FlexibleFoo::Tag::kI:
        return 2;
      case ::test_union::FlexibleFoo::Tag::kUnknown:
        return 0;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_union::FlexibleFoo::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::FlexibleFoo::Tag::kS;
      case 2:
        return ::test_union::FlexibleFoo::Tag::kI;
      default:
        return ::test_union::FlexibleFoo::Tag::kUnknown;
    }
  }
};

extern "C" const fidl_type_t test_union_FieldCollisionTable;

class FieldCollision {
 private:
  using Storage_ =
      std::variant<
          std::monostate, int32_t>;

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

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

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

  constexpr ::test_union::FieldCollision::Tag Which() const {
    return FieldCollision::IndexToTag(storage_->index()).value();
  }
  static FieldCollision WithFieldCollisionTag(int32_t val) {
    return FieldCollision(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

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

  FieldCollision(::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_union::FieldCollision>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalUnionMember<::fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintEmpty>());

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

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

  static constexpr std::optional<::test_union::FieldCollision::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::FieldCollision::Tag::kFieldCollisionTag;
      default:
        return std::nullopt;
    }
  }
};

extern "C" const fidl_type_t test_union_ExplicitXUnionTable;

class ExplicitXUnion {
 private:
  using Storage_ =
      std::variant<
          std::monostate, int64_t, float>;

 public:
  // TODO: share union tag types between wire & natural.
  enum class Tag : fidl_union_tag_t {
    kI = 1,  // 0x1
    kF = 4,  // 0x4
    kUnknown = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };
  // Create an unknown value of this union.
  ExplicitXUnion() : storage_(std::make_shared<Storage_>()) {}

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

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

  constexpr ::test_union::ExplicitXUnion::Tag Which() const {
    return ExplicitXUnion::IndexToTag(storage_->index()).value();
  }
  static ExplicitXUnion WithI(int64_t val) {
    return ExplicitXUnion(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> i() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> i() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static ExplicitXUnion WithF(float val) {
    return ExplicitXUnion(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
  }

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

  ExplicitXUnion(::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_union::ExplicitXUnion>;
  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 ExplicitXUnion(std::shared_ptr<Storage_> storage) : storage_(std::move(storage)) {}

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_union::ExplicitXUnion::Tag tag) {
    switch (tag) {
      case ::test_union::ExplicitXUnion::Tag::kI:
        return 1;
      case ::test_union::ExplicitXUnion::Tag::kF:
        return 2;
      case ::test_union::ExplicitXUnion::Tag::kUnknown:
        return 0;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_union::ExplicitXUnion::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::ExplicitXUnion::Tag::kI;
      case 2:
        return ::test_union::ExplicitXUnion::Tag::kF;
      default:
        return ::test_union::ExplicitXUnion::Tag::kUnknown;
    }
  }
};

extern "C" const fidl_type_t test_union_UnionSandwichTable;

class UnionSandwich {
 private:
  struct Storage_;

 public:
  UnionSandwich(Storage_ storage) noexcept : storage_(std::move(storage)) {}
  UnionSandwich(uint32_t a, ::test_union::ExplicitXUnion u, uint32_t b) noexcept
      : storage_({.a = std::move(a),
                  .u = std::move(u),
                  .b = std::move(b)}) {}

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

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

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

  uint32_t
  a() const {
    return storage_.a;
  }

  uint32_t& a() {
    return storage_.a;
  }

  const ::test_union::ExplicitXUnion&
  u() const {
    return storage_.u;
  }

  ::test_union::ExplicitXUnion& u() {
    return storage_.u;
  }

  uint32_t
  b() const {
    return storage_.b;
  }

  uint32_t& b() {
    return storage_.b;
  }

  UnionSandwich(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : UnionSandwich(Storage_{
                                                                                  .a = {},
                                                                                  .u = ::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{},
                                                                                  .b = {},
                                                                              }) {}

 private:
  struct Storage_ final {
    uint32_t a = {};
    ::test_union::ExplicitXUnion u;
    uint32_t b = {};
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_union::UnionSandwich, 32>;
  friend struct ::fidl::internal::MemberVisitor<::test_union::UnionSandwich>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint32_t, fidl::internal::NaturalCodingConstraintEmpty>{
                                                       &Storage_::a, 0},
                                                   ::fidl::internal::NaturalStructMember<Storage_, ::test_union::ExplicitXUnion, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::u, 8}, ::fidl::internal::NaturalStructMember<Storage_, uint32_t, fidl::internal::NaturalCodingConstraintEmpty>{&Storage_::b, 24});
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint64_t>{
                                                       .offset = 0,
                                                       .mask = 0xffffffff00000000ull,
                                                   },
                                                   ::fidl::internal::NaturalStructPadding<uint64_t>{
                                                       .offset = 24,
                                                       .mask = 0xffffffff00000000ull,
                                                   });
};

extern "C" const fidl_type_t test_union_ExplicitUnionTable;

class ExplicitUnion {
 private:
  using Storage_ =
      std::variant<
          std::monostate, int32_t, ::std::string>;

 public:
  // TODO: share union tag types between wire & natural.
  enum class Tag : fidl_union_tag_t {
    kPrimitive = 1,               // 0x1
    kStringNeedsConstructor = 3,  // 0x3
  };

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

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

  constexpr ::test_union::ExplicitUnion::Tag Which() const {
    return ExplicitUnion::IndexToTag(storage_->index()).value();
  }
  static ExplicitUnion WithPrimitive(int32_t val) {
    return ExplicitUnion(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> primitive() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> primitive() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static ExplicitUnion WithStringNeedsConstructor(::std::string val) {
    return ExplicitUnion(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
  }

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

  ExplicitUnion(::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_union::ExplicitUnion>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalUnionMember<::fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintString<>>());

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

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_union::ExplicitUnion::Tag tag) {
    switch (tag) {
      case ::test_union::ExplicitUnion::Tag::kPrimitive:
        return 1;
      case ::test_union::ExplicitUnion::Tag::kStringNeedsConstructor:
        return 2;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_union::ExplicitUnion::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::ExplicitUnion::Tag::kPrimitive;
      case 2:
        return ::test_union::ExplicitUnion::Tag::kStringNeedsConstructor;
      default:
        return std::nullopt;
    }
  }
};

extern "C" const fidl_type_t test_union_ExplicitStrictFooTable;

class ExplicitStrictFoo {
 private:
  using Storage_ =
      std::variant<
          std::monostate, ::std::string, int32_t>;

 public:
  // TODO: share union tag types between wire & natural.
  enum class Tag : fidl_union_tag_t {
    kS = 3,  // 0x3
    kI = 2,  // 0x2
  };

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

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

  constexpr ::test_union::ExplicitStrictFoo::Tag Which() const {
    return ExplicitStrictFoo::IndexToTag(storage_->index()).value();
  }
  static ExplicitStrictFoo WithS(::std::string val) {
    return ExplicitStrictFoo(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> s() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> s() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static ExplicitStrictFoo WithI(int32_t val) {
    return ExplicitStrictFoo(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
  }

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

  ExplicitStrictFoo(::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_union::ExplicitStrictFoo>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalUnionMember<::fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintString<>>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintEmpty>());

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

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_union::ExplicitStrictFoo::Tag tag) {
    switch (tag) {
      case ::test_union::ExplicitStrictFoo::Tag::kS:
        return 1;
      case ::test_union::ExplicitStrictFoo::Tag::kI:
        return 2;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_union::ExplicitStrictFoo::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::ExplicitStrictFoo::Tag::kS;
      case 2:
        return ::test_union::ExplicitStrictFoo::Tag::kI;
      default:
        return std::nullopt;
    }
  }
};

extern "C" const fidl_type_t test_union_ExplicitFooTable;

class ExplicitFoo {
 private:
  using Storage_ =
      std::variant<
          std::monostate, ::std::string, int32_t>;

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

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

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

  constexpr ::test_union::ExplicitFoo::Tag Which() const {
    return ExplicitFoo::IndexToTag(storage_->index()).value();
  }
  static ExplicitFoo WithS(::std::string val) {
    return ExplicitFoo(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

  const ::fidl::internal::UnionMemberView<1, Storage_> s() const {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  ::fidl::internal::UnionMemberView<1, Storage_> s() {
    return ::fidl::internal::UnionMemberView<1, Storage_>(storage_);
  }
  static ExplicitFoo WithI(int32_t val) {
    return ExplicitFoo(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
  }

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

  ExplicitFoo(::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_union::ExplicitFoo>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalUnionMember<::fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintString<>>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintEmpty>());

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

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_union::ExplicitFoo::Tag tag) {
    switch (tag) {
      case ::test_union::ExplicitFoo::Tag::kS:
        return 1;
      case ::test_union::ExplicitFoo::Tag::kI:
        return 2;
      case ::test_union::ExplicitFoo::Tag::kUnknown:
        return 0;
      default: {
        decoder->SetError(::fidl::internal::kCodingErrorUnknownUnionTag);
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_union::ExplicitFoo::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::ExplicitFoo::Tag::kS;
      case 2:
        return ::test_union::ExplicitFoo::Tag::kI;
      default:
        return ::test_union::ExplicitFoo::Tag::kUnknown;
    }
  }
};

extern "C" const fidl_type_t test_union_EmptyTable;

class Empty {
 private:
  struct Storage_;

 public:
  Empty(Storage_ storage) noexcept : storage_(std::move(storage)) {}
  Empty(uint8_t __reserved) noexcept
      : storage_({.__reserved = std::move(__reserved)}) {}

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

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

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

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

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

  Empty(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Empty(Storage_{
                                                                          .__reserved = 0u,
                                                                      }) {}

 private:
  struct Storage_ final {
    uint8_t __reserved = 0u;
  };

  Storage_ storage_;
  Storage_ CloneStorage_() const;

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

extern "C" const fidl_type_t test_union_XUnionContainingEmptyStructTable;

class XUnionContainingEmptyStruct {
 private:
  using Storage_ =
      std::variant<
          std::monostate, ::test_union::Empty>;

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

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

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

  constexpr ::test_union::XUnionContainingEmptyStruct::Tag Which() const {
    return XUnionContainingEmptyStruct::IndexToTag(storage_->index()).value();
  }
  static XUnionContainingEmptyStruct WithEmpty(::test_union::Empty val) {
    return XUnionContainingEmptyStruct(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
  }

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

  XUnionContainingEmptyStruct(::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_union::XUnionContainingEmptyStruct>;
  static constexpr auto kMembers = std::make_tuple(
      ::fidl::internal::NaturalUnionMember<::fidl::internal::NaturalCodingConstraintEmpty>(), ::fidl::internal::NaturalUnionMember<fidl::internal::NaturalCodingConstraintEmpty>());

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

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

  static constexpr std::optional<::test_union::XUnionContainingEmptyStruct::Tag> IndexToTag(size_t index) {
    switch (index) {
      case 1:
        return ::test_union::XUnionContainingEmptyStruct::Tag::kEmpty;
      default:
        return ::test_union::XUnionContainingEmptyStruct::Tag::kUnknown;
    }
  }
};

}  // namespace test_union
namespace fidl {

extern "C" const fidl_type_t test_union_StructWithNullableXUnionTable;

template <>
struct IsFidlType<::test_union::StructWithNullableXUnion> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_TestProtocolStrictXUnionHenceResponseMayBeStackAllocatedTopResponseTable;

template <>
struct IsFidlType<::test_union::TestProtocolStrictXUnionHenceResponseMayBeStackAllocatedTopResponse> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_PizzaTable;

template <>
struct IsFidlType<::test_union::Pizza> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_PastaTable;

template <>
struct IsFidlType<::test_union::Pasta> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_TestProtocolFlexibleXUnionHenceResponseMustBeHeapAllocatedTopResponseTable;

template <>
struct IsFidlType<::test_union::TestProtocolFlexibleXUnionHenceResponseMustBeHeapAllocatedTopResponse> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_NullableUnionStructTable;

template <>
struct IsFidlType<::test_union::NullableUnionStruct> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_UnionSandwichTable;

template <>
struct IsFidlType<::test_union::UnionSandwich> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_EmptyTable;

template <>
struct IsFidlType<::test_union::Empty> : public std::true_type {};

template <>
struct internal::NaturalCodingTraits<::test_union::Empty, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalEmptyStructCodingTraits<::test_union::Empty> {};

extern "C" const fidl_type_t test_union_UnionWithAttributesTable;

template <>
struct IsFidlType<::test_union::UnionWithAttributes> : public std::true_type {};
template <>
struct IsUnion<::test_union::UnionWithAttributes> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_UnionTable;

template <>
struct IsFidlType<::test_union::Union> : public std::true_type {};
template <>
struct IsUnion<::test_union::Union> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_StrictUnionTable;

template <>
struct IsFidlType<::test_union::StrictUnion> : public std::true_type {};
template <>
struct IsUnion<::test_union::StrictUnion> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_StrictSimpleXUnionTable;

template <>
struct IsFidlType<::test_union::StrictSimpleXUnion> : public std::true_type {};
template <>
struct IsUnion<::test_union::StrictSimpleXUnion> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_StrictFooTable;

template <>
struct IsFidlType<::test_union::StrictFoo> : public std::true_type {};
template <>
struct IsUnion<::test_union::StrictFoo> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_StrictBoundedXUnionTable;

template <>
struct IsFidlType<::test_union::StrictBoundedXUnion> : public std::true_type {};
template <>
struct IsUnion<::test_union::StrictBoundedXUnion> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_ReverseOrdinalUnionTable;

template <>
struct IsFidlType<::test_union::ReverseOrdinalUnion> : public std::true_type {};
template <>
struct IsUnion<::test_union::ReverseOrdinalUnion> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_StrictPizzaOrPastaTable;

template <>
struct IsFidlType<::test_union::StrictPizzaOrPasta> : public std::true_type {};
template <>
struct IsUnion<::test_union::StrictPizzaOrPasta> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_PizzaOrPastaTable;

template <>
struct IsFidlType<::test_union::PizzaOrPasta> : public std::true_type {};
template <>
struct IsUnion<::test_union::PizzaOrPasta> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_FlexiblePizzaOrPastaTable;

template <>
struct IsFidlType<::test_union::FlexiblePizzaOrPasta> : public std::true_type {};
template <>
struct IsUnion<::test_union::FlexiblePizzaOrPasta> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_ExplicitPizzaOrPastaTable;

template <>
struct IsFidlType<::test_union::ExplicitPizzaOrPasta> : public std::true_type {};
template <>
struct IsUnion<::test_union::ExplicitPizzaOrPasta> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_OlderSimpleUnionTable;

template <>
struct IsFidlType<::test_union::OlderSimpleUnion> : public std::true_type {};
template <>
struct IsUnion<::test_union::OlderSimpleUnion> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_NewerSimpleUnionTable;

template <>
struct IsFidlType<::test_union::NewerSimpleUnion> : public std::true_type {};
template <>
struct IsUnion<::test_union::NewerSimpleUnion> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_FlexibleUnionTable;

template <>
struct IsFidlType<::test_union::FlexibleUnion> : public std::true_type {};
template <>
struct IsUnion<::test_union::FlexibleUnion> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_FlexibleFooTable;

template <>
struct IsFidlType<::test_union::FlexibleFoo> : public std::true_type {};
template <>
struct IsUnion<::test_union::FlexibleFoo> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_FieldCollisionTable;

template <>
struct IsFidlType<::test_union::FieldCollision> : public std::true_type {};
template <>
struct IsUnion<::test_union::FieldCollision> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_ExplicitXUnionTable;

template <>
struct IsFidlType<::test_union::ExplicitXUnion> : public std::true_type {};
template <>
struct IsUnion<::test_union::ExplicitXUnion> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_ExplicitUnionTable;

template <>
struct IsFidlType<::test_union::ExplicitUnion> : public std::true_type {};
template <>
struct IsUnion<::test_union::ExplicitUnion> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_ExplicitStrictFooTable;

template <>
struct IsFidlType<::test_union::ExplicitStrictFoo> : public std::true_type {};
template <>
struct IsUnion<::test_union::ExplicitStrictFoo> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_ExplicitFooTable;

template <>
struct IsFidlType<::test_union::ExplicitFoo> : public std::true_type {};
template <>
struct IsUnion<::test_union::ExplicitFoo> : public std::true_type {};

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

extern "C" const fidl_type_t test_union_XUnionContainingEmptyStructTable;

template <>
struct IsFidlType<::test_union::XUnionContainingEmptyStruct> : public std::true_type {};
template <>
struct IsUnion<::test_union::XUnionContainingEmptyStruct> : public std::true_type {};

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

}  // namespace fidl